Liquid AI's LFM2.5-2.6B Beats 9B Models Running Entirely on Your Phone

The premise of on-device AI agents has always been compelling but frustratingly out of reach. Models small enough to run locally tend to fall apart the moment you ask them to plan across multiple steps, call tools reliably, or follow complex instructions. Liquid AI is pushing directly against that wall with LFM2.5-2.6B, a 2.6B parameter model purpose-built for agentic workloads that runs entirely on-device, no cloud calls required.

Zero marginal cost agents

Agents that depend on cloud APIs carry per-token costs, latency, and privacy exposure. Running inference locally eliminates all three. More importantly, removing the per-token cost changes how developers can architect systems: agents can be massively parallelized on local hardware, burning through millions of tokens in the background at no marginal cost. When token spend stops being a constraint, you can run agents continuously, on the user's own hardware, across any number of parallel tasks.

LFM2.5-2.6B is small enough to run on a phone, fast enough to stay responsive on a CPU, and capable enough to handle planning, tool calls, and multi-step workflows.

A hybrid architecture built for constrained hardware

LFM2.5-2.6B is built on the LFM2 hybrid architecture, which is the primary reason it performs well on constrained hardware. LFM2 pairs efficient gated short convolution blocks with a small number of grouped query attention (GQA) blocks. Attention accounts for only about 37% of the model; the remaining 63% uses cheaper convolution blocks.

In a standard Transformer, every layer uses Softmax Attention, which scales quadratically with sequence length and produces large KV caches that consume VRAM. The LFM2 convolution blocks sidestep this entirely. Each convolution layer maintains a fixed-size state that updates on each new token. There is no attention over past tokens and no KV cache: state memory at token 10,000 is identical to state memory at token 10.

The specific block type is called an LIV (Linear Input-Varying) convolution, a linear-time operator whose behavior changes based on the input. Liquid AI ran hardware-in-the-loop architecture search to find the best layer mix across quality, latency, and memory. The search space included GQA, short convolutions, linear attention, S4, Mamba, and Mamba2. The winning configuration was the simplest: mostly short convolutions, with a handful of attention layers to handle long-range retrieval. LFM2.5-2.6B has 30 layers total: 22 double-gated short convolution blocks and 8 GQA blocks.

Four-stage post-training

The base model is pre-trained on roughly 34 trillion tokens, with a 128K context extension phase included. Converting it into an agent required a four-stage post-training process:

1. Supervised Fine-Tuning (SFT): Two consecutive SFT stages, starting with broad domain coverage, then targeted shaping on priority skills including agentic tasks, reasoning, and tool use. The SFT training mix is about seven times the size of the one used for LFM2.5-8B-A1B, with heavier weighting toward tool use, web search, software engineering, and agent traces.
2. Teacher Specialization: From the shared SFT checkpoint, one expert per target domain is trained through a focused SFT round followed by reinforcement learning with verifiable rewards (RLVR). Specialists cover instruction following, math, knowledge (including hallucination control), code, tool use, and long context.
3. Multi-Domain On-Policy Distillation (MOPD): The specialized experts act as teachers, distilling their capabilities into a single student model. Unlike off-policy distillation, MOPD lets the student roll out under its own policy. Each prompt is routed to the appropriate domain expert, which supervises the student's response with token-level feedback.
4. Agentic RL: The final stage trains the model inside real agent environments through multi-turn agentic reinforcement learning. Tasks cover research, writing, coding, data analysis, document management, external tool use, and multi-step workflow automation.

Each training rollout runs in a dedicated sandbox. The model is optimized with GRPO (Group Relative Policy Optimization), an RL algorithm that improves the model by comparing groups of its own outputs against each other rather than relying on a separate reward model. The reward signal combines an LLM-as-a-judge rubric, programmatic checks, and a hard safety gate. Training directly inside Hermes Agent, OpenClaw, and other harnesses exposes the model to their tools, system prompts, and interaction patterns before deployment.

Benchmark results: where it leads, where it doesn't

On instruction following and tool use, LFM2.5-2.6B consistently beats models two to four times its size:

LFM2.5-2.6B leads on every instruction-following benchmark and nearly every tool use benchmark. On agentic tasks, it outperforms the Gemma models across the board and trades closely with Qwen. Coding is the one area where larger models hold a clear edge, and Liquid AI is transparent about this: the model card explicitly flags it as not recommended for agentic coding or knowledge-heavy tasks.

Inference speed

Raw benchmark scores matter less if the model can't run fast enough to be useful. LFM2.5-2.6B decodes at 220 tokens/s on an M5 Max and 113 tokens/s on a Ryzen AI Max+ 395, while staying under 2.5 GB of memory. On a phone, it holds 30 tokens/s. CPU prefill and decode run roughly 2x faster than comparably sized Transformer models, and the absence of a KV cache keeps memory usage flat regardless of sequence length.

On GPU, the model reaches nearly 15,000 output tokens per second at high concurrency, approximately 1.3 billion tokens per day on a single H100. That throughput makes high-volume agentic pipelines genuinely economical at the server side as well.

Getting started

Both the base model (LFM2.5-2.6B-Base) and the post-trained version (LFM2.5-2.6B) are available on Hugging Face. The model ships with support across the full inference stack:

• llama.cpp (GGUF) for CPU and local deployment
• MLX for Apple Silicon
• vLLM and SGLang for GPU-accelerated serving
• ONNX for cross-platform and edge deployments

Serving a local agent requires two steps: run the model behind an OpenAI-compatible endpoint, then point your agent harness at it. It works out of the box with Hermes Agent, OpenClaw, and Pi. The model is also fine-tunable on a single GPU, with Unsloth and TRL notebooks provided in the Hugging Face model card.

Minimal Transformers setup:

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)
input_ids = tokenizer.apply_chat_template(
    [{"role": "user", "content": "Research the top 3 open-source agent frameworks"}],
    add_generation_prompt=True,
    return_tensors="pt",
    tokenize=True,
)["input_ids"].to(model.device)
output = model.generate(
    input_ids, temperature=0.1, top_k=50,
    repetition_penalty=1.1, max_new_tokens=512
)

What shifts with this approach

Until recently, running an agent meant accepting cloud latency and cost, or accepting a significant capability drop with small local models. That tradeoff is narrowing. The architecture keeps memory flat at scale; the training pipeline targets the actual harnesses developers deploy rather than synthetic traces. The model has already seen the tool schemas, system prompts, and interaction patterns of Hermes Agent, OpenClaw, and Pi before you deploy it, which gives it a practical head start in those ecosystems. You can explore the full LFM model library to see where LFM2.5-2.6B fits within Liquid's broader range of text, vision, and audio models.