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

Last updated: August 5, 2026

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 (our setup guide), 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.

FAQ#

How fast is LFM2.5-2.6B on a laptop?#

Liquid AI 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 in under 2.5 GB of memory.

Is LFM2.5-2.6B good for coding?#

Coding is its weak spot. In the vendor benchmarks, larger models such as Qwen3.5-9B keep a clear lead on LiveCodeBench v6, so it is better suited to research, writing, tool orchestration, and document workflows than to work as a code assistant.

Can LFM2.5-2.6B be used commercially?#

It ships 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. A company above that threshold needs a commercial agreement.

How do I run LFM2.5-2.6B locally?#

Day-one support covers llama.cpp (GGUF), MLX, vLLM, SGLang, and ONNX. The setup path is to serve the model as an OpenAI-compatible endpoint and point a harness such as Hermes Agent, OpenClaw, or Pi at it. A WebGPU demo on Hugging Face also runs a research agent in the browser with no setup.

Does LFM2.5-2.6B work with OpenCode?#

Not out of the box. It is not in OpenCode's model registry, so you serve it with vLLM or llama.cpp and configure it as a custom provider in OpenCode.

Continue Reading#

• Small AI Models Are Finding Real Users Where Networks Fail - real deployments of on-device models where connectivity is unreliable
• The Best Local Coding LLMs in 2026 - how on-device models compare for real workloads
• Local LLM Speed by Hardware: What llmspeed Gets Right - estimate tokens per second for a model on your hardware
• 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
• LFM2.5-VL-3B: Liquid AI''s 3B Vision Model Reads Screens, Grounds Objects, and Calls Tools on a Laptop
• LFM2.5-24B-A2B vs Qwen3.6-35B-A3B - Liquid's 24B-A2B agent model against the Qwen coder, tool use vs SWE-Bench
• Best Local Models - what else runs on your own hardware, by memory tier
• Best Open-Source Models - the open-weight field, ranked

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