Molmo2-4B vs LFM2.5-VL-3B: 19 GB of Weights Against 3 GB of Phone

Put the two checkpoints side by side on disk and the comparison is close to over before it starts. Molmo2-4B ships as 19.42 GB of float32 safetensors across four shards. LFM2.5-VL-3B's native repository totals 6.27 GB, and Liquid's own card promises it runs in "under 3.3 GB of memory." Once you quantize the smaller model that is roughly a six-to-one gap in footprint for two models that get discussed as if they were interchangeable small vision-language models. They are not interchangeable, and the reason is not quality. One of them is built to answer questions about a 384-frame video. The other is built to answer questions about a photograph on a phone with the radio off. Neither model is hosted here, so the platform's role is the surrounding stack. 0% markup pricing The provider's list price is passed through unchanged.

Neither model is new, which matters if you arrived from a results page implying otherwise. Molmo2-4B was announced by the Allen Institute for AI on 11 December 2025 and its weights went up on 14 December. LFM2.5-VL-3B shipped from Liquid AI on 12 August 2026. What changed recently is narrower and more useful than a launch: Molmo2 became a first-class architecture in upstream Transformers, with PR #43451 merged on 9 October 2026 and the model first shipping in v5.20.0 on 15 October, ending the period in which you had to pass trust_remote_code=True and install a separate molmo_utils package. On 5 November Ai2 also published Molmo2-4B-tb, a robotics fine-tune built on this exact checkpoint. Neither event makes Molmo2-4B new. Both make it newly practical to run.

The memory question, in numbers rather than adjectives

Sizes first, because they decide most deployments before a single benchmark is consulted.

• Parameters — Molmo2-4B is 4,850,869,200 across a SigLIP 2 vision tower and a Qwen3-4B-Instruct-2507 language core; LFM2.5-VL-3B is 3,123,483,888 across a SigLIP2 NaFlex 400M encoder and a 2.6B LFM2.5 backbone.

• Shipped weight format — Molmo2-4B is distributed in float32, 19.42 GB on disk, four shards; LFM2.5-VL-3B is distributed in bfloat16 at 6.27 GB, with official GGUF, ONNX and MLX exports published alongside it.

• Stated runtime footprint — Liquid claims under 3.3 GB for LFM2.5-VL-3B at inference; AI2 publishes no runtime memory figure for Molmo2-4B, and the float32 distribution means you will be casting before you serve.

• Throughput — Liquid reports 228 tokens/s on an Apple M5 Max, 116 tokens/s on an AMD Ryzen AI Max+ 395 and 20 tokens/s on a Galaxy S26 Ultra. There is no equivalent public number for Molmo2-4B at any size.

• Context — 32,768 tokens for LFM2.5-VL-3B; 36,864 positions in Molmo2-4B's text config, reached through a dedicated long-context fine-tuning stage at 384 frames.

That last pair deserves a caveat rather than a comparison. Molmo2-4B's 36,864 is a sequence-length budget that its video pipeline eats quickly: the released video preprocessor defaults to 384 frames at 2 fps, resized to 378×378 with 3×3 pooling. A long clip can consume the whole window in frames alone, leaving little room for the question. LFM2.5-VL-3B's 32,768 is spent on text and image patches, because it has no video path at all.

Video is the dividing line, not the benchmark table

LFM2.5-VL-3B processes text and images. That is the whole input surface. It is very good at what it was built for — full-page OCR with layout annotation, object detection from natural-language queries, screen reading, and near-real-time work on device — but a video is not one of its inputs, and no amount of prompt engineering changes that.

Molmo2-4B was built the other way round. Ai2's model card lists nine training sets, and five of them are video or multi-image: video captioning QA, video subtitle QA, video pointing, video tracking, multi-image QA, multi-image pointing. The pointing output is the unusual part. Coordinates come back scaled to 0–1000 of image width and height, in a tagged format the card ships a regex for, so a "where is the boat" answer is a numeric point rather than a sentence. The same format carries a timestamp in video mode, which is what makes frame-level tracking possible at all.

If your task is a screenshot, a scanned page, a photograph of a shelf or a menu, none of that matters, and the 3 GB model is simply the better engineering choice. If your task is "find the moment the crate falls off the pallet," LFM2.5-VL-3B cannot enter the comparison.

Two vendor averages that must not be subtracted from each other

Here is where most comparison pages go wrong. Liquid reports a 69.4 average for LFM2.5-VL-3B across a 28-benchmark vision table. AI2 reports a 62.8 average for Molmo2-4B across 15 academic benchmarks. Print those two numbers beside each other and LFM2.5-VL-3B looks 6.6 points better. It is not a valid comparison: different benchmark sets, different prompt formats, different decoding settings, and in Liquid's case a suite its own authors selected.

