LFM2.5-2.6B: the tiny agent that outruns models 4x its size

Building useful AI agents has mostly been a scale game so far: bigger models, longer contexts, more tools in the loop. Liquid AI is betting the opposite way. Its new LFM2.5-2.6B squeezes the agentic stack into 2.6 billion parameters that run in under 2.5 GB of memory. On the company's own evaluations, the model competes with rivals up to four times its size on tool use and multi-step agentic tasks, and beats all of them on instruction following. It is the same small-model case Liquid made with its LFM2.5 encoders.

That is the sales pitch, and for once there are numbers behind it. Liquid published a full benchmark run against four larger models: gemma-4-E2B-it (5.1B), gemma-4-E4B-it (8B), Qwen3.5-4B (4.7B) and Qwen3.5-9B (9.7B). LFM2.5-2.6B is the smallest model in that group. The same trick has worked before in safety, where a 3B classifier outgunned models seven times its size.

The smallest model in the group, ahead on instruction following

Liquid reports its 2.6B model in first place on every instruction-following benchmark in the suite, and in first place on every tool-use benchmark except BFCLv4, where only the 9.7B Qwen edges ahead.

Benchmark	LFM2.5-2.6B (2.6B)	gemma-4-E2B-it (5.1B)	gemma-4-E4B-it (8B)	Qwen3.5-4B (4.7B)	Qwen3.5-9B (9.7B)
AA Omniscience	-29.50	-74.47	-49.03	-54.30	-50.43
AIME25	51.87	26.33	34.27	49.33	56.07
IFBench	59.17	34.08	39.24	48.40	56.47
Multi-IF	80.07	69.44	77.35	55.67	62.55
BFCLv4	56.88	36.98	46.39	50.56	60.13
ToolSandbox	77.83	52.40	65.00	75.55	76.44
BrowseComp+ (OpenClaw)	26.89	8.31	15.90	24.46	27.23

On agentic tasks the gap narrows: LFM2.5-2.6B beats both Gemma models and stays level with the Qwens, while posting the group's top score on AA Omniscience. Liquid summarizes the results as leading on knowledge and staying close on math. These are the company's own numbers, with no third-party verification attached, but the wins are not rounding errors.

Four training stages, one black-box harness trick

LFM2.5-2.6B starts from a base model pre-trained on roughly 34 trillion tokens, with a mid-training phase that extends the context window to 128K. The agentic behavior is a post-training job, and it runs in four stages.

• Two rounds of supervised fine-tuning, weighted toward agentic data: tool use, web search, and harness trajectories.
• One specialist teacher per domain: math, code, tool use, and more.
• Multi-domain on-policy distillation, which folds the teachers back into a single student.
• Agentic reinforcement learning, where multi-turn RL runs inside real agent harnesses so the model learns across tools, system prompts, and multi-turn task environments.

Multi-domain on-policy distillation is the stage with the clearest lineage. SEED's on-policy distillation showed that a model can improve by turning its own past trajectories into reusable lessons; Liquid spreads that work across several specialist teachers before folding them back into one student.

The fourth stage is where the engineering gets interesting. Liquid separates model optimization, inference, and environment execution, then runs the agent inside a black-box harness, naming OpenClaw and Hermes Agent as examples. A Harness Proxy intercepts the harness's model calls and records the token-level trajectories the training loop needs, without modifying the harness.

The trade-off is that the harness itself becomes part of the training surface. Some harnesses are substantially harder to learn from than others, and RL mostly improves reliability while critical abilities like error recovery stay weak.

Fast enough for a phone, cheap enough for a fleet

Then there is raw speed. Liquid reports 220 tokens/s decode on an Apple M5 Max and 113 tokens/s on an AMD Ryzen AI Max+ 395, both under 2.5 GB of memory. At 30 tokens/s, the company says, the model is fast enough for a capable agent on a phone. At high concurrency on a single H100, it pushes almost 15,000 output tokens per second, roughly 1.3 billion tokens a day.

Day-one support covers llama.cpp, MLX, vLLM, SGLang, and ONNX, and the model loads through transformers 5.0.0 or later. Both LFM2.5-2.6B and the LFM2.5-2.6B-Base variant are on Hugging Face, a WebGPU demo runs a research agent in the browser, and Liquid published guides for running local agents in harnesses like OpenClaw, Hermes Agent, and Pi.

Coding is where the bigger models earn their size

The one place the size advantage reverses is code. On LiveCodeBench v6, every rival except the 5.1B Gemma scores higher than LFM2.5-2.6B's 59.41. Liquid says the larger models keep a clear lead there and recommends reaching for something bigger. It is a concession worth reading closely, because other labs are making code the centerpiece of agentic training. Macaron-V1-Venti's 748B design is the same bet at the other end of the scale: four specialists, coding among them, and wins over GPT-5.5 and Claude Opus 4.8. Liquid went the other way: small, general, fast, and explicitly not for code.

Both are bets on the same thesis: agentic behavior comes from how a model is trained, not just from how big it is. Microsoft is betting on the same idea with coach-based training that replaces a score with transferable lessons. Liquid calls the release a step toward 'AI that runs anywhere.' For tool use, instruction following, and multi-step tasks on local hardware, the numbers make that pitch credible. For everything else, there is always a bigger model.