Skip to main content
Back

OpenBMB's MiniCPM5-1B Beats Alibaba's 2B Model at Half the Size

OpenBMB's MiniCPM5-1B tops the 1B open-weights leaderboard with a 17.9 Intelligence Index score, beating 2B models while fitting in 0.5GB

  • MiniCPM5-1B scores 17.9 on the Artificial Analysis Intelligence Index, the highest of any open-weights model at or below 1B parameters by 7.4 points.
  • The model beats Alibaba's Qwen3.5 2B (16.3) despite having half the parameters, and fits in ~0.5GB at INT4 quantization.
  • Key strengths: agentic tool use, code generation, native MCP support, 128K context window, and a dual fast/reasoning mode in one checkpoint.
  • Training used a novel RL + On-Policy Distillation (OPD) pipeline that raised benchmark scores by 16 points and cut overlong responses by 29 percentage points.
  • Available now on Hugging Face under Apache 2.0, with GGUF, MLX, vLLM, SGLang, Ollama, and LM Studio support — no custom kernels required.
  • Known weaknesses: logic traps and non-English languages (especially Japanese) are unreliable; no multimodal input support.

MiniCPM5-1B, the new 1-billion-parameter model from OpenBMB, just redrew the map for what a sub-2B open-weights model can do. It scores 17.9 on the Artificial Analysis Intelligence Index, making it the strongest open-weights model at or below 1B parameters by a margin of 7.4 points, and it actually beats Alibaba's Qwen3.5 2B, a model with twice the parameters, which sits at 16.3.

OpenBMB is a China-based lab jointly founded in 2022 by Tsinghua University's NLP Lab and ModelBest Inc. MiniCPM5-1B is the first checkpoint in the MiniCPM5 series, designed for local assistants, coding agents, tool-use workflows, and reasoning scenarios where a compact model is preferred.

A new ceiling for tiny models

MiniCPM5-1B scores 17.9 on the Artificial Analysis Intelligence Index, the highest of any open-weights model at 1B parameters or below by 7.4 points. The next-most-intelligent open-weights model at this scale is Qwen3.5 0.8B (Reasoning, 10.5). No other open-weights model under 2B parameters has exceeded 15 on the Intelligence Index; its predecessor MiniCPM-V 4.6 1.3B sits at 12.7. That means MiniCPM5-1B didn't just inch forward, it jumped 5 points in intelligence while actually shrinking by 23% in parameter count compared to its predecessor.

The token efficiency story is equally striking. MiniCPM5-1B uses up to 31x fewer output tokens than the larger reasoning peers it surpasses on the Intelligence Index. It used 12.6M output tokens to run the Intelligence Index, ~31x fewer than Qwen3.5 2B (Reasoning, 389M) and ~8x fewer than Qwen3.5 2B (Non-reasoning, 100M). For on-device inference, where every token costs battery and latency, this matters enormously.

There's also a notable result on hallucination. MiniCPM5-1B scores -1 on AA-Omniscience, the highest in its size class, earned by abstaining rather than hallucinating. Sub-2B peers typically attempt a large proportion of questions and hallucinate at high rates, resulting in low AA-Omniscience scores; MiniCPM5-1B declines the majority of questions, an honest posture that AA-Omniscience credits positively. Competing models are pulled down to the -70 to -89 range (Qwen3.5 0.8B Non-reasoning at -89, MiniCPM-V 4.6 1.3B at -85, Exaone 4.0 1.2B Non-reasoning at -83).

What it's actually good at

MiniCPM5-1B reaches 1B-class open-source SOTA, with its advantage most visible in tool use, code generation, and difficult reasoning. This makes it a practical choice for local coding agents, tool assistants, and reasoning assistants. Internally, OpenBMB reports an average score of 42.57 for MiniCPM5-1B Thinking across its selected benchmark set, compared with 26.77 for Qwen3-0.6B Thinking, 25.14 for Qwen3.5-0.8B Thinking, and 35.61 for LFM2.5-1.2B Thinking.

Where it falls short: MiniCPM5-1B shows strengths in agentic tool use and code generation but falters on logic traps. Early hands-on tests also surfaced weak non-English language support. In one demo, the model answered a question about screen protectors with an unrelated response about battery protection, and when prompted in Japanese, it thought in Chinese before producing an off-topic Japanese answer, showing that its Japanese conversational ability is far from practical.

How it was built

The training of MiniCPM5-1B is a full-stack practice of UltraData Tiered Data Management, covering three stages: base training, mid-training, and post-training. During base training, the model goes through stable training and decay training to build core language capability and training stability. It then enters mid-training to further strengthen target capabilities and adapt to the target data distribution. The training corpus is released alongside the model as Ultra-FineWeb, Ultra-FineWeb-L3, and UltraData-Math.

The post-training pipeline is where the real magic happens. Post-training proceeds in three steps: SFT, RL, and OPD. OpenBMB first used 200B tokens of deep-thinking SFT and 200B tokens of hybrid-thinking SFT to establish deep-thinking, hybrid-thinking, and general chat abilities. They then trained specialized RL teachers for math, code, closed-book QA, writing, and related domains, and used On-Policy Distillation (OPD) to distill these teachers back into one release model.

