AgentCPM-Explore goes open source: 4B parameters break the performance barrier for on-device agent models

2026-01-13

While the whole industry is still debating whether 30B can challenge trillion-parameter models, we offer a more radical answer: 4B. No trillion-parameter compute pileup, no brute-force injection of millions of data points. AgentCPM-Explore, an agent model jointly developed by the Tsinghua University NLP lab, Renmin University of China, ModelBest, and the OpenBMB open-source community, is built on a model with just 4B parameters. On deep exploration tasks it achieves SOTA among models of the same size, catches up with or even surpasses 8B-class SOTA models, and matches some 30B+ and closed-source large models — bringing long-horizon task handling with large models within reach of on-device deployment.

💡 AgentCPM-Explore highlights at a glance

Breaking the parameter barrier: the first 4B on-device model capable of handling eight long, difficult agent tasks including GAIA, Xbench, and BrowserComp, redefining the performance ceiling for small models;

Long-horizon deep exploration: up to more than 100 rounds of non-repeating, stable environment interaction, continuing deep exploration until the task is completed accurately;

Full-pipeline open source: beyond the model itself, we also open-source the unified tool sandbox management and scheduling platform AgentDock, the fully asynchronous reinforcement learning training framework AgentRL, and the one-click agent capability evaluation platform AgentToLeaP, enabling end-to-end reproduction and custom extensions by the community.

➤ Related links

Github:

🔗 https://github.com/OpenBMB/AgentCPM

HuggingFace:

🔗 https://huggingface.co/openbmb/AgentCPM-Explore

ModelScope:

🔗 https://modelscope.cn/models/OpenBMB/AgentCPM-Explore

GitCode:

🔗 https://gitcode.com/OpenBMB/AgentCPM

Modelers:

🔗 https://modelers.cn/models/OpenBMB/AgentCPM-Explore

Higher capability density: SOTA performance for an on-device agent model

On mainstream agent benchmarks — GAIA, HLE, BrowserComp, BrowserComp (ZH), WebWalker, FRAMES, Xbench-DeepResearch, and Seal-0 — AgentCPM-Explore demonstrates extreme parameter efficiency. It not only achieves SOTA among same-size models but also catches up with or surpasses SOTA models with twice the parameters (8B class), matching some 30B+ and closed-source large models.

Table 1: Leaderboard results on eight agent evaluation tasks

On Xbench-DeepResearch, AgentCPM-Explore outperforms closed-source models such as OpenAI-o3 and Claude-4.5-Sonnet, clearly exceeding the performance trend line of SOTA models across different scales and demonstrating higher capability density.

Figure 1: Analysis of model performance on the Xbench dataset (Note: deep search tasks typically show large sampling variance, up to 20%. AgentCPM-Explore (and MiroThinker) uses the rigorous Avg@8 setting; compared with the industry’s single-run or 3-run settings, this keeps variance error within 2%, providing the most realistic and reproducible performance comparison.)

Wider capability boundary: unlocking the full potential of on-device agent models

A 4B on-device model can get almost every GAIA question right! As the figure shows, with stable post-training on the AgentDock and AgentRL infrastructure, AgentCPM-Explore achieves a multifold performance jump over Qwen3-4B-thinking-2507 and, given multiple attempts, can solve more than 95% of GAIA text tasks. Small models are not “capability-limited”; their potential is underestimated. With the right training framework, on-device models are fully capable of solving the vast majority of complex problems.

Figure 2: Capability boundaries of the original Qwen3-4B-thinking-2507 model versus the post-trained AgentCPM-Explore

More intelligent behavior: on-device agent models that think like humans

On deep exploration tasks, AgentCPM-Explore breaks the stereotype that small models can only rote-learn. As shown in the video, faced with a complex question — “Among the birthplaces of all U.S. presidents, which two cities are farthest apart from east to west?” — it reasons like an experienced human researcher:

It questions: it refuses to trust tools blindly. When it finds “Brookline, MA” listed as the easternmost point, it judges that the summary may have missed key information and decisively asks to re-check the full dataset;

It seeks truth: unsatisfied with compressed secondhand information, it actively looks for complete original data so decisions rest on the full picture;

It adapts: if search fails, it scrapes tables; if the path is wrong, it queries databases. From general search to pinpointing sources on GitHub, it adjusts tactics in real time based on feedback;

It persists: repeated failed searches do not discourage it; it keeps looking for alternative sources until it uncovers the most reliable data.

This article includes video content. Please view it in the original WeChat post.

Full-pipeline open-source infrastructure: built for custom extensions

