LFM2.5-2.6B: 220 tokens/s local agents under 2.5GB, wired into Hermes Agent and OpenClaw

The center of gravity in edge LLMs has shifted over the last six months. The question is no longer "can this run a chat on a phone" but "can this drive an agent on a phone." Liquid AI's LFM2.5-2.6B, released on August 4, 2026, is built exactly for that new target: a 2.6B-parameter dense model, 128K context, a 128K-token vocabulary, and a memory footprint held under 2.5GB — while trading punches with the 9B-class Qwen3.5-9B on every agentic benchmark.

Spec and training data

LFM2.5-2.6B is a dense model aimed squarely at agentic workloads: 2.6B total parameters, pre-trained on roughly 34T tokens. Liquid AI stayed dense here (the 8B-A1B variant was the MoE one); the point of going dense is that weights are easier to schedule on edge hardware. The vocabulary is doubled from the LFM2 era's ~64K to 128K by extending the existing BPE tokenizer in place with subword-mean initialization rather than re-training the model. Mid-training includes a dedicated 128K context-extension phase so the model can absorb the long inputs that agentic workflows need.

Post-training runs through a four-stage pipeline. Liquid AI is unusually explicit about it:

  1. Supervised Fine-Tuning (SFT). Two SFT stages: broad coverage first, then a targeted shaping pass on agent tasks, reasoning, and tool use. The total SFT mix is roughly 7× the size of the one used for LFM2.5-8B-A1B.
  2. Teacher Specialization. A set of domain experts branch from the same SFT checkpoint and each deep-dives its area (reasoning, knowledge, code, tool use, long context) with RLVR.
  3. Multi-Domain On-Policy Distillation (MOPD). The student model rolls out under its own policy; per-domain teachers are routed to give token-level supervision. This is closer to the student's distribution than off-policy distillation and lets multiple domain capabilities converge inside a single model.
  4. Agentic Reinforcement Learning (Agentic RL). Multi-turn agentic RL inside real harnesses, optimized with GRPO and an outcome reward that combines an LLM-as-judge rubric, programmatic checks, and a hard safety gate. Training directly inside Hermes Agent, OpenClaw, and other harnesses means the model learns their tool APIs, system prompts, and interaction patterns.

A piece of engineering worth flagging: the Harness Proxy treats agent harnesses as black boxes and transparently captures token-level trajectories to reconstruct RL samples. In practice, LFM2.5-2.6B is not just learning "general tool use" — it is being trained to behave reliably inside Hermes Agent / OpenClaw / Pi.

Benchmarks: a quarter of the size, near 9B-class tool use

Liquid AI published results on BFCLv4, ToolSandbox, PinchBench, τ³-Bench, Claw-Eval, BrowseComp+, AIME25, IFBench, Multi-IF, IFStruct, AA-Omniscience, and LiveCodeBenchv6. The comparators are gemma-4-E2B-it (5.1B), gemma-4-E4B-it (8B), Qwen3.5-4B (4.7B), and Qwen3.5-9B (9.7B) — between 1.5× and 4× the size of LFM2.5-2.6B.

LFM2.5-2.6B wins every instruction-following benchmark: Multi-IF 80.07 vs. Qwen3.5-9B's 62.55; IFStruct 85.49 vs. 78.50; AA-Omniscience-Public -29.50, a wide margin over Qwen3.5-9B's -50.43. On tool use, BFCLv4 is 56.88 (a touch below Qwen3.5-9B's 60.13), ToolSandbox is 77.83 (above 76.44), and PinchBench is 68.22 (below 71.45). AIME25 lands at 51.87 — losing to Qwen3.5-9B's 56.07 but well clear of Gemma-4-E4B's 34.27.

The blog's own summary: LFM2.5-2.6B leads on every instruction-following benchmark and on almost every tool-use benchmark, only losing on math and code generation against the 9B.

Inference speed: a phone can run it; an H100 can spit out 1.3B tokens/day

Liquid AI's deployment numbers are concrete:

  • M5 Max (CPU): 220 tokens/s, < 2.5 GB of memory.
  • Ryzen AI Max+ 395 (CPU): 113 tokens/s.
  • Smartphone: 30 tokens/s, enough for a complete multi-step agent loop.
  • NVIDIA H100 SXM5: SGLang 0.5.16, 1,024 input / 256 output, BF16, sustaining high concurrency. LFM2.5-2.6B reaches nearly 15K output tokens/s, i.e. about 1.3B tokens per day on a single card.

Day-one inference stack coverage includes llama.cpp (GGUF), MLX (Apple Silicon), vLLM, SGLang, and ONNX — Apple, AMD, Qualcomm, and NVIDIA. The open weights on Hugging Face ship in two flavors: base (LFM2.5-2.6B-Base) and post-trained (LFM2.5-2.6B).

Why "local agents" matters right now

Running an agent entirely on-device is not about feasibility; it's about removing the per-token marginal cost. Liquid AI states the motivation bluntly: when token spend is no longer a constraint, agents can be massively parallelized on local hardware, run as background tasks, burn through millions of tokens with no marginal cost. That changes how developers build agents.

Choosing LFM2.5-2.6B as the "flagship" of the LFM2.5 family makes sense given that lineup. LFM2-8B-A1B (1.5B-active MoE) lifted the ceiling for edge LLMs in June. LFM2.5-VL-450M pushed edge VLMs to sub-second in June. The 2.6B dense model fills a different gap: the sweet spot where a full multi-step agent actually runs reliably, not the smallest possible chat model and not the heaviest edge MoE.

Commentary and caveats

From an engineering angle, the headline is not the parameter count — it's that agent training and harness training are bundled together. Most LLM training stops at the "tool use" layer; agent behavior is assembled on top by the harness's prompts and heuristics. Liquid AI runs RL inside Hermes Agent and OpenClaw, which means the model's weights absorb the system prompt, the tool protocol, and the multi-turn interaction pattern. That is friendly to the targeted harnesses, but it raises an open question: does the model transfer cleanly to other harnesses? Liquid AI does not publish cross-harness results.

Another caveat: BrowseComp+ (OpenClaw) and PinchBench are reported only against OpenClaw. These benchmarks are tightly coupled to task-style multi-step agent behavior, but evaluating inside the harness itself blurs the line between model capability and harness fit. Reproducers and independent reviewers should keep that in mind.

Finally, code generation is still the 9B models' territory. LiveCodeBenchv6: LFM2.5-2.6B 59.41 vs. Qwen3.5-9B 69.86 — a 10-point gap. Liquid AI's own blog is candid: "for more complex agentic tasks or coding-heavy workloads, larger models may still be a better fit." What the 2.6B buys you is "runs, runs cheaply, runs privately" — not "wins every benchmark."

Closing

On BFCL, ToolSandbox, IFBench, and Multi-IF — the benchmarks that most closely track real agent capability — LFM2.5-2.6B matches or beats 9B-class models from a quarter of the size. On an M5 Max it runs at 220 tokens/s under 2.5 GB of memory. Hermes Agent, OpenClaw, and Pi users can pull the weights directly from Hugging Face and wire them into existing harnesses today.

Liquid AI has put a number on the gap between "local agents" as a slogan and as a measurable product. What remains is whether developers are willing to swap their cloud token bills for local kilowatt-hours.

References: