LFM2.5-2.6B: Liquid AI's Biggest On-Device Agent Model Yet

A 2.6-billion-parameter model just beat a 9-billion-parameter one on tool use — and it did it running locally on a laptop, not in a data center.

On August 4, 2026, Liquid AI released LFM2.5-2.6B, the flagship model in its LFM2.5 family of on-device agentic models. The pitch is direct: an agent that plans, calls tools, and works through multi-step tasks entirely on-device — phone, laptop, PC, or robot — with data that never leaves the device and a marginal cost per run that's effectively zero.

TL;DR

The benchmark story: smaller, and still winning

Liquid AI's comparison set includes Gemma-4-E2B (5.1B), Gemma-4-E4B (8B), Qwen3.5-4B (4.7B), and Qwen3.5-9B (9.7B) — every one of them larger than LFM2.5-2.6B, some nearly 4x larger. The headline claim is that LFM2.5-2.6B leads on every instruction-following benchmark and nearly every tool-use benchmark in that comparison anyway.

The pattern is consistent across the results: LFM2.5-2.6B wins or nearly matches on agentic and instruction-following categories (tool use, structured instruction following, multi-turn compliance) while trailing the larger Qwen3.5-9B on raw reasoning and code benchmarks like AIME25 and LiveCodeBenchv6. That's a coherent story rather than selective benchmark reporting — Liquid AI is explicitly optimizing for the agentic-on-device use case rather than trying to win every category against much larger general-purpose models, and it publishes the categories where it loses. The fairer criticism, raised after publication, is about the comparison set rather than the benchmark list: every model shown is larger, and the same-size peers are absent. See the August 11 update below.

How it was trained

Pre-training ran on roughly 34 trillion tokens, with the tokenizer's vocabulary expanded to 128K to better support the varied inputs an on-device agent actually encounters — tool schemas, file paths, structured outputs — not just natural-language chat.

Post-training runs four distinct stages. Supervised fine-tuning first covers broad domains, then narrows to an agentic-specific focus. Teacher specialization produces separate expert models per domain. Multi-domain on-policy distillation routes supervision from those domain specialists back into the single deployed model. Finally, agentic reinforcement learning trains the model inside real agent harnesses — not synthetic benchmarks — using outcome-based rewards that combine LLM-as-judge rubrics with programmatic correctness checks. That last stage is likely the biggest contributor to the tool-use and instruction-following results, since it directly optimizes for "did the agent's multi-step task actually succeed," not just next-token accuracy.

Speed and footprint across real hardware

The performance numbers span a real range of on-device hardware rather than a single best-case GPU benchmark:

Quantized, the model fits under 2.5GB of memory — small enough to coexist with everything else already running on a phone or laptop, which is the actual constraint that matters for "runs on-device" claims to be more than a demo. Liquid also reports the H100 figure specifically to make a cost point: at sustained throughput, that's roughly 1.3 billion tokens per day on a single GPU, positioned as a cloud-hosting option for teams that want the model's capability without managing on-device deployment across a fleet.

Where LFM2.5-2.6B fits in the family

Liquid AI already shipped a much smaller sibling in this same architecture generation: LFM2.5-230M, released in June 2026 at roughly 1/11th the parameter count, targeting the smallest edge devices — phone CPUs and Raspberry Pi-class hardware — with correspondingly lighter capability. LFM2.5-2.6B is the flagship of the same family: same architectural lineage and on-device-first design philosophy, but built to actually contest benchmark leaderboards against multi-billion-parameter general-purpose models rather than just fitting the smallest possible footprint.

Together they cover a real deployment range: 230M for the tightest edge constraints, 2.6B for devices that can spare a couple gigabytes of memory but still need to stay off the cloud entirely.

The agentic benchmarks specifically

Beyond the general instruction-following and tool-use scores, Liquid AI reports a dedicated set of agentic benchmarks meant to more directly simulate real multi-step agent work rather than single-turn tool calls:

These four are notably harder than ToolSandbox or BFCLv4 — they're built to test whether an agent can sustain a coherent multi-step plan across a longer task (browsing, banking-style transactions, general agent evaluation), not just whether it can format one correct tool call. LFM2.5-2.6B is competitive with Qwen3.5-9B here rather than clearly ahead, and both models comfortably outperform Gemma-4-E4B across the board — which is the more useful signal than any single benchmark: Liquid's agentic RL post-training stage appears to transfer to genuinely multi-step evaluation, not just the easier single-call tool benchmarks.

Getting it running

Both the base checkpoint (LFM2.5-2.6B-Base) and the post-trained, tool-calling-ready checkpoint (LFM2.5-2.6B) are open-weight on Hugging Face. Inference support spans the tools most on-device deployments already use:

That spread matters for the "deploy agents everywhere" pitch specifically — a team isn't locked into one inference stack depending on whether the target device is an iPhone, a Windows laptop with an NPU, or a cloud GPU fleet. The same weights, quantized appropriately, move across all of them.

What people are asking

Is this actually usable for agent work, or just a benchmark win? The agentic RL post-training stage and the ToolSandbox/BFCLv4 scores both point at real multi-step tool-calling capability, not just chat quality. Liquid AI's named use cases — desktop cleanup, in-browser research, background calendar management — are exactly the kind of bounded, tool-heavy tasks these benchmarks are meant to predict.

