MiniCPM5-2B vs LFM2.5 2.6B Base: A Finished Model vs the Raw Material to Build Your Own

Two of the most interesting small-model releases of the past month occupy the same weight class and could not be at more different points in their lives. MiniCPM5-2B is the finished article: a 2.5B dense model that ModelBest and OpenBMB unveiled at the World Artificial Intelligence Conference on July 19, whose open weights quietly went live on Hugging Face on September 6 and 7 with a full post-training pipeline behind them, Apache-2.0, ready to serve. LFM2.5 2.6B Base is Liquid AI's pre-trained text-only checkpoint — the raw substrate the company says is "recommended only for tasks that require heavy fine-tuning," with no instruction tuning, no chat template and zero published benchmarks, because a base model is not scored; the models you fine-tune from it are. Comparing them is really a question about which layer of the build you are shopping for: a model that works tonight, or the ingredients to make your own.

Both cards say "not for direct use" in different dialects, and the vendors put that in the first lines. MiniCPM5-2B's card describes a dense Llama-architecture transformer of 2,516,756,480 total parameters (1,981,982,720 non-embedding), 42 layers, grouped-query attention, a 131,072-token context window in the shipped config, and a post-training story — deep-thinking SFT, specialized RL, On-Policy Distillation — aimed squarely at agentic behavior and tool use. Liquid's card for LFM2.5 2.6B Base describes a 2.69B hybrid that stacks eight grouped-query-attention layers on twenty-two dual-gated short-convolution blocks, pre-trained on roughly 34 trillion tokens across 16 languages with a 128K context, and then stops: the base exists to be continued or fine-tuned into something else. One is a destination; the other is a starting line.

What Liquid actually shipped

LFM2.5 2.6B Base reached Hugging Face in early August as the pre-trained foundation for Liquid's LFM2.5-2.6B family. Its model card shows the family table — the base, and the post-trained LFM2.5-2.6B that Liquid tuned for agentic workloads with tool calling — and is upfront that the base is the text-only checkpoint used to create all the variants. That is its whole job: you take the 2.69B hybrid architecture and 34-trillion-token multilingual foundation and continue pre-training or SFT it on your own domain, after which anything you ship inherits its license terms. There are no benchmarks on the card because there is nothing to benchmark yet; the model has no instruction tuning, so out of the box it continues text rather than answering. It runs from about 2.5GB of weights and is supported by Transformers, vLLM, SGLang, MLX and llama.cpp, which makes it a plausible base for phone- and edge-class fine-tuning projects.

The practical caveat for this matchup: if what you want is a working small model from Liquid, the fair counterpart to MiniCPM5-2B is the post-trained LFM2.5-2.6B, not the Base. The Base is the version you choose when you intend to do the post-training yourself — which is precisely why MiniCPM5-2B's own benchmark table compares against the family's instruction-tuned sibling rather than this raw checkpoint.

What OpenBMB shipped, and why it is different

MiniCPM5-2B arrives as a completed product with the factory blueprints attached. Where Liquid hands you a base and the labor, OpenBMB hands you the whole thing open: the final RL + OPD post-trained checkpoint, GGUF, MLX, GPTQ, base, SFT and draft companions, and — the part that changes the comparison — the training corpora themselves, released under Apache-2.0 as the UltraData family. The model card reports an internal average of 53.9 across a vendor-selected comparison set of 2B-4B open models, with an AIME 2025/2026 of 86.5 and a vendor-run 46.4 on SWE-bench Verified, none of it yet reproduced independently. It is meant to run, not to be trained: the launch pitch was day-zero adaptation across nine chip families and ARM, native tool calling through XML-style calls, and hybrid fast/deliberate response modes for interactive use.

The scoreboard, honestly labeled

• What you get — MiniCPM5-2B: a finished, servable chat model plus open training data. LFM2.5 2.6B Base: a pre-trained base you fine-tune into a finished model.

