MiniCPM5-1B by OpenBMB is the highest-scoring open-source AI model in the sub-2B parameter class as of mid-2026, achieving an average of 42.57 across reasoning, code, math, and agentic benchmarks — 7 points above the next-best model in the same size class. It packs a 128K token context window, hybrid "Think/No-Think" reasoning modes, and native tool-calling into a dense 1.08B-parameter checkpoint that runs on a consumer laptop with as little as 688 MB of RAM (quantized). For builders and small businesses that need AI working locally — for privacy, cost, or speed — this is the model to beat.
Last verified: 2026-08-01 — Pricing/limits/versions change often; last checked today. TL;DR: 1.08B dense params · 128K context · Apache-2.0 · hybrid reasoning · tool-calling · runs in <1 GB (Q4) · SOTA in the 1B class.
What is MiniCPM5-1B and who built it?
MiniCPM5-1B is a dense 1-billion-parameter Transformer language model released by OpenBMB, a research lab jointly founded by Tsinghua University's NLP group and ModelBest Inc. It is the first release in the MiniCPM5 series and is specifically engineered for on-device and resource-constrained deployment — not for cloud-scale benchmarks. The model is licensed under Apache-2.0, meaning anyone can download, run, fine-tune, and commercially deploy it without restrictions.
The "5" in MiniCPM5 refers to the fifth generation of the MiniCPM family, which has been steadily pushing the Pareto frontier of intelligence-per-parameter since 2024. The predecessor, MiniCPM-V 4.6 (1.3B parameters), scored 12.7 on the Artificial Analysis Intelligence Index; MiniCPM5-1B scores 17.9 — a 5.3-point increase with roughly 23% fewer parameters.
How does a 1B model outperform 2B models?
The short answer: a training recipe that combines reinforcement learning with on-policy distillation, applied on top of a massive and carefully curated corpus.
OpenBMB's training pipeline runs in three stages, documented in the GitHub repository:
- Base training — Pre-training on Ultra-FineWeb and UltraData-Math corpora to build core language and mathematical capability.
- Mid-training — Strengthening targeted capabilities (reasoning, code, agentic tasks) and adapting to the target data distribution.
- Post-training — SFT (200B tokens of deep-thinking + 200B tokens of hybrid-thinking), followed by RL with specialized teachers, then On-Policy Distillation (OPD) that compresses multiple teacher models back into one release checkpoint.
The RL + OPD stage alone raises the average benchmark score by 16 points and cuts the share of responses hitting the max-token budget by 29 percentage points, according to OpenBMB's published tech report. The model uses reverse KL divergence as its advantage estimate — a technique that lets the student model learn from teacher logits without simply mimicking them.
What are MiniCPM5-1B's key specifications?
Here is the full technical breakdown, verified against the HuggingFace model card and Ollama listing:
| Specification | Value |
|---|---|
| Architecture | Standard LlamaForCausalLM (no custom kernels) |
| Total parameters | 1,080,632,832 (~1.08B) |
| Non-embedding parameters | 679,552,512 (~680M) |
| Layers | 24 |
| Attention heads (GQA) | 16 Q heads, 2 KV heads |
| Context length | 131,072 tokens (128K) |
| Precision | BF16 |
| License | Apache 2.0 |
| Modality | Text input / text output only |
The standard LlamaForCausalLM architecture is critical for adoption — it means any inference engine that already supports Llama-family models (vLLM, SGLang, llama.cpp, Ollama, LM Studio, MLX) can load MiniCPM5-1B with zero custom code. No forks, no patches, no trust_remote_code=True.
How does hybrid reasoning work (Think vs. No-Think modes)?
MiniCPM5-1B includes a built-in chat template that supports two reasoning modes toggled by a single flag: enable_thinking. This is the "hybrid thinking" feature.
- Think mode (
enable_thinking=True): The model engages in deliberate, step-by-step reasoning before producing its answer. Best for coding, math, planning, and complex multi-step tasks. Recommended sampling:temperature=0.9, top_p=0.95. - No-Think mode (
enable_thinking=False): The model responds immediately without an intermediate reasoning phase. Best for fast chat, simple Q&A, and high-throughput scenarios. Recommended sampling:temperature=0.7, top_p=0.95.
Both modes use the same checkpoint — you switch at inference time. This eliminates the need to maintain two separate models (one for speed, one for quality) which is how most small-model deployments work today.
This capability matters for real-world use: you can run the same model as a snappy chatbot during the day and as a deep reasoner for batch processing at night, all from one 688 MB file. The training recipe includes 200B tokens of hybrid-thinking SFT data specifically to make this mode-switching reliable.
Can MiniCPM5-1B call tools and function as an agent?
Yes — tool use is one of MiniCPM5-1B's headline strengths. The model emits XML-style tool calls that are converted to OpenAI-compatible tool_calls by inference engines. SGLang is the recommended backend for tool calling because it ships a built-in minicpm5 parser:
python -m sglang.launch_server --model-path openbmb/MiniCPM5-1B --port 30000 \
--tool-call-parser minicpm5
The model scored 25.1% on the BFCL v4 (Berkeley Function Calling Leaderboard v4) and 22.7% on LiveCodeBench Pro, according to data aggregated by BenchLM.ai. Those are modest numbers in absolute terms — they trail large frontier models by a wide margin — but they are strong for the 1B class, where most models cannot reliably emit structured tool calls at all.
For practical agent workflows, this means MiniCPM5-1B can fill out forms, pull API data, and execute multi-step task chains when hooked up to a framework like SGLang. If you're building agent operating systems or evaluating free AI agent tools, MiniCPM5-1B is one of the few sub-2B models worth including in the test set.
How to run MiniCPM5-1B locally (step-by-step)
There are three practical deployment paths, depending on your hardware and whether you need tool calling.
Method 1: Ollama (fastest setup, works on any laptop)
Ollama is the simplest path — one command and you're chatting with the model:
# Download and run in one step
ollama run openbmb/minicpm5
# Or pull first, then run separately
ollama pull openbmb/minicpm5
Ollama serves the model on http://localhost:11434 with an OpenAI-compatible API. Available tags:
| Tag | Size | Format | Best for |
|---|---|---|---|
minicpm5:latest |
688 MB | Q4_K_M | Default, balances speed and quality |
minicpm5:q4_K_M |
688 MB | Q4_K_M | Same as latest — 4-bit quantized |
minicpm5:q8_0 |
1.2 GB | Q8_0 | Higher quality, still fast |
minicpm5:fp16 |
2.2 GB | FP16 | Full precision, best quality |
The Q4 quantization at 688 MB means MiniCPM5-1B can run on machines with as little as 2 GB of free RAM. If you've previously tried to run larger models with streaming tricks, a 1B model is a very different experience — it loads in seconds and responds near-instantly on CPU.
Method 2: vLLM (GPU, high-throughput serving)
If you have an NVIDIA GPU and want to serve the model as an API endpoint:
pip install "vllm>=0.21"
vllm serve openbmb/MiniCPM5-1B --port 8000
At ~1.1B params, the model fits easily on a single GPU (TP=1). To conserve VRAM on small GPUs, drop the context: --max-model-len 8192. Use --enforce-eager if CUDA graph compilation OOMs.
Tool calling on vLLM requires a plugin parser that is not yet in the v0.21.0 or v0.22.0 releases (the minicpm5 parser merged to main on May 27, 2026 but is not in a stable release). Until v0.23+, load it as a plugin from the MiniCPM repo:
vllm serve openbmb/MiniCPM5-1B --port 8000 \
--enable-auto-tool-choice \
--tool-parser-plugin /path/to/MiniCPM/tool_parsers/minicpm5xml_tool_parser.py \
--tool-call-parser minicpm5
Method 3: MLX (Apple Silicon, optimized)
For Mac users, OpenBMB provides an MLX 4-bit variant tuned for Apple Silicon:
pip install mlx-lm
mlx_lm.generate --model openbmb/MiniCPM5-1B-MLX --prompt "Explain hybrid reasoning."
OpenBMB also ships a "Desktop Pet" app — a local LLM companion that runs MiniCPM5-1B via a llama.cpp sidecar with an Electron UI, supporting Apple Silicon, NVIDIA GPU, and CPU. It works with Cursor, Claude Code, and Codex, and supports LoRA-based persona switching. Grab it from the MiniCPM-Desk-Pet releases.
How does MiniCPM5-1B compare to other small open-source models?
Based on the Artificial Analysis Intelligence Index (independently measured, not vendor-reported):
| Model | Params | Type | Intelligence Index | Key advantage |
|---|---|---|---|---|
| MiniCPM5-1B | 1.08B | Hybrid | 17.9 | Best intelligence-per-parameter |
| Qwen3.5 2B | 2B | Reasoning | 16.3 | Strong overall, 2x the params |
| MiniCPM-V 4.6 | 1.3B | Non-reasoning | 12.7 | Predecessor, multimodal |
| Qwen3.5 0.8B | 0.8B | Reasoning | 10.5 | Smallest, weakest |
MiniCPM5-1B beats Qwen3.5 2B by 1.6 points despite having less than half the parameters. It also beats Qwen3.5 0.8B by 7 points. Among open-weights models under 2B parameters, no other model has exceeded 15 on the Intelligence Index — MiniCPM5-1B at 17.9 is in a class of its own.
A standout finding from Artificial Analysis: MiniCPM5-1B scored -1 on the AA-Omniscience test (a measure of honest abstention — negative scores mean the model refuses questions it cannot answer rather than hallucinating). Peer models in the sub-2B class score -70 to -89, meaning they hallucinate frequently. For business workflows where accuracy matters more than having an answer for everything, this honest behavior is a meaningful differentiator.
On OpenBMB's own benchmark comparisons, MiniCPM5-1B was compared against LFM2.5-1.2B-Thinking, Qwen3-0.6B/think, and Qwen3.5-0.8B/think. Within that set, it scored 42.57 average versus 35.61 for the next-best — with its advantage most visible in tool use, code generation, and competition math.
Is MiniCPM5-1B actually better than what's already available?
The answer depends on what you're optimizing for. If you need raw problem-solving power and have cloud budget, frontier models still win by a large margin — MiniCPM5-1B scores 22.7% on LiveCodeBench Pro versus 90.8% for top-tier models, per BenchLM. But if you need a model that:
- Runs entirely offline on consumer hardware
- Costs $0 per query (no API calls, no cloud bills)
- Keeps your data private (nothing leaves your machine)
- Still handles coding, tool use, and reasoning competently for the class
- Has a 128K context window (enough for long documents and full codebases)
...then MiniCPM5-1B is the best option in its size tier. The training innovations — particularly the RL + OPD stage — are what let a 1B model punch above its weight. Understanding the post-RLHF training landscape helps explain why techniques like on-policy distillation produce outsized gains in small models: every parameter has to work harder, so training quality matters more than raw scale.
What can you actually build with MiniCPM5-1B?
Here are practical use cases where a 1B local model adds real value:
1. Private document Q&A Load a 128K-token document (roughly 350-400 pages of text) into context and ask questions. Because the model abstains rather than hallucinates (AA-Omniscience score: -1), it will tell you when it doesn't know instead of inventing answers. This is ideal for legal, medical, or financial documents where accuracy is non-negotiable. For a deeper comparison of how to structure AI for local business automation, a local model keeps client data in-house.
2. Code autocomplete on your machine At 688 MB (Q4), MiniCPM5-1B can run as a background process alongside your IDE, providing code completions and explanations without sending your codebase to a cloud API. LiveCodeBench v6 scores 33.5% — modest in absolute terms, but enough for boilerplate generation and function-level assistance.
3. Tool-calling agents for small businesses
Wire up SGLang with the minicpm5 tool parser and you have a locally-running agent that can call APIs, fill forms, and execute multi-step workflows. The 25.1% BFCL v4 score means roughly 1 in 4 tool calls will execute correctly on the first attempt — acceptable for supervised workflows where a human verifies the result, not for fully autonomous pipelines.
4. Fine-tuned specialists MiniCPM5-1B supports five fine-tuning frameworks (TRL, LLaMA-Factory, MS-Swift, Unsloth, XTuner). A LoRA adapter for a specific domain (e.g., customer support for your product) costs a few hundred MB on top of the base model. This mirrors the Mixture-of-LoRA approach where one base model serves multiple specialists — except here the base model is tiny enough to run on a phone.
What are the limitations of MiniCPM5-1B?
Being honest about boundaries is part of how we build trust:
- Not multimodal. MiniCPM5-1B handles text only. If you need vision (image understanding), look at the predecessor MiniCPM-V 4.6 or wait for a multimodal MiniCPM5 variant.
- Small-model benchmarks are not frontier benchmarks. A 42.57 average on 1B-class benchmarks is impressive for its class but does not make it competitive with 70B+ models on hard reasoning tasks.
- Tool-calling accuracy is moderate. 25.1% on BFCL v4 means the model gets about a quarter of function calls right in benchmark conditions. For production agent workflows, plan for human verification.
- LLM context windows shrink in practice. While 128K is the theoretical maximum, many benchmarks test shorter contexts, and real-world performance at the context boundary is less tested. vLLM's own recipe suggests dropping to 8K-32K for small GPU VRAM, which means you may not be using the full 128K in practice.
- Newer model, less tooling maturity. The vLLM tool parser is not yet in a stable release. Ollama, SGLang, and HuggingFace Transformers support is current; other ecosystems may lag.
- Single-language focus. While bilingual (English/Chinese) support is documented, multilingual performance on languages beyond those two is not benchmarked.
What this means for you
If you're a builder or small business owner evaluating local AI, MiniCPM5-1B changes the calculus in three concrete ways:
- The cost floor dropped. A model that scores 17.9 on the Intelligence Index and runs in 688 MB means you can deploy capable AI on hardware you already own — no cloud API budget, no GPU rental, no ongoing costs. For teams exploring whether to build a free AI agent operating system, MiniCPM5-1B is now the model to put at the core.
- Privacy is default, not a feature. When the model runs on your machine, no prompt or document ever touches a server. For client work (legal, medical, financial) this removes a procurement hurdle that blocks most cloud AI adoption in regulated industries.
- The 1B class is no longer a toy. A year ago, sub-2B models could barely hold a conversation. Kimi K3 and other large open-source models get the headlines, but the real shift for practical AI adoption is that 1B-class models now do real work. MiniCPM5-1B's hybrid reasoning, 128K context, and tool-calling make it usable for actual pipelines, not just demos.
The practical action: download Ollama, run ollama run openbmb/minicpm5, and test it on a real workflow from your business. If it handles the task at acceptable quality, you've just cut your AI API bill to zero for that use case.
FAQ
Q: How much RAM does MiniCPM5-1B need to run locally?
A: The Q4_K_M quantized version on Ollama is 688 MB and runs on machines with as little as 2 GB of free RAM. The full-precision FP16 version is 2.2 GB and requires roughly 4 GB of free RAM for inference. The model also ships as an MLX 4-bit variant optimized for Apple Silicon.
Q: Can MiniCPM5-1B replace GPT-4 or Claude for business tasks?
A: No — MiniCPM5-1B scores 17.9 on the Artificial Analysis Intelligence Index, while frontier models score 60+. It is best used for tasks within its capability bounds: document Q&A, code completion boilerplate, structured output generation, and supervised tool-calling workflows where a human verifies the result.
Q: What is hybrid reasoning and why does it matter?
A: Hybrid reasoning means one model checkpoint can switch between a fast "No-Think" mode (instant responses for simple queries) and a deliberate "Think" mode (step-by-step reasoning for complex tasks) via the enable_thinking flag. This eliminates the need to deploy two separate models — one for speed, one for quality — reducing operational complexity and storage.
Q: Which inference backend should I use for tool calling?
A: SGLang is the recommended backend for tool calling because it ships a built-in minicpm5 parser that converts the model's XML-style tool calls to OpenAI-compatible tool_calls natively. On vLLM, the tool parser is not yet in a stable release (expected v0.23+); until then you need to load it as a plugin from the MiniCPM GitHub repository.
Q: Is MiniCPM5-1B open source and free for commercial use?
A: Yes. The model is released under the Apache-2.0 license, which permits commercial use, modification, and redistribution. Training data and some training code are partially released (Ultra-FineWeb, UltraData-SFT-2605) but not all components are open.
Q: How does MiniCPM5-1B compare to Gemma 4 QAT or other small models?
A: MiniCPM5-1B scores 17.9 on the Artificial Analysis Intelligence Index — the highest of any open-weights model at 1B parameters or below, ahead of Qwen3.5 2B (16.3) and MiniCPM-V 4.6 (12.7). Gemma 4 QAT is another strong option for on-device AI at ~1 GB, but published benchmark head-to-heads are limited. The key differentiator: MiniCPM5-1B abstains rather than hallucinates (AA-Omniscience: -1), while most small peers hallucinate frequently (scores of -70 to -89).
Discussion
0 comments