Why does data privacy matter here specifically? Because the model runs the entire agent loop — planning, tool calls, multi-step execution — locally. Nothing about the task, the tool outputs, or the intermediate reasoning needs to leave the device, which is a meaningfully different privacy posture than a cloud-hosted agent that has to transmit screen content or file contents to a remote API on every step.

How does this compare to Anthropic's Claude in Chrome or Cowork, which also act as agents? Different tradeoff entirely — Claude in Chrome and Cowork run frontier-scale cloud models with correspondingly stronger reasoning and higher per-action cost (and cloud-side data exposure). LFM2.5-2.6B trades some of that ceiling for zero marginal cost, full local privacy, and offline operation — the right choice depends on whether the task needs frontier reasoning or just reliable tool execution.

What's the catch? The reasoning and code benchmarks (AIME25, LiveCodeBenchv6) show LFM2.5-2.6B trailing Qwen3.5-9B, so it's not a universal replacement for a larger general-purpose model — it's specifically strong where the task is agentic and tool-driven rather than open-ended reasoning or coding.

Why this matters beyond the benchmark table

The broader trend LFM2.5-2.6B sits in is small models closing the gap on agentic tasks specifically, faster than they're closing the gap on open-ended reasoning. That's not an accident of this one release — it reflects where post-training effort has concentrated across the industry this year: agentic RL against real harnesses is a more tractable optimization target than general reasoning improvement, because the reward signal (did the tool call succeed, did the task complete) is cleaner and more verifiable than judging open-ended reasoning quality.

For builders, the practical implication is a shift in default assumptions: "on-device" no longer automatically means "toy capability." A 2.6B model that beats a 9B model on the exact benchmarks that predict tool-calling reliability is a real option for production agent workloads that were previously assumed to require a cloud API call, not just a privacy-preserving fallback for degraded functionality.

Update — August 11: the skeptical read

The model reached Hacker News on August 11 (72 points, 18 comments), and the pushback is worth recording alongside the benchmark table.

The cherry-picking objection. The comparison set is entirely Gemma-4 and Qwen3.5 variants. Commenters flagged the absence of Qwen3.5-2B — the closest size peer, and the obvious control — plus Nanbeige4.2-3B and Ling-3.0-tiny. One reader put the general principle bluntly: in self-reported comparisons there's a strong incentive to omit any model that wins. That doesn't make the published numbers false, but "beats models 4x larger" is a claim about a chosen field, and the same-size field is the one that isn't shown.

The practical objection. Several readers reported that Liquid AI models "have never worked well in practice" and cited coherence problems — the standard gap between benchmark scores and felt quality at this parameter count. Worth weighting appropriately: these are unquantified anecdotes, but they come from people who tried the earlier models.

The clarification worth keeping. A recurring confusion was people evaluating a 2.6B model for agentic coding. Liquid AI's own model card explicitly rules that out: recommended for "agentic workloads, tool use, data extraction, RAG, and long-context workflows," and not recommended for agentic coding and knowledge-heavy tasks. Judging it on coding is judging it against a use case its authors excluded.

What people are actually doing with it. The most useful part of the thread was builders describing non-coding agent workloads — home-assistant loops where the small model queries a tool service, invokes tools, and synthesizes results while escalating anything requiring new tooling to a larger model; ops and run-book execution where a stronger model writes detailed instructions and the small model executes them. That escalation pattern — cheap local model executes, frontier model plans — is the shape that keeps recurring, and it matches the model orchestration logic of matching model size to task difficulty rather than defaulting to the biggest available.

One commenter framed the real research challenge well: the hard problem isn't knowledge, it's building a model that reasons and operates tools well while discarding everything that is merely knowledge of facts. Small reasoning models are where that problem lives.

The takeaway

LFM2.5-2.6B is a clean data point in the ongoing "small models are getting good enough" trend, but the more interesting claim is the deployment story: an agent that plans and executes multi-step tool-calling tasks entirely on a phone or laptop, at zero marginal cost, beating models several times its size on the exact benchmarks that predict real agentic usefulness. The AIME25/LiveCodeBenchv6 gap against Qwen3.5-9B is the honest asterisk — this is a tool-use and instruction-following specialist, not a frontier reasoning model, and Liquid AI's benchmark selection reflects that focus rather than obscuring it.

Related on explainx.ai:

• Pipette — Liquid AI on-device benchmark suite (Aug 24)
• S1-mini: Superwhisper's 0.6B on-device transcript cleaner — another small specialist that runs fully on-device, for ASR cleanup rather than tool use
• Matic Cues: How a Home Robot Runs Voice, Vision, and Mapping On-Device — a real-product case study in the same edge-AI tradeoffs
• TwIL-LM3: 3B Beats GPT-OSS-120B on Logic — With Three Asterisks
• Pokee-Isaac 28B: A Real 10M-Token Context Model on One GPU
• Why AI Agents Haven't Gone Mainstream (Consumer Adoption Gap)
• LFM2.5-230M: Liquid AI's Edge Agent Model
• Claude in Chrome: Features, Access & Safety
• How to Use Claude Cowork Safely
• Build a Personal AI System: Local Workflow Guide
• NVIDIA DGX Spark: Best Local LLM Setup

Official: LFM2.5-2.6B — Liquid AI blog · Model on Hugging Face

Benchmark numbers and hardware throughput figures reflect Liquid AI's August 4, 2026 release and may change as the model is updated.