LFM3-VL-2B: A 1.92B Vision Model Whose Headline Score Hangs on One Switch

LiquidAI/LFM3-VL-2B existed in public for eight days before Liquid AI said a word about it. The Hugging Face repository was created on October 19, 2026, and a GGUF build appeared the same evening; the vendor's announcement — a blog post, a model collection, a card with a full benchmark table — landed on October 27. The model it replaces, LFM2.5-VL-3B, is the obvious yardstick: it is 3.1B parameters to the new model's 1.92B, and on Liquid's own 62-benchmark suite the new one averages 71.4 against the old one's 57.6. The same card also records a second number that gets far less attention: with thinking disabled, LFM3-VL-2B averages 62.1. That single configuration flag is worth 9.3 points, and it is the difference between a decisive generational win and a modest one.

This piece covers what is actually on the record as of October 28 — the repository timeline, the specs, the benchmark table and its caveats — and marks clearly where the evidence stops.

What appeared, and when

The timeline matters because it explains why the model arrived with no coverage. Liquid AI did not publish a teaser, a waitlist or a research post. It uploaded weights and a model card, and the card sat there. Third-party trackers noticed the repository, and the first public writing about LFM3-VL-2B was speculation built on an unmerged inference-framework pull request rather than anything from the vendor.

• Repository created — October 19, 2026, 19:51 UTC, according to the Hugging Face API.

• GGUF repository created — October 19, 2026, 20:29 UTC, thirty-eight minutes later.

• Card last modified — October 27, 2026, 16:24 UTC, the day of the announcement.

• Vendor announcement — October 27, 2026: a family blog post, a Hugging Face blog post, and a model collection.

So the accurate description is not "shipped quietly and still unannounced." It is "shipped quietly, then announced eight days later." Anyone who wrote up the repository during that window was describing a real, downloadable checkpoint, but not a product with a stated position in Liquid's lineup. That position now exists: LFM3-VL-2B is the vision member of a six-model family built on a shared 1.7B base, and the vendor's framing is on-device visual understanding — documents, charts, app screens, object finding, and spatial reasoning for robots.

The model, in the card's own numbers

Liquid's card is unusually specific about where the parameters went, which is worth noting because "2B" in a model name usually hides more than it reveals.

• Total parameters — 1.92B: a 1.73B language model, a 164M vision encoder, and a 25M projector.

• Encoder — built in-house, convolution plus attention, replacing the SigLIP2 tower used in the LFM2.5 vision models.

• Modalities — text, images and video in; text out. It is the first LFM vision model to accept video, sampled at 2 frames per second.

• Visual tokenisation — each 2×2 block of patches becomes one language token, at native resolution.

• Context — 128K tokens, input plus output, with a maximum position of 128,000.

• Licence — the LFM Open License v1.0, the same non-permissive-but-open terms as the rest of the family.

• Pre-training — the LFM3-1.7B-Base trunk, 22T tokens in total, with a 128K context extension and a 256K extension used during mid-training.

• Not recommended for — coding, multi-turn conversation, or complex reasoning, per the card's own guidance.

That last line is the one to read twice. A model that is explicitly not recommended for multi-turn conversation is also a model whose 128K context window will be hard to use in the way long context is normally used. The window is real and it is nearly four times the 32,768 tokens of LFM2.5-VL-3B. It is also, on a 1.92B model, a KV cache that grows faster than the weights it is attached to.

Sixty-two benchmarks, one lab, and a table that names its rivals

The benchmark section is the most useful part of the release, and not only because the numbers are high. Liquid published a 62-benchmark table that includes its own model in two configurations alongside nine competitors: LFM2.5-VL-3B, MiniCPM-V 4.7 1B, Qwen3.5 2B, Qwen3.5 4B, InternVL3.5 4B, Gemma 4 E2B, Gemma 4 12B, GPT-5.6 Luna and Gemini 3.5 Flash Lite. Every score is normalised to 0–100, every category is an unweighted mean of its benchmarks, and the average is an unweighted mean across all 62.

That is a more falsifiable artefact than a press-release chart. It names the instruments, it names the competitors, and the card footnotes which models ran with reasoning enabled and which did not. It is still vendor work: Liquid chose the 62 benchmarks, ran every model, and published the table. Nobody outside the company has reproduced any of it.

• Average — 71.4 for LFM3-VL-2B, against 57.6 for LFM2.5-VL-3B and 57.5 for MiniCPM-V 4.7 1B.

• Document, OCR and chart — 83.9, the category the on-device pitch leans on hardest.

• GUI understanding — 83.1, against 66.0 for LFM2.5-VL-3B.

• Visual grounding — 77.3, against 68.3.

• Video — 61.2, against 41.3, on the first LFM vision model that takes video at all.

• Agentic — 42.5, against 21.1. The weakest category for every small model in the table.

• Math and logical reasoning — 68.8, against 40.6. Hold that number; it is the interesting one.

