Liquid AI's LFM2.5-VL-3B Beats Models Twice Its Size Running on Your Phone

Liquid AI just released LFM2.5-VL-3B, a 3.1B-parameter vision-language model (VLM) designed to run fast on real hardware, from a single H100 GPU down to a Galaxy S26 Ultra. The headline claim is striking: it matches or beats models up to 2.6x its size on key benchmarks, while fitting in about 3 GB of memory and decoding at 228 tokens per second on an Apple M5 Max.

This is not a reasoning model. It answers directly, which keeps latency low. That design choice is deliberate: the target is real-time and on-device applications where you cannot afford a 10-second thinking trace before getting a result.

A non-transformer running on your phone

To understand why LFM2.5-VL-3B is fast, you need to understand what it is built on. The core of LFM2.5 is a hybrid of attention and short-range convolutions, where attention blocks account for only about 37% of the model, with the remaining 63% made up of cheaper convolution blocks. This matters because standard transformers hit a memory wall on edge devices because their KV cache grows with every token, while LFM2's architecture cuts that cache by up to 90% by replacing most attention layers with zero-cache convolution blocks.

Liquid AI is an AI startup spun out of MIT's CSAIL, founded in 2022, building foundation models for edge devices based on research into liquid neural networks. The VL model pairs this hybrid language backbone with a vision encoder: a SigLIP2 NaFlex encoder to convert input images into token sequences, using the 400M shape-optimized variant for fine-grained vision capabilities. NaFlex (Native Flex) is Google's image encoder that supports multiple resolutions and preserves the native image aspect ratio, which has the potential to improve aspect-sensitive applications such as document understanding.

The connector between vision and language is a lightweight 2-layer MLP that applies a PixelUnshuffle operation, projecting patch-level embeddings into language space by first lowering the number of visual tokens, then mapping image embeddings into the LFM2 hidden dimension. This is what keeps the token budget small and first-token latency low.

Four things that actually got better

LFM2.5-VL-3B builds on the previous LFM2-VL-3B with significant improvements in screen understanding, grounding, function calling, and multi-image input. Each of these is a meaningful jump, not a marginal one:

• Screen and UI understanding: It averages 80.7 on ScreenSpot-v2, far ahead of the much larger Gemma-4-E4B (51.2) and Qwen 3.5 4B (78.5) and close behind the larger InternVL-3.5-4B (84.1).
• Function calling: ToolSandbox more than doubles from 26.4 to 59.5 and BFCL v4 climbs from 20.5 to 32.5, putting it on par with Gemma-4-E2B and ahead of Qwen3.5-2B.
• Grounding: LFM2.5-VL-3B significantly improves grounding performance by scaling synthetic grounding data, raising RefCOCO precision@1 from 57.1 to 87.9, a 30-point gain over the previous release. Grounding means the model can locate specific objects in an image and return their bounding box coordinates.
• Multi-image input: Improved reasoning across multiple images, improving BLINK from 50.2 to 61.5 and MUIRBench from 34.9 to 58.3.

The overall picture across 28 benchmarks: LFM2.5-VL-3B significantly outperforms much larger Gemma models and comes within 0.7% of the larger 4.7B Qwen 3.5 model.

How it was trained

LFM2.5-VL-3B is pre-trained on ~34T tokens. To better support non-Latin scripts, the vocabulary was doubled to 128K by extending the existing tokenizer in place rather than retraining from scratch. Doubling the vocabulary this way is a practical trick: you avoid the cost of a full retraining while gaining coverage for Arabic, Chinese, Japanese, Korean, and other scripts.

Vision pretraining was scaled 4x in tokens, while improving data quality with a large mixture of curated and synthetic image-caption, OCR, grounding, and instruction-following data. The post-training pipeline has two stages:

1. Supervised fine-tuning (SFT) with knowledge distillation from a larger teacher model, plus a technique called Antidoom training.
2. Multi-reward reinforcement learning to sharpen instruction-following and tool use.

Antidoom is worth explaining. It is Liquid AI's own method for eliminating "doom loops", where a model gets stuck repeating the same phrase until it runs out of context. Antidoom uses Final Token Preference Optimization to cut doom-loop rates in reasoning models by up to 90%, with minimal disruption to model behavior. Rather than applying a blunt inference-time penalty, it surgically identifies the exact token that starts a loop and trains the model to prefer coherent alternatives at that single position. On an early LFM2.5-2.6B checkpoint, this dropped the loop rate from 10.2% to 1.4%.

Inference speed: the real story