What each vendor actually reports, with the provenance attached:

• LFM2.5-VL-3B, vendor-reported — DocVQA 91.1, RefCOCO-avg 87.9, CountBenchQA 87.3, OCRBench v1 84.2, TextVQA 84.3, MMBench 81.0, SEED-Bench image 77.7, ScreenSpot-v2 Web 82.2, MMStar 63.3, MMMU 48.4, MMMU-Pro 30.5, MathVista mini 68.5.

• Molmo2-4B, vendor-reported — 62.8 average over 15 academic benchmarks, against 63.1 for the 8B sibling, 58.1 for Qwen3-VL-4B, 53.4 for InternVL3.5-4B, 59.6 for Claude Sonnet 4.5, 70.0 for Gemini 3 Pro and 70.6 for GPT-5 on the same table.

• Not reported anywhere by either vendor — a shared harness. Neither company has published Molmo2-4B results on Liquid's 28-benchmark suite or LFM2.5-VL-3B results on AI2's 15-benchmark table.

The one genuinely comparable axis is model size, and there the 4.85B model beats the 3.12B model on AI2's own average while losing badly on deployment footprint. That is the trade, stated plainly.

Licences: neither is the Apache-2.0 it looks like

Both cards carry a permissive-sounding label, and both have a catch that a procurement reviewer will find.

• Molmo2-4B — weights under Apache 2.0, but the card adds that the model "is trained on third party datasets that are subject to academic and non-commercial research use only," and tells you to review the sources before deciding whether the model fits. The weights are open; the data lineage is not clean for commercial use, and Ai2 says so on the card rather than in a footnote.

• LFM2.5-VL-3B — the LFM Open License v1.0, which is not an OSI licence. Commercial use is granted conditionally: section 5 makes commercial rights contingent on your legal entity staying below a defined Threshold, and the licence defines that Threshold as annual revenue of 10 million US dollars or more.

Neither restriction is unusual for a research-adjacent release. Both mean the question "can we ship this" has a different answer for a two-person prototype and a funded company, and the two answers point in opposite directions depending on which model you picked.

Running either one today

Molmo2-4B's own model card is now behind the library. It still instructs you to install transformers==4.57.1, pass trust_remote_code=True, and install molmo_utils and decord2. That recipe works. It is also no longer the only one: since v5.20.0, stock Transformers carries a Molmo2ForConditionalGeneration class with its own configuration, image processor, video processor and processor, so the remote-code path is optional rather than mandatory. vLLM has carried Molmo2 support behind its own model class since shortly after launch; AI2's platform documentation still points at the nightly wheels rather than a stable release, which is worth knowing before you pin a version in production.

LFM2.5-VL-3B has the more mature deployment story of the two, and it is not close: native weights plus GGUF, ONNX and MLX exports, with llama.cpp, vLLM and SGLang all listed as supported, and published throughput on three different pieces of consumer hardware. If your target is a laptop, a phone or a single-board computer, that ecosystem is the product.

One practical note for anyone planning to route between them: neither model is in the OrcaRouter catalogue, and it would be wrong to read a comparison like this as an availability claim. What the platform does offer is one API for more than 200 models alongside a self-hosted deployment like these two, with automatic failover and the provider's own list price passed through with no markup added. The usual pattern is to keep the small vision model local for the latency-critical path and route the harder, rarer requests out — and to prove that split with real traffic before committing to either.

Which one to pick

Choose LFM2.5-VL-3B if the deployment target is a phone, a laptop or an edge box, if your inputs are screenshots, documents or single photographs, if you need sub-second first-token latency, or if you need one of the quantized formats that already exist for it. The 16-language coverage and the ScreenSpot-v2 numbers make it a defensible pick for on-device screen understanding specifically.

Choose Molmo2-4B if video is in scope, if you need coordinates rather than prose, if you need multi-image reasoning over a set of frames, or if the task is counting objects in a scene — AI2's own comparison puts the Molmo2 family at the top of the open-weight field on video counting while conceding that no model in its evaluation reaches 40% accuracy. Budget for the footprint: 19.42 GB of float32 weights, a cast to bfloat16 before serving, and a GPU rather than a phone.

What would settle it properly is a joint evaluation on one harness, at matched quantization, with latency measured on the same device. Neither vendor has published one, and until somebody does, the honest answer is that these two models were designed for different jobs and the benchmarks were never meant to meet.