The card makes three comparative claims in prose: that LFM3-VL-2B scores at least 8 points ahead of all models of similar size across the 62 benchmarks, that it matches Gemma 4 12B, and that it lands within 2 points of GPT-5.6 Luna while beating Gemini 3.5 Flash Lite. Checked against the table, those hold: Gemma 4 12B averages 71.7, GPT-5.6 Luna 73.4, Gemini 3.5 Flash Lite 70.0. A 1.92B model averaging within 0.3 of a 12B model is the headline claim, and it is a vendor-run claim about vendor-run numbers.

The thinking switch is doing most of the work

LFM3-VL-2B reports two scores for the same weights. In reasoning mode it averages 71.4. With thinking disabled it averages 62.1. The gap is not spread evenly across categories — it is concentrated where you would expect reasoning to help and almost absent where you would not.

• Math and logical reasoning — 68.8 with thinking, 41.0 without. A 27.8-point swing, by far the largest.

• Document, OCR and chart — 83.9 against 71.6. A 12.3-point swing on tasks that look perceptual but often are not.

• GUI understanding — 83.1 against 81.5. Barely moves, which suggests the screen-reading skill is in the encoder and the post-training, not the reasoning loop.

• Perception — 75.6 against 68.9.

• Average — 71.4 against 62.1.

The consequence is that the headline comparison flatters the new model in a specific way. LFM2.5-VL-3B does not support reasoning mode, so Liquid is comparing a thinking model against a non-thinking one. The fair fight is 62.1 against 57.6 — still a win, but a 4.5-point win rather than a 13.8-point one. And in that configuration it no longer leads everything nearby: Qwen3.5 2B averages 64.0, though that figure also comes from a reasoning-enabled run.

None of this makes the release less interesting. It makes the release legible. Liquid built a small model whose default deployment is fast and non-reasoning, and whose ceiling is much higher when you let it think. Which number applies to you depends entirely on whether your product can afford the latency of a reasoning loop on a phone.

What 1.92B buys you on a device

The efficiency case is the part Liquid is actually selling, and the card backs it with measurements rather than adjectives. On a single NVIDIA B300 running SGLang in BF16, the model produces more than 12,000 output tokens per second at 1,024 concurrent requests. That figure says more about batching than about the model, but it establishes that the serving path exists on day one.

On-device, the card publishes prefill, decode and peak memory for each compared model under a fixed workload: one 512×512 image, 1,024 text tokens in, 256 tokens out, all in llama.cpp with a Q4_0 GGUF language model and an F16 vision projector. That is a reproducible setup, and the memory column is the one to read before committing to a phone.

The tooling is real but uneven. SGLang support was there at launch. llama.cpp support is in review — pull request 31252 — and carries an explicit caveat from Liquid: no video input for now. GGUF weights exist and predate the announcement by eight days. If video is the reason you want this model, the local path is not finished yet, and the card says so.

What is not knowable yet

The honest boundary of this piece: everything quantitative above came from Liquid AI. There is no independent evaluation of LFM3-VL-2B, no third-party leaderboard entry, no reproduction of the 62-benchmark suite, and no published per-token price for the model on Liquid's own API as of October 28. The card lists availability through Hugging Face, the Liquid playground and the Liquid API, and the weights are open, but "open weights" and "independently verified" are different claims.

There is also a gap between the aggregate and the deployment story. A 62-benchmark average is a good instrument for ranking models and a poor one for predicting your workload. The categories where LFM3-VL-2B is strongest — GUI understanding, visual grounding, document and chart reading — are exactly the ones where a vendor's choice of benchmark instances can move a score by several points. The categories where it is weakest, agentic work at 42.5, are the ones most likely to matter for the robotics use case the card advertises.

Where this fits if you are building something

LFM3-VL-2B is not on OrcaRouter's catalogue at the time of writing — this is a checkpoint you download and run yourself, not something you call on our API. That shapes the useful pattern rather than ruling it out. The models this release competes with on cost — hosted vision models that handle the long tail of documents and video — are the ones you would route, and putting the local checkpoint and the hosted fallback on either side of one routing decision is the architecture the numbers actually argue for. Running a 1.92B model on the device and escalating the hard frames to a larger hosted model is the deployment that makes the 62.1 number acceptable, because the cases it fails are the cases that leave the device.

For the models we do route, one endpoint means one key, no second contract, and automatic failover across providers when the primary is degraded. That is the half of the system that needs a router; the on-device half needs a good quantisation and a battery budget.

What would change this picture

Three things, in order of how much they would matter. An independent reproduction of the 62-benchmark table would either confirm the most interesting claim in the release or move it. A merged llama.cpp build with video support would turn the on-device pitch from a plan into a product. And a published API price would let anyone compare it on the axis that decides most deployments, which right now is a blank cell.

Until then, the defensible reading is narrow and useful: Liquid shipped a 1.92B vision model that beats the 3.1B model it replaces on the vendor's own suite, wins that comparison decisively when reasoning is enabled and narrowly when it is not, and leads its size class on screens and documents. The repository was public eight days before the announcement, which is a fact about Liquid's launch process and not about the model — but it is the reason the first coverage of LFM3-VL-2B was speculation rather than review.