• Parameters — MiniCPM5-2B: 2.52B total / 1.98B non-embedding, dense Llama-style. LFM2.5 2.6B Base: 2.69B hybrid (8 attention + 22 short-convolution blocks).

• Context — MiniCPM5-2B: 131,072 tokens in the shipped config. LFM2.5 2.6B Base: 128K native.

• Languages — MiniCPM5-2B: English- and Chinese-centered card and data. LFM2.5 2.6B Base: pre-trained on 16 languages.

• Benchmarks — MiniCPM5-2B: full vendor suite (internal average 53.9; unreproduced). LFM2.5 2.6B Base: none published for the base itself, by design.

• License — MiniCPM5-2B: Apache-2.0 for weights and released data. LFM2.5 2.6B Base: LFM Open License v1.0, free under $10M annual revenue, and the cap travels into your derivatives.

The scoreboard above is the same story in six rows: both models are small, 128K-class and Apache-adjacent, but one column ends in a running service and the other ends in a decision about who does the training.

The license is the feature

For a builder, the licensing gap is the least glamorous and most decisive row on that list. OpenBMB put MiniCPM5-2B and its released data under Apache-2.0: you can serve it, fine-tune it and build a commercial product on it with no revenue ceiling and no inherited obligation beyond attribution. Liquid's LFM Open License v1.0 is genuinely open-weight but revenue-conditioned — organizations under $10 million in annual revenue get a broad commercial grant, organizations at or above that line do not, and the cap is inherited by whatever you fine-tune, so a product built on LFM2.5 2.6B Base carries the same ceiling as your company grows. That does not make Liquid's license unreasonable; it makes it a term a startup hoping to scale past the cap has to plan around from day one, and it is the single biggest reason the "finished model" framing matters. If you are building something you intend to grow, Apache-2.0 with open data is a different kind of raw material than a capped license.

The build-versus-buy fork, made concrete

Frame it as build-versus-buy and the choice stops being confusing. MiniCPM5-2B is the buy path: the hard work — post-training a small model for agentic, long-context work — is already done, the license is clean, and your remaining work is serving and evaluation. The cost is that you are adopting someone else's post-training choices, and its headline numbers are one week old and unverified by anyone outside the lab. LFM2.5 2.6B Base is the build path: you buy Liquid's architecture and pretraining and do the post-training yourself, which is the only honest reason to choose a base over the instruction-tuned LFM2.5-2.6B sibling Liquid already sells. That path makes sense when you have a domain, a language, or a behavior profile that off-the-shelf models do not cover. It is strictly more work, it starts with zero published benchmarks, and it carries the revenue cap forward. The payoff is a model no one else has — and, because OpenBMB opened MiniCPM5-2B's own data, you now have a second way to get there: continue-training a proven Apache-2.0 recipe instead of starting from a bare base.

The routing reality for both

Neither checkpoint appears in a hosted catalog today, so the layer question is about the world around them rather than delivery. Once you have served MiniCPM5-2B or fine-tuned LFM2.5 2.6B Base into something of your own, the reversible way to trial either against the hosted models you already use is through one API with automatic failover — a new or derivative stack can stall without taking production down, and provider list prices pass through at 0% markup, so the A/B comparison is cheap. For the build-versus-buy decision itself, though, the honest plan is the same as it always is with small open models: the benchmark that matters is the one you run on your own hardware and your own data, not the one printed on either card.

Which layer are you actually shopping for

Choose MiniCPM5-2B when you want a finished, Apache-2.0 on-device model you can serve tonight and fine-tune on open data — accepting that its impressive card is unverified and needs your own reproduction before it earns production trust. Choose LFM2.5 2.6B Base when you intend to post-train your own model and want Liquid's hybrid architecture and 16-language foundation as the starting weights — accepting the fine-tuning bill, the zero published benchmarks, and the $10 million revenue cap that will ride along in whatever you ship. The two are not rivals for the same job; they are two different jobs on the same hardware, and the only wrong choice is buying one while believing you were buying the other.