Olha só isso: VLM que roda no dispositivo
Sabe quando você quer colocar um modelo de visão dentro de um app mobile, mas o único caminho é chamar uma API de um modelo de 30B+? Pois é, o LFM2.5-VL-3B da Liquid AI veio para mudar esse jogo. Ele tem 3.1B de parâmetros, cabe em cerca de 3 GB de memória e ainda assim entrega:
- 228 tok/s num M5 Max
- 116 tok/s num Ryzen AI Max+ 395
- 20 tok/s num Galaxy S26 Ultra (isso mesmo, no celular!)
E não para por aí. As quatro grandes melhorias em relação à geração anterior são:
- Entendimento de tela/UI — ele lê o que está na tela, não só fotos de documentos.
- Grounding — você pergunta "o botão vermelho no canto superior direito" e ele devolve a bounding box certinha.
- Múltiplas imagens — raciocina sobre um conjunto de imagens, não só uma.
- Function calling — chamada de ferramentas forte em texto puro e em texto+visão.
Se você curte a parte de agentes, vale a pena cruzar essa leitura com o padrão de agentes de produção do ADK Go 1.0 — a lógica é a mesma: contexto certo vale mais que modelo gigante.
Fonte: notas de lançamento da Liquid AI

Vamos colocar a mão na massa
Primeiro, instala a stack atual do transformers (o modelo pede transformers>=5.10.1):
pip install -q torch torchvision accelerate "transformers>=5.10.1"
Agora carrega o modelo e roda uma legenda de imagem simples:
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."},
],
}
]
# aplica o chat template e prepara os tensores
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,
)
# decodifica só os tokens novos
output = processor.batch_decode(
outputs[:, inputs["input_ids"].shape[1]:], skip_special_tokens=True
)[0]
print(output)
Saída esperada na imagem de exemplo:
Two cats are sleeping on a pink couch with two remote controls.
Essa é a base. Para grounding, OCR, múltiplas imagens e tool calling, o padrão é o mesmo: troca o array content e o prompt, o resto fica igual.

Benchmarks e o que ninguém te conta
A Liquid AI comparou o LFM2.5-VL-3B com modelos da mesma faixa. Os destaques ficam em tarefas de imagem do mundo real, entendimento de tela e grounding — exatamente o que importa para apps on-device.
| Área | Benchmark | LFM2.5-VL-3B | LFM2-VL-3B | Qwen3.5-2B | InternVL 3.5 2B |
|---|---|---|---|---|---|
| Geral | MMStar | 63.3 | 57.7 | 55.1 | 57.7 |
| Documento | 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-imagem | BLINK | 61.5 | 50.2 | 48.6 | 52.0 |
| Tool use | ToolSandbox | 59.5 | 26.4 | 47.7 | N/A |
Os poréns que você precisa saber antes de subir para produção:
- Não é um modelo de raciocínio. Ele responde direto, por design. Se sua tarefa exige chain-of-thought em matemática ou dedução longa em várias etapas, essa não é a ferramenta certa.
- Matemática e STEM são o ponto fraco. MathVista ~68.5 e MMMU-Pro ~30.5 servem para Q&A visual do dia a dia, não para workflow científico sério.
- A classe 4B ainda ganha em acurácia bruta. InternVL 3.5 4B e Qwen3.5-4B batem ele na média geral. Você está trocando alguns pontos de acurácia por um footprint 3x menor.
- Throughput é só um eixo. 11K tok/s num H100 em alta concorrência é ótimo, mas se o seu workload é single-request, a métrica que importa é latência — meça as duas.
Para quem está desenhando a camada de contexto de um agente, a mesma disciplina de escolher o modelo certo para o trabalho aparece no context engineering para agentes de código em background da Spotify.

Próximos passos
Se você está construindo qualquer coisa que toca uma tela — ferramenta de acessibilidade, assistente de screenshot on-device, bot de QA mobile, scanner de documento para trabalho de campo — o LFM2.5-VL-3B é o primeiro modelo aberto da classe 3B que passa do sarrafo para shippar. O caminho é direto:
- Comece pela demo WebGPU no navegador. Sem setup, sem GPU. Se ele fizer o que você precisa nas suas imagens de amostra, você tem um candidato.
- Faça fine-tune no seu domínio com os tutoriais oficiais — o modelo é pequeno o suficiente para uma GPU de consumidor.
- Benchmark com os seus dados, não com o leaderboard. ScreenSpot-v2 é proxy; os screenshots do seu app são a verdade.
Para ir mais fundo:
- Function calling / integração com agentes: teste os caminhos de tool use antes de commitar.
- Raciocínio multi-imagem: o maior salto em relação à geração anterior (BLINK 50.2 → 61.5) — vale explorar para entender fluxos de UI.
- Quantização: o modelo já cabe em ~3 GB em bf16; quantização int4 abre a porta para celulares mais antigos e microcontroladores.
Leitura complementar: o model card oficial do LFM2.5-VL-3B tem as tabelas completas de benchmark, o pipeline de treino e os links para os tutoriais de fine-tuning.