We have open-sourced not just the model but the entire pipeline code that takes it from the base model (GAIA 25.24%) to the SOTA model (GAIA 63.90%). With the three infrastructure components below, developers can easily reproduce the training process that doubles performance and quickly achieve private deployment and custom extensions.

(1) AgentDock: a unified tool sandbox management and scheduling platform

High-concurrency tool integration: native support for 16 MCP services and more than 100 tools. Multi-version polling and load balancing support 100+ QPS high-concurrency calls for core high-frequency tools.

Robust fault tolerance: output standardization, automatic retries, service self-healing, and automatic fallback to backup tools keep long-horizon tasks running stably.

Unified sandbox management: unified control of task distribution, container orchestration, and dynamic routing. The client hosting the agent only needs to care about the “capability interface,” not complex networking and concurrency details. Tools are hot-pluggable and elastically scalable.

(2) AgentRL: a minimal, efficient asynchronous reinforcement learning framework

Zero-barrier onboarding: a standard ChatCompletions interface is all it takes to plug into the training pipeline.

Minimal codebase: the core implementation spans just 7 files and 1,000+ lines of code, greatly lowering the barrier to learning and secondary development and making it easy to validate new ideas quickly.

Fully asynchronous training and inference on the same GPU: sampling and training run as a fully asynchronous pipeline on the same GPU, squeezing maximum performance out of the hardware.

Decoupling and parallelism: training and sampling are fully decoupled, and sampling processes scale independently. Compatible with native PyTorch parallelism plus FSDP2/Tensor Parallel/Context Parallel, it easily supports 128K+ long-text training.

(3) AgentToLeaP: one-click evaluation platform for agent capabilities

One-click, fully automated: one-click evaluation on eight mainstream leaderboards including GAIA and HLE; a single command starts the full evaluation.

Modular extension: evaluation sets are managed independently and results are output uniformly. Developers can follow the docs to plug in custom test sets with ease.

What makes an on-device model punch above its weight

With limited parameter capacity, a 4B model has very little margin for error on long-horizon, highly interactive agent tasks. In practice we identified three core challenges to improving small-model agent performance and found effective ways to address them.

Model merging to overcome SFT overfitting. Small models easily fall into rote memorization during SFT. In our experiments, simply changing irrelevant tool descriptions in the prompt caused a sharp drop in performance. This is classic overfitting: the model sacrifices general decision-making ability to memorize specific task patterns. We use parameter merging to combine the trained “specialized model” with the pre-training “general model.” The mechanism: general parameters shared by both models are preserved, complementary specialized capabilities are strengthened, and random noise parameters produced by overfitting cancel each other out in the merge. Measurements show the merged model improves about 7% on agent tasks, effectively balancing general and specialized ability.

Signal denoising to correct RL reward bias. Agent task trajectories often run dozens of steps, and small models are extremely sensitive to negative signals along long chains. If a long sequence fails at the last step, conventional RL propagates the penalty back through the entire chain, so correct intermediate reasoning steps are also wrongly punished and training collapses. We apply strict reward-signal denoising: we select only trajectories that genuinely carry policy-update value, and for long samples that ultimately fail we do not penalize the whole trajectory. This keeps negative signals from contaminating the correct reasoning logic the model has already learned, protecting fragile small-model training.

Information refinement to counter long-context interference. During inference, verbose noise returned by web pages has an outsized effect on small models. Comparative experiments show that summarizing context with models of different capability (for example, Qwen3-4B vs. DeepSeek-V3.1) can produce a 10% difference in final GAIA performance. We introduced a context information refinement mechanism: context management tools or multi-model collaboration take charge of filtering and summarizing web content before information reaches the 4B model. By building a high-quality “learning environment,” we let the small model focus on key information and avoid getting lost in noise.

We will describe further details in the technical report.

Building the next generation of the on-device agent ecosystem

Intelligence has no limits. On this low-barrier, high-efficiency “on-device agent model research platform,” we invite partners from everywhere to join us:

Researchers: boldly test new ideas on our framework, reproduce experiments, and even challenge our conclusions;

Engineers: help us optimize training/inference efficiency and support more base models to deliver a better engineering experience;

Benchmark enthusiasts: push evaluation with trickier, more challenging test cases and help us find blind spots we have not covered.

We believe the future of on-device agent models is not only vast but, thanks to open source, within reach. Let’s explore it together 🚀

📧 Partnership contact: agentcpm@modelbest.cn;

💬 Technical discussion: scan the QR code below to join the group. We look forward to your suggestions and feedback.