Liquid AI just dropped LFM2.5-2.6B, and the headline is simple: this is the fastest, most capable small agent model you can run locally right now. At 2.6B parameters, it beats models up to 9.7B on instruction following and tool use, runs at 220 tokens per second on an M5 Max, and fits in under 2.5 GB of memory.
The big idea is agents that run entirely on-device—laptops, phones, edge hardware—with no cloud dependency, no latency, and no recurring inference bill. LFM2.5-2.6B is purpose-built for that.
The benchmarks: punching way above its weight
Liquid tested LFM2.5-2.6B against Gemma-4 (5.1B and 8B) and Qwen3.5 (4.7B and 9.7B). It's the smallest model in the group, yet it wins or ties on nearly every agentic and instruction-following task.
On instruction following, LFM2.5-2.6B leads every benchmark: 59.17 on IFBench, 80.07 on Multi-IF, and 85.49 on IFStruct. The next-best is Qwen3.5-9B at 56.47, 62.55, and 78.50 respectively. That's a model nearly 4x the size.
For tool use, it tops ToolSandbox (77.83 vs. Qwen3.5-9B's 76.44) and comes second on BFCLv4 (56.88, just behind Qwen3.5-9B's 60.13). On agentic tasks like PinchBench and BrowseComp+, it either leads or stays neck-and-neck with the 9.7B Qwen.
The one clear gap is coding. On LiveCodeBenchv6, Qwen3.5-9B hits 69.86; LFM2.5-2.6B scores 59.41. If your app is code-heavy, reach for something bigger. But for agents that need to follow complex instructions, call tools, and navigate multi-turn workflows, this is the model.
Agentic RL: training inside real harnesses
The most interesting part isn't the benchmarks—it's how they got there. Liquid trained LFM2.5-2.6B with what they call Agentic RL: reinforcement learning run inside real agent harnesses like OpenClaw and Hermes Agent.
Most RL setups simulate environments or use synthetic data. Liquid instead executed actions in live agent frameworks, collected real multi-turn trajectories, and optimized the model to work across different tools, system prompts, and task types.
The architecture splits cleanly: a Training Engine optimizes the model, a Rollout Engine generates actions with the latest policy, and a Sandbox Service executes those actions inside blackbox harnesses. A Harness Proxy sits between them, capturing token-level trajectories without modifying the harness itself.
This means the model isn't just good at benchmarks—it's explicitly trained to be compatible with the agent frameworks developers actually use. That's a subtle but powerful shift: most models are fine-tuned on curated datasets and hope they generalize to real harnesses. LFM2.5-2.6B was optimized inside them.
Four-stage post-training pipeline
Before Agentic RL, Liquid ran three earlier stages:
- Supervised fine-tuning (SFT): Two rounds, heavily weighted toward agentic data like tool use, web search, and harness trajectories.
- Teacher specialization: Train one specialist teacher per domain—math, code, tool use, etc.
- Multi-domain on-policy distillation (MOPD): Distill all the specialist teachers into a single student model.
- Agentic RL: Multi-turn RL inside real harnesses, as described above.
The base model was pre-trained on roughly 34T tokens, with a mid-training phase that extends the context window to 128K. The full pipeline is end-to-end optimization for agentic workflows, not general chat.
Inference speed: 220 tok/s on a laptop
LFM2.5-2.6B ships with day-one support across the inference ecosystem: llama.cpp, MLX, vLLM, SGLang, and ONNX. On CPU, it hits 220 tokens per second on an M5 Max and 113 tokens per second on a Ryzen AI Max+ 395. Even on a phone, it runs at 30 tok/s.
On GPU, it's the fastest model in its size class: nearly 15K output tokens per second at high concurrency, which works out to roughly 1.3 billion tokens per day on a single H100.
That's not just fast for a small model—it's fast, period. The LFM2 architecture (Liquid's proprietary design) is doing real work here.
When to reach for it
Use LFM2.5-2.6B when you need:
- On-device agents with no cloud dependency
- High-volume tool use without inference bills
- Multi-step workflows with complex instructions
- Privacy-sensitive tasks where data can't leave the device
Don't use it for heavy code generation. That's the one place the larger models keep a clear lead.
Liquid ships both the base model (LFM2.5-2.6B-Base) and the instruction-tuned version (LFM2.5-2.6B) on Hugging Face. They also have a WebGPU demo of a research agent running entirely in-browser—no setup, no server.
What this means for local agents
We're at an inflection point. A year ago, "local agent" meant hobbyist demos or toys. LFM2.5-2.6B is the first model I've seen that's genuinely production-ready for edge deployment: competitive with cloud models 4x its size, fast enough for real-time interaction, and small enough to fit on a phone.
The Agentic RL approach is also worth watching. Training inside real harnesses instead of simulated environments is obvious in hindsight, but I haven't seen another team do it at this scale. If it generalizes—and the benchmarks suggest it does—this could be the new standard for post-training agentic models.
Liquid is making a specific bet: that the future of agents is edge-first, not cloud-first. LFM2.5-2.6B is the clearest execution of that vision yet.