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

Vision-language AI model processing images and documents on edge hardware System Abstract Visual

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.

Smartphone running LFM2.5-VL-3B on-device for screen understanding and grounding Programming Illustration

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.

AreaBenchmarkLFM2.5-VL-3BLFM2-VL-3BQwen3.5-2BInternVL 3.5 2B
GeneralMMStar63.357.755.157.7
DocumentDocVQA91.189.892.688.4
GroundingRefCOCO-avg87.957.178.582.9
GUIScreenSpot-v2 Desktop78.76.063.879.9
GUIScreenSpot-v2 Mobile81.27.669.786.2
Multi-imageBLINK61.550.248.652.0
Tool useToolSandbox59.526.447.7N/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.

Server rack with H100 GPUs serving 11K tokens per second for LFM2.5-VL-3B inference Dev Environment Setup

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:

  1. 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.
  2. Fine-tune on your domain using the official tutorials — the model is small enough that a single consumer GPU is realistic.
  3. 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.

This content was drafted using AI tools based on reliable sources, and has been reviewed by our editorial team before publication. It is not intended to replace professional advice.