MiniCPM-V 4.7 vs LFM3-VL-2B: The Better Benchmark Score Is the Wrong Sensor

Liquid AI put MiniCPM-V 4.7 1B in its own comparison table and then beat it. On a 62-benchmark suite run by Liquid, LFM3-VL-2B averages 71.4 with reasoning enabled and 62.1 without it; MiniCPM-V 4.7 1B averages 57.5. That is a 13.9-point gap in the small-model tier, and it is the number most comparison posts stop at. It is also the least useful number in the decision, because the two models are not competing for the same slot. One is a 1.92-billion-parameter dense model built to be the whole answer. The other is the cheap half of a two-model system whose expensive half is a 35-billion-parameter mixture of experts.

The version of this matchup that matters depends on which MiniCPM-V 4.7 you mean. The 1B is a 1.55-billion-parameter dense model that fits in a 641 MB Q4_K_M file. The 35B-A3B is 35.2 billion stored parameters with roughly 3 billion active per token, and it is not in Liquid's table at all. LFM3-VL-2B sits between them and is, on Liquid's own numbers, a better general vision model than the small MiniCPM and a much weaker one than the large MiniCPM. Everything below is about which of those facts should decide your architecture.

Three tiers pretending to be two models

LFM3-VL-2B is one artefact. It is 1.92 billion parameters made of a 1.73B language backbone, a 164M in-house vision encoder and a 25M projector, with a 128K-token context, video sampled at two frames per second, and a single set of weights that does detection, OCR, charts and description. Liquid announced the LFM3 family on 27 October 2026; the LFM3-VL-2B repository went up on 19 October.

MiniCPM-V 4.7 is two artefacts with a shared vision tower. The 1B is a dense qwen3_5_text backbone with 24 layers, a 262,144-token context and three linear-attention layers for every full-attention layer. The 35B-A3B is a 256-expert sparse model that routes eight experts per token, keeps the same 262,144-token context, and exists because OpenBMB wanted a large model that could stream experts from storage instead of holding them in memory. Both are Apache-2.0. The weights appeared on 6 and 7 October 2026, the model card followed on 12 October, and ModelBest issued an English press release on 15 October.

So the honest framing is not "2B versus 1B". It is "one model that must do everything" against "a family where you choose how much model each question deserves". If your pipeline asks one question per image, the LFM3-VL-2B shape is simpler and, at the small end, stronger. If your pipeline asks ten thousand cheap questions and one expensive one, the MiniCPM shape is cheaper by construction.

What Liquid's own table says, and what it costs to read it

The 62-benchmark suite is Liquid's, run on vLLM 0.27.1, normalised to a 0–100 scale, with reasoning mode enabled for every model except the rows marked otherwise. A vendor benchmarking a rival is normal and worth reading, but the harness is the vendor's, the prompt set is the vendor's, and the aggregate is the vendor's. Treat the rows as claims.

• MMMU — LFM3-VL-2B 55.7 with thinking, 48.6 without; MiniCPM-V 4.7 1B is not broken out per benchmark in the same table, and OpenBMB publishes no MMMU figure for the 1B at all.

• OCRBench — LFM3-VL-2B 86.3 against 86.1 for MiniCPM-V 4.7 1B on OpenBMB's own page. A 0.2-point difference is noise, and it is the one row where the two vendors are measuring the same thing on the same scale.

• MathVista — 84.2 with thinking and 68.5 without for LFM3-VL-2B, against 74.3 for MiniCPM-V 4.7 1B.

• CharXiv reasoning — 70.2 for LFM3-VL-2B against 48.8 for MiniCPM-V 4.7 1B.

• LongVideoBench — 53.4 for MiniCPM-V 4.7 1B; Liquid does not publish a LongVideoBench row for LFM3-VL-2B in the same table.

The pattern is consistent: with reasoning on, the 2B dense model is better at multi-step visual reasoning and chart interpretation, and roughly level at plain OCR. With reasoning off, the gap collapses to about 4.6 points, which tells you most of the advantage is bought with test-time tokens rather than with parameters. That matters for latency more than for quality, and latency is the axis this comparison usually ignores.

The independent test that reverses the ranking

