LFM2.5-2.6B: Liquid AI's On-Device Agent Model Runs at 220 Tokens/s in Under 2.5 GB

On August 4, 2026, Liquid AI released LFM2.5-2.6B, an open-weight model whose pitch is simple: an agent that fits in 2.5 GB of memory, runs on a laptop CPU, and beats models four times its size on instruction following and tool use. The company measured 220 tokens/s decoding on an Apple M5 Max, 113 tokens/s on an AMD Ryzen AI Max+ 395, and around 30 tokens/s on a phone, all under 2.5 GB of memory. That combination, fast enough for interactive agent work with no cloud inference bill, is the reason this release matters.

Official Sources#

What Shipped#

LFM2.5-2.6B is a 2.69B-parameter model with 30 layers (22 double-gated short convolution blocks and 8 GQA layers), a 128K vocabulary, and a 131,072-token context window. It was pre-trained on about 34 trillion tokens, then given a dedicated 128K context-extension phase. The base model and the agentic post-trained variant are both on Hugging Face under the LFM Open License v1.0, which allows commercial use for entities below $10M annual revenue and free use for non-profits and research.

The interesting part is the post-training. Liquid AI describes four stages: two rounds of supervised fine-tuning weighted toward tool use, web search, and harness trajectories; per-domain teacher specialization trained with RL on verifiable rewards; multi-domain on-policy distillation (MOPD), where the student rolls out under its own policy and routed teachers give token-level feedback; and finally agentic RL. That last stage runs GRPO with an outcome-based reward combining an LLM-as-a-judge rubric, programmatic checks, and a hard safety gate, inside real harnesses like Hermes Agent and OpenClaw. A harness proxy captures token-level trajectories from those black-box environments, with consistency checks and a rollout routing replay pass to validate the training samples.

The Benchmarks#

Liquid AI evaluated LFM2.5-2.6B against models up to nearly four times its size: gemma-4-E2B-it (5.1B), gemma-4-E4B-it (8B), Qwen3.5-4B (4.7B), and Qwen3.5-9B (9.7B). Vendor numbers:

The pattern is consistent with the training story: LFM2.5-2.6B leads every instruction-following benchmark here, and every tool-use benchmark except BFCLv4, where only the 9.7B Qwen edges ahead. On agentic tasks it beats both Gemma models and trades evenly with the Qwens. Coding is the one place larger models keep a clear lead, so for code-heavy agent work you would still reach for a bigger model. These are vendor-published numbers, evaluated with vLLM and the generation parameters stated in the post's footnote, so treat them as vendor claims rather than independent measurements.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "LiquidAI/LFM2.5-2.6B"
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto", dtype="bfloat16")
tokenizer = AutoTokenizer.from_pretrained(model_id)

Serving and Speed#

Day-one support covers llama.cpp (GGUF), MLX, vLLM, SGLang, and ONNX. On GPU, Liquid AI measured nearly 15K output tokens/s at high concurrency on a single H100, roughly 1.3 billion tokens per day. On CPU, 113 tokens/s on a Ryzen laptop means a multi-step agent task that generates a few thousand tokens completes in seconds.

The setup path is an OpenAI-compatible endpoint plus a harness: serve the model locally, then point a harness at it. Liquid AI's docs cover Hermes Agent, OpenClaw, and Pi, and a WebGPU space on Hugging Face runs a research agent fully in the browser. Try that demo first: it is the fastest way to judge whether a 2.6B model suits your workload.

Can You Run It in OpenCode?#

Not yet. LFM2.5-2.6B is not in OpenCode's model registry, so there is no one-line opencode run --model path. The vendor route is the OpenAI-compatible endpoint: serve it with vLLM or llama.cpp, then configure it as a custom provider in OpenCode. If you are already on OpenCode, the closest first-party option remains DeepSeek V4 Flash for agent-heavy coding work, while LFM2.5-2.6B earns its place on the local/on-device lane.

Why It Matters#

The economics are the point. When a capable agent model runs locally, the marginal cost of an extra agent turn drops to zero, which changes what you run: background agents that churn through millions of tokens, parallel workers on the same machine, and private workloads that never leave the device. Our local LLM guide laid out the 2026 tradeoff between benchmark performance, hardware cost, and keeping code off third-party servers; this release moves the on-device lane forward on the agentic axis specifically, because it was trained inside real agent harnesses rather than on static chat data.

Two caveats keep it honest. First, coding ability is the weak spot at this size, so it is an agent model for research, writing, tool orchestration, and document workflows, not a code assistant. Second, the $10M revenue threshold in the license means a company above that line needs a commercial agreement, which matters for startups that grow into it.

Continue Reading#

• The Best Local Coding LLMs in 2026 - how on-device models compare for real workloads
• GLM 5.2 on a Slow Computer: Local Inference - what local inference actually costs in practice
• GLM 5.2 vs DeepSeek V4 vs Qwen3: Open Weights Coding Showdown - where the bigger open-weights models stand
• DeepSeek V4 Flash 0731: Release and OpenCode Guide - the agent-benchmark leader you can run today
• What Is an AI Coding Agent in 2026 - how harnesses and models fit together

Sources#

• Liquid AI: LFM2.5-2.6B: Deploy Agents Everywhere - fetched August 5, 2026
• Hugging Face: LFM2.5-2.6B model card - fetched August 5, 2026
• Hugging Face: LFM2.5-2.6B LICENSE (LFM Open License v1.0) - fetched August 5, 2026
• Hugging Face blog: Deploy local agents everywhere with LFM2.5-2.6B - fetched August 5, 2026
• Liquid AI docs: agent harnesses guide