Why Edge VLMs Finally Matter
For the last two years, "vision-language model" has meant one thing: a 30B+ monster behind an API. Great for demos, useless for an offline app, a kiosk, or a field device with spotty connectivity. LFM2.5-VL-3B from Liquid AI flips that assumption — it is a 3.1B model that fits in roughly 3 GB of memory, decodes 228 tok/s on an M5 Max, 116 tok/s on a Ryzen AI Max+ 395, and still manages 20 tok/s on a Galaxy S26 Ultra. That is not a toy; that is a model you can ship inside a mobile app.
The four capabilities that actually changed from the previous generation:
- Screen/UI understanding — it reads what is on the display, not just photos of documents.
- Grounding — natural-language queries like "the red button in the top-right" now map to real bounding boxes.
- Multi-image input — reasoning across a set of images, not just one frame.
- Function calling — strong tool use in both text-only and vision-text settings.
If you are coming from the agent-building side, the same design instinct (context over raw model size) is what shows up in the ADK Go 1.0 production agent patterns — worth reading alongside this one.
Source: Liquid AI release notes

Hands-On: Load and Run It
Install the current transformers stack (the model requires transformers>=5.10.1):
pip install -q torch torchvision accelerate "transformers>=5.10.1"
Then load the model and run a simple captioning pass:
import torch
from transformers.image_utils import load_image
from transformers import AutoModelForImageTextToText, AutoProcessor
from IPython.display import display
MODEL_ID = "LiquidAI/LFM2.5-VL-3B"
processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForImageTextToText.from_pretrained(
MODEL_ID,
device_map="auto",
dtype="bfloat16",
)
img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png"
input_image = load_image(img_url)
display(input_image)
messages = [
{
"role": "user",
"content": [
{"type": "image", "image": input_image},
{"type": "text", "text": "Describe this image in two concise sentences."},
],
}
]
inputs = processor.apply_chat_template(
messages,
add_generation_prompt=True,
tokenize=True,
return_dict=True,
return_tensors="pt",
).to(model.device)
with torch.inference_mode():
outputs = model.generate(
**inputs,
do_sample=True,
temperature=0.2,
top_k=50,
repetition_penalty=1.0,
max_new_tokens=256,
)
output = processor.batch_decode(
outputs[:, inputs["input_ids"].shape[1]:], skip_special_tokens=True
)[0]
print(output)
Expected output on the sample image:
Two cats are sleeping on a pink couch with two remote controls.
That is the baseline. For grounding, OCR, multi-image input, and tool calling, the model uses the same chat-template pattern — swap the content array and the prompt, keep the rest identical.
![]()
Benchmarks and Trade-offs
Liquid AI evaluated LFM2.5-VL-3B against same-class models. The headline wins are on real-world image tasks, screen understanding, and grounding — the areas that matter for on-device apps.
| Area | Benchmark | LFM2.5-VL-3B | LFM2-VL-3B | Qwen3.5-2B | InternVL 3.5 2B |
|---|---|---|---|---|---|
| General | MMStar | 63.3 | 57.7 | 55.1 | 57.7 |
| Document | DocVQA | 91.1 | 89.8 | 92.6 | 88.4 |
| Grounding | RefCOCO-avg | 87.9 | 57.1 | 78.5 | 82.9 |
| GUI | ScreenSpot-v2 Desktop | 78.7 | 6.0 | 63.8 | 79.9 |
| GUI | ScreenSpot-v2 Mobile | 81.2 | 7.6 | 69.7 | 86.2 |
| Multi-image | BLINK | 61.5 | 50.2 | 48.6 | 52.0 |
| Tool use | ToolSandbox | 59.5 | 26.4 | 47.7 | N/A |
The caveats you should know before shipping:
- Not a reasoning model. It answers directly, by design. If your task needs chain-of-thought math or long multi-step deduction, this is the wrong tool — you will need a larger reasoning-capable model.
- Math and STEM are the weak spot. MathVista ~68.5 and MMMU-Pro ~30.5 are fine for everyday visual Q&A, but not for serious scientific workflows.
- The 4B class still wins on raw accuracy. InternVL 3.5 4B and Qwen3.5-4B beat it on aggregate average (69.4 / 70.1 vs 69.4 — roughly tied, but on individual benchmarks the gap is real). You are trading a few points of accuracy for a 3x smaller memory footprint.
- Throughput is only one axis. 11K tok/s on an H100 at high concurrency is excellent, but if your workload is single-request, latency, not throughput, is the metric that matters — measure both.
For teams designing the retrieval and context side of an agent, the same discipline of picking the right model for the job applies — see how Spotify's team thinks about context engineering for background coding agents.

What to Do Next
If you are building anything that touches a screen — an accessibility tool, an on-device screenshot assistant, a mobile QA bot, a document scanner for a field worker — LFM2.5-VL-3B is the first open 3B-class model that clears the bar for shipping. The path is straightforward:
- Start with the WebGPU demo in the browser. No setup, no GPU. If it does what you need on your sample images, you have a candidate.
- Fine-tune on your domain using the official tutorials — the model is small enough that a single consumer GPU is realistic.
- Benchmark on your own data, not the leaderboard. ScreenSpot-v2 is a proxy; your app's screenshots are the truth.
Where to go deeper from here:
- Function calling / agent integration: pair the model with an agent runtime and test tool-use paths before committing.
- Multi-image reasoning: the biggest jump over the previous generation (BLINK 50.2 → 61.5) — worth exploring for UI-flow understanding.
- Quantization: the model already fits in ~3 GB at bf16; int4 quantization opens the door to older phones and microcontrollers.
Further reading: the official LFM2.5-VL-3B model card has the full benchmark tables, the training pipeline details, and links to the fine-tuning tutorials.