In late October, WebBrain published a 100-case browser-screenshot benchmark run entirely offline in Q4_K_M GGUF on dual RTX 5060 Ti cards, with a frozen set of screenshots, one production prompt and a deterministic rubric. MiniCPM-V 4.7 1B scored 37 strict passes out of 100 and a 68.2 percent mean rubric score at 1.30 seconds per screenshot. LFM3-VLD-2B — a sibling variant of the Liquid model, not the exact LFM3-VL-2B checkpoint — scored 4 strict passes and 44.7 percent at 2.20 seconds.

The caveat is important and cuts both ways. Under the strict numbered-heading regex, MiniCPM scored zero passes because it wrote section headings as text labels instead of digits. The 37-pass figure comes from re-scoring the same outputs by section name. That is a real formatting failure, and if your downstream parser expects numbered headings, it is disqualifying. But the content score is not close: 68.2 against 44.7, at 60 percent of the latency, on a task — reading a dense browser viewport — that is much closer to production than a chart benchmark.

This is the only independent evaluation either model has in this tier, it is one harness on one GPU pair, and the Liquid model it tested is the VLD variant. It is still more informative than the 62-benchmark aggregate, because it measures the thing you actually do with a small vision model: look at a screen and answer a fixed question quickly.

Licence is the quiet decider

MiniCPM-V 4.7 ships under Apache-2.0 with no revenue condition. LFM3-VL-2B ships under the LFM Open License v1.0, which Liquid describes as free for commercial use below 10 million dollars in annual revenue. Above that line, the terms change and you need to read them.

For a hobby project the difference is theoretical. For a product, it is the first thing a lawyer will ask about, and it is the one row in any comparison table that no benchmark can override. A model that is four points better on chart reasoning and carries a revenue trigger is not automatically the better dependency. This is also where the Apache-2.0 choice on both MiniCPM-V 4.7 sizes does more work than the benchmark numbers: it removes a conversation.

Cadence: the number neither table reports

The esp32-eye cat monitor is the clearest public example of how the MiniCPM 1B is actually used. It runs as a Q4_K_M GGUF behind llama-server on a MacBook and is called at most once every 1.5 seconds, gated by a background-difference check so that most frames never reach it. The same build found the 1B unreliable at telling four similar cats apart and moved identity to the 35B rather than shipping a guess.

That is the deployment profile the benchmark tables do not capture. A model you call every 1.5 seconds needs to be small enough to stay resident, fast enough that the answer arrives before the next frame, and permissive enough that you can ship it. The 1B meets all three. LFM3-VL-2B is 1.25 GB in Q4 and 2.2 seconds per screenshot in the independent test, which is fine for a per-image pipeline and too slow for a 1.5-second gate on the same hardware.

If you want a hosted endpoint instead of a local file, neither model is in OrcaRouter's catalogue today, so the honest answer is that the 1B runs where you put it and the 35B runs on OpenBMB's own API. What a router does offer is the surrounding architecture: one key across more than 200 models, 0% markup on provider list prices, and automatic failover, which is how you keep a two-model pipeline alive when the expensive leg is a single external endpoint. It does not make an unhosted model hosted, and it is worth saying so plainly.

Which one to pick

If you are building a single-model image pipeline and you want the strongest 2B-class generalist on the benchmarks both labs publish, LFM3-VL-2B is the defensible pick, with the licence caveat written down. If you are building an agent that looks at screens on a loop, the independent browser test puts the MiniCPM 1B ahead on both score and latency, and its formatting discipline is the thing to fix in your parser rather than in the model.

If you need a model that can read a 262,144-token document, watch a video, and hold its own on MMMU, neither small model is the answer: that is the 35B-A3B tier, where OpenBMB reports 80.2 on MMMU, 91.2 on OCRBench and 68.9 on LongVideoBench, all vendor-reported and none independently reproduced. The real decision is not which 2B wins. It is whether your pipeline can afford to ask a small question cheaply and a hard question rarely — and if it can, the two-model design is cheaper than any single model that tries to be good at both.

One last calibration. The 13.9-point gap that Liquid publishes is real on Liquid's suite, and the 23.5-point gap that WebBrain publishes is real on WebBrain's suite, and they point in opposite directions because they measure different jobs. Anyone quoting one without the other is selling you a conclusion. The useful question is not which model is better; it is how many times a day you need to ask, and how much you are willing to pay for the answer.