MiniCPM 5 2B: A Small Tool-Calling Model Built for Sub-Agents
MiniCPM 5 2B targets tool calling and sub-agent workloads. Here's how it benchmarks against 4B models and runs locally via llama.cpp and SGLang.
What is MiniCPM 5 2B?
MiniCPM 5 2B is a small language model from OpenBMB, released as the follow-up to the team’s earlier 1B model. It’s built around 2.5 billion parameters, though it’s marketed as a 2B model, and it’s designed specifically for tool calling and agentic tasks rather than general chat or coding. OpenBMB positions it as competitive with 4B-class models on function-calling and agentic benchmarks, while making clear it isn’t meant to compete with larger models on general knowledge or coding output quality.
TL;DR
- MiniCPM 5 2B scales up from OpenBMB’s earlier 1B model, doubling parameters while overhauling the post-training pipeline, and it’s pitched against 4B models rather than other 2B models.
- The model uses a new RL2 training stage with a critic-based reinforcement learning approach, plus on-policy distillation where the model samples its own trajectories and compares them against teacher models.
- On agentic benchmarks it edges out Qwen 2.5B-class models and holds up against some 4B models, but it falls well behind Qwen on harder agentic tests like SweetBench Pro and Terminal Bench.
- In hands-on testing across BFloat16, GGUF (4-bit), and a DeepSpark speculative decoding version, the model ran at very high token speeds, including over 400 tokens per second in llama.cpp on an RTX Pro 6000.
- The model passed function-calling and tool-use tests at high rates, including planning tasks, prompt injection resistance, failure-retry recovery, and distractor-tool tests, with roughly 80% consistency across repeated runs on some harder tests.
- It is weak at general knowledge, long-form writing, and code generation, which matches its intended role: a fast, cheap model for sub-agents that call tools rather than a generalist assistant.
- OpenBMB released multiple checkpoints, including the full post-trained model, SFT-only and mid-training checkpoints, a base model, quantized versions, and a DeepSpark variant tuned for speculative decoding.
How does MiniCPM 5 2B differ from the 1B version?
The core idea carries over from the 1B release: a small, fast model tuned heavily for tool use rather than broad capability. What changed is the scale of data and the structure of post-training. The earlier 1B model split its supervised fine-tuning between 200 billion tokens of “deep thinking” data and 200 billion tokens of hybrid data. MiniCPM 5 2B instead uses 400 billion tokens of deep-thinking-only data for SFT, a shift toward reasoning-style training data rather than a mixed approach.
The bigger change is in reinforcement learning. OpenBMB introduced what it calls RL2, a critic-based RL method that the team says is more stable than standard GRPO-style approaches. Rather than training one generalist RL pass, the model goes through separate RL and on-policy distillation stages organized by domain: reasoning tasks, general tasks, and agentic tasks each get their own expert-style RL pass. The logic is that each expert only needs to be good at one thing, which simplifies the optimization problem compared to training a single model to do everything at once.
The final stage is on-policy distillation, where the model generates its own trajectories, compares them against outputs from larger teacher models, and updates based on the difference. This loop is what OpenBMB credits for much of the benchmark improvement over the 1B generation.
How does it perform on benchmarks?
MiniCPM 5 2B outperforms other models in its own 2B weight class by a wide margin and holds its own against some 4B models, according to OpenBMB’s published comparisons, which include results against Qwen 3.5B-class models on tasks like SweetBench Verified. On general knowledge evaluations like GPQA Diamond, the model trails 4B models but scores far ahead of other 2B models, at a level that would have been associated with models 10 to 100 times larger not long ago.
That said, the scaling story isn’t uniformly positive. On harder agentic benchmarks, specifically SweetBench Pro and Terminal Bench, Qwen’s larger models score substantially higher (roughly double MiniCPM’s score on SweetBench Pro, according to hands-on testing referenced in coverage of the model). This isn’t surprising given that Qwen’s models likely draw on much larger pre-training budgets. It’s also worth noting that Qwen hasn’t updated its smallest models (the 0.5B to 3.8B range) in a while, so a more current comparison may look different once Qwen’s next generation ships.
Is MiniCPM 5 2B good at coding and general tasks?
No, and it isn’t trying to be. Testing across writing, coding, and creative tasks showed clear limits: asked for a 5,000-word essay, the model produced something far shorter. Classic small-model stress tests like the SVG Pelican drawing task and generating a full HTML page produced weak results, not broken, but clearly behind what dedicated coding models produce.
Where the model does well outside of tool use is logic puzzles and math reasoning, both of which it handles quickly and accurately. This lines up with where OpenBMB concentrated training: reasoning and agentic behavior, not general knowledge or code generation. If you need a model to write content or generate production code, this isn’t the tool for that job. If you need something fast that can reason through a multi-step task and hand off to the right function, that’s the design target.
How well does it handle tool calling and agentic tasks?
This is where MiniCPM 5 2B is built to shine, and testing bears that out. Basic function-calling tests, checking whether the model picks the right tool and supplies correct arguments, were passed consistently. On a harder test suite designed to catch failure modes common in agentic models, the model passed all eight tests in one run using the 4-bit GGUF version through llama.cpp.
The harder tests are the interesting ones. Planning tasks that require using multiple tools in sequence, sometimes needing to recover from errors mid-task, were handled well. Prompt injection resistance tests, which check whether a model can be manipulated by malicious content embedded in tool outputs, also passed. Failure-retry tests, where tool calls are deliberately made to fail a couple of times before succeeding, are historically a weak spot for smaller models. MiniCPM 5 2B kept retrying and eventually produced the correct result. Distractor-tool tests, where the model has to find the right information among irrelevant options, also came back accurate. Across repeated runs (roughly 10 per test), pass rates landed around 80% on some of the harder cases, which isn’t perfect but is solid for a model this size.
One notable behavioral trait: when given tools, the model tends to defer to them rather than answer from its own (limited) knowledge. That’s exactly the behavior you want in a sub-agent. A model that confidently makes things up when it should be calling a search or fetch tool is a liability in agentic pipelines. MiniCPM 5 2B appears trained to avoid that failure mode.
How fast does it run locally?
Speed is one of the model’s clearest selling points. Testing across three variants (a BFloat16 version and a DeepSpark speculative-decoding version run on SGLang, plus a 4-bit GGUF version run on llama.cpp) all on a single RTX Pro 6000 showed high throughput across the board. The GGUF version in particular ran at well over 400 tokens per second, and in tool-calling scenarios involving multiple calls and large context (like fetching and parsing a full web page), end-to-end throughput exceeded 500 tokens per second.
One configuration issue surfaced during testing: the SGLang setup returned malformed tool-call output for the BFloat16 and DeepSpark versions, while the GGUF version through llama.cpp worked correctly. This points to a serving-configuration problem rather than a model limitation, since the same weights performed correctly under a different inference stack.
OpenBMB released the model in several forms: the full post-trained checkpoint, an SFT-only checkpoint (before RL), mid-training and base model checkpoints, several quantized versions, and a DeepSpark variant intended for speculative decoding setups. That range gives developers room to pick a checkpoint suited to fine-tuning versus straight deployment.
Frequently Asked Questions
What is MiniCPM 5 2B best used for?
Remy doesn't write the code. It manages the agents who do.
Remy runs the project. The specialists do the work. You work with the PM, not the implementers.
It’s built for tool calling and agentic sub-agent roles, where a fast, small model needs to select the right tool, pass correct arguments, and defer to tool outputs rather than its own knowledge. It’s not designed for general chat, long-form writing, or code generation.
How does MiniCPM 5 2B compare to Qwen models?
It outperforms other models in the 2B class and competes with some 4B models on function-calling benchmarks, but Qwen’s models still lead on harder agentic benchmarks like SweetBench Pro and Terminal Bench. Qwen also likely benefits from a larger pre-training budget.
Can I run MiniCPM 5 2B locally?
Yes. It runs through llama.cpp using GGUF quantized versions and through SGLang or vLLM using the BFloat16 or DeepSpark variants. Testing showed strong throughput on a single high-end consumer GPU (RTX Pro 6000), and the model’s small size should make it workable on more modest prosumer hardware as well.
What is RL2 in MiniCPM 5’s training?
RL2 is OpenBMB’s new critic-based reinforcement learning method, described as more stable than standard GRPO approaches. It’s part of a broader post-training pipeline that also includes domain-specific RL experts and an on-policy distillation stage.
Is MiniCPM 5 2B good at coding?
Not particularly. It performed noticeably worse than dedicated coding models on tasks like generating HTML pages or SVG art. Its strengths are in reasoning, math, and especially tool use and function calling, not code generation.