On-Policy Distillation (OPD) is the key technique here. Unlike standard knowledge distillation, where a small model simply mimics a large model's outputs, OPD allows the 1B model to generate its own responses (on-policy), which are then evaluated and corrected based on teacher model distributions. OPD uses reverse KL divergence as the advantage estimate, replacing the original verification-based advantage. At each response position, it takes top-k logits from both the student and teacher models, computes reverse KL on the union of the two token sets, and balances accuracy with training efficiency. OPD reuses the in-domain prompts used to train each RL teacher as distillation data, so no additional data curation is required.

The combined effect of RL and OPD is significant: RL + OPD raises the average score by 16 points on math, code, and instruction-following tasks while cutting the share of responses that hit the max-tokens budget by 29 percentage points. That second number is important, it means the model learned to answer concisely rather than rambling until it hit a hard stop.

The architecture is refreshingly boring

The official model card describes MiniCPM5-1B as a dense 1B-class causal language model built on the standard LlamaForCausalLM architecture. It has 1,080,632,832 total parameters, 679,552,512 non-embedding parameters, 24 layers, grouped-query attention with 16 query heads and 2 key-value heads, and a context length of 131,072 tokens. MiniCPM5-1B uses the standard LlamaForCausalLM architecture, so mainstream inference engines can load it directly: no custom kernels, no model-code fork. That's a deliberate choice: it means the model works out of the box with vLLM, SGLang, llama.cpp, Ollama, and LM Studio without any special setup.

One standout feature is the dual-mode reasoning toggle. The model has a built-in <think> chat template, switchable via enable_thinking. The same checkpoint serves as both a fast assistant and a deliberate reasoner. You don't need two different model files.

Running it yourself

The model is free and available now under Apache 2.0. Getting it running takes a few lines:

# Serve with vLLM (OpenAI-compatible API)
pip install "vllm>=0.21"
vllm serve openbmb/MiniCPM5-1B --port 8000
# Or pull via Ollama for local on-device use
ollama run openbmb/minicpm5

For tool calling, SGLang is the recommended backend. MiniCPM5-1B emits XML-style tool calls and SGLang's built-in minicpm5 parser converts them to OpenAI-compatible tool_calls natively. The model supports native tool calling and the Model Context Protocol (MCP) and carries a 128K-token context window.

To toggle reasoning mode in Python:

from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "openbmb/MiniCPM5-1B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype="auto", device_map="auto")
messages = [{"role": "user", "content": "Solve: what is 17 * 23?"}]
# Fast mode (no chain-of-thought)
inputs = tokenizer.apply_chat_template(
    messages, tokenize=True, add_generation_prompt=True,
    enable_thinking=False,  # flip to True for deliberate reasoning
    return_tensors="pt"
).to(model.device)
outputs = model.generate(inputs, max_new_tokens=128)
print(tokenizer.decode(outputs[0][inputs.shape[-1]:], skip_special_tokens=True))

Multiple formats are available: the BF16 final release (post-trained with RL + OPD), an SFT-only checkpoint (before RL/OPD), a base checkpoint (pre-training only), GGUF for llama.cpp/Ollama/LM Studio, and an MLX/4-bit build for Apple Silicon. INT4 weights come in at just ~0.5GB, making the model runnable on phones, browsers, and laptops.

Practical use cases

  • On-device coding assistant: Its advantage is most visible in agentic tool use, code generation, and difficult reasoning.
  • Local agents with tool calling: The release is aimed at local agent workflows where a phone or laptop can call local tools, query a calendar, search a local database, or reach an MCP research server without sending user data to a cloud API.
  • Long-document processing: The 128K-token context equals roughly 96,000 words of continuous text, enabling long roleplay sessions, full-document digests, and agent contexts that persist across many exchanges.
  • Privacy-first assistants: Everything runs locally, no cloud calls, no data leaving the device.
  • Fine-tuning base: The full training corpus (Ultra-FineWeb, UltraData-Math, UltraData-SFT-2605) is open, and fine-tuning cookbooks are provided for TRL+PEFT, LLaMA-Factory, ms-swift, unsloth, and xtuner.

What this changes

For the last few years, small language models have been awkwardly positioned. They are attractive because they can run closer to the user, but many of them are limited in reasoning, coding, instruction following, long-context handling, or tool use. A 1B model can be easy to run but not necessarily easy to rely on. MiniCPM5-1B is a direct challenge to that assumption.

The combination of 1B-class size, 131,072 token context, and explicit agentic tooling resources shifts the practicality boundary for building local agents on mobile hardware. For practitioners, this lowers barriers to prototyping private, offline assistants and experimenting with tool use without cloud dependencies.

The deeper implication is about training methodology. The OPD approach, where domain-specific RL teachers are trained and then distilled back into a single small model, is a replicable recipe. OpenBMB released all the training data alongside the model. If the technique generalizes, it suggests that the gap between 1B and 7B+ models may be more about training investment than fundamental architectural limits. The benchmark gap MiniCPM5-1B just opened over its peers will likely close quickly, but the playbook it demonstrated will outlast the leaderboard position.