The benchmark numbers are one thing. The throughput numbers are where this model becomes genuinely interesting for production use.

LFM2.5-VL-3B decodes 228 tokens/s on an Apple M5 Max and 116 tokens/s on an AMD Ryzen AI Max+ 395, while staying in about 3 GB of memory. It even runs on a phone, decoding 20 tokens/s on a Galaxy S26 Ultra.

On server-side GPU inference, the advantage is even sharper for multi-image inputs. LFM2.5-VL-3B keeps latency consistently low and pulls far ahead on multi-frame inputs, returning the first token in about 34 ms on a 5-frame video clip where the Gemma models take around 200 ms. At high concurrency on a single H100, LFM2.5-VL-3B reaches the highest output throughput of any model tested, about 11K tokens per second, roughly 2x the larger 4B-class models, adding up to nearly 1B output tokens per day on a single H100.

The speed advantage on multi-image inputs comes directly from the compact vision encoder. Models with heavier encoders stall when processing multiple frames because they generate far more vision tokens per image. LFM2.5-VL-3B's token compression pipeline keeps that cost low regardless of how many images you send.

Where it falls short

The benchmark table reveals a few gaps worth knowing about. On MMMU (val), which tests college-level multi-discipline reasoning from images, LFM2.5-VL-3B scores 48.4, behind InternVL-3.5-4B at 60.7 and Qwen3.5-4B at 50.3. On SimpleVQA, which requires factual world knowledge tied to images, it scores 35.4, behind Qwen3.5-4B at 40.7. These are tasks that demand broad world knowledge baked into the weights, which is harder to compress into a 3B model.

The model is also explicitly not a reasoning model. LFM2.5-VL-3B is a non-reasoning model that answers directly, keeping latency low for real-time and on-device applications. If your task requires step-by-step worked solutions, you will want a different model, or you will need to fine-tune this one.

What you can build with it

The combination of screen understanding, grounding, function calling, and fast multi-image inference points to a specific class of applications:

• UI and screen agents: Navigating mobile apps, web browsers, or desktop software by visually reading the screen and deciding where to click, all on-device.
• Document and chart pipelines: Parsing invoices, contracts, charts, and infographics without sending data to a cloud API.
• Vision-triggered tool calling: Identifying what is in an image and deciding which tool or API to call, from either a text or image prompt.
• Privacy-sensitive deployments: Any use case where images cannot leave the device, from medical records to industrial inspection.
• High-throughput server pipelines: Running nearly 1B output tokens per day on a single H100 makes it viable for large-scale document processing without a fleet of GPUs.

The bigger picture

The AI landscape is witnessing a dramatic shift from large language models to small models specifically optimized for edge environments, with Gartner predicting that by 2027, organizations will use small, task-specific AI models three times more than general-purpose LLMs. LFM2.5-VL-3B is a direct bet on that shift, and the ScreenSpot-v2 number is its sharpest argument: a 3B model beating an 8B model by 29 points on UI understanding is not a marginal win, it is a signal that architecture and training data choices can matter more than raw parameter count for specific tasks.

Liquid AI's researchers describe their target as running entirely on local hardware without relying on cloud inference or GPUs, for users who "can't use a cloud model." That framing matters. The model is not trying to compete with GPT-4o or Gemini Ultra on general capability. It is trying to be the best vision model that runs privately on your own hardware, and for the tasks it targets, the numbers suggest it is succeeding.

Getting started

The model is available today on Hugging Face and the Liquid AI Playground. It ships with day-one support for llama.cpp, MLX, vLLM, SGLang, and ONNX, so you can drop it into most existing inference setups without changes. The weights are open, and the official docs cover both local inference and fine-tuning. There is also a WebGPU demo that runs the model entirely in your browser with no setup required.

A quick example of how to run it with the Hugging Face transformers library:

from transformers import AutoProcessor, AutoModelForVision2Seq
from PIL import Image
model_id = "LiquidAI/LFM2.5-VL-3B"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForVision2Seq.from_pretrained(model_id)
image = Image.open("screenshot.png")
messages = [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "Where is the login button?"}]}]
inputs = processor.apply_chat_template(messages, images=[image], return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=128)
print(processor.decode(outputs[0]))

The model is free for individuals and small companies. For enterprise licensing terms, check the Hugging Face model card directly. The community reception has been warm: prior LFM releases drew comments like "LFM2-1.2B was galaxies ahead of competitors; it's 1.2B but really behaves more like a ~10B model in terms of coherence and reasoning power." LFM2.5-VL-3B raises the bar further on the vision side.