A developer on your team opens a laptop on the train, no Wi-Fi, and their agent keeps running - planning steps, calling tools, reading context from a 128K window. That is not a hypothetical. 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.
That last claim needs unpacking. Some of it holds up. Some of it does not.
What makes this release genuinely different from other small models
Most small model releases are general-purpose models shrunk down. LFM2.5-2.6B was designed from the architecture up for agentic inference - the combination of tool calling, multi-step planning, and long-context recall that kills most sub-3B models.
The model has 2.69B total parameters across 30 layers. The stack is 22 double-gated short convolution blocks plus 8 grouped-query attention blocks. Vocabulary size is 128,000 and context length is 131,072 tokens. That convolution-attention hybrid is the architectural bet: convolutions are faster and cheaper on memory-constrained hardware than pure attention, while the GQA layers preserve the context tracking that tool-calling agents actually need.
Pre-training used approximately 34 trillion tokens. The post-training pipeline leaned into agentic harnesses specifically - not generic RLHF but reinforcement learning run inside the tool environments the model is expected to operate in. The model was trained inside the most popular agentic harnesses to improve compatibility.
The memory and speed numbers are specific enough to mean something:
LFM2.5-2.6B ships with day-one support across the inference ecosystem, including llama.cpp, MLX, vLLM, SGLang, and ONNX. That breadth matters. A model that requires a specific runtime to hit its claimed numbers is harder to slot into an existing workflow; this one is not.
What the benchmarks actually say (including the gaps)
Liquid AI's own numbers show a consistent pattern. LFM2.5-2.6B tops every instruction-following benchmark and every tool-use benchmark except BFCLv4, where only the 9.7B Qwen edges ahead. On agentic tasks, it beats both Gemma models and stays even with the Qwens.
Concretely, from the vendor's evaluation: LFM2.5-2.6B scores 80.07 on Multi-IF, 85.49 on IFStruct, 56.88 on BFCLv4, 77.83 on ToolSandbox, 62.85 on Claw-Eval, and 68.22 on PinchBench. These are vendor-published numbers evaluated with vLLM, so treat them as a starting point rather than a ground truth.
The honest read:
| Capability | LFM2.5-2.6B vs. peers | Verdict |
|---|---|---|
| Instruction following | Beats all 2B-8B baselines tested | Strong |
| Tool use (ToolSandbox) | 77.83, beats Gemma 4 E4B (8B) | Strong |
| BFCLv4 agentic eval | 56.88, trails Qwen3.5-9B | Competitive |
| Coding (LiveCodeBench) | Larger models keep a clear lead | Weak |
| Math (AIME25) | Trails Qwen3.5-4B and -9B | Weak |
| Throughput (H100) | ~15K tok/s, fastest in class | Strong |
The takeaway is not that a 2.6B model has suddenly replaced larger models. The more interesting takeaway is: a small model can be highly competitive when it is specifically optimized for agentic workloads.
If your agent is writing code or solving AIME problems, reach for something bigger. If it is triaging tickets, routing requests, calling APIs, and summarizing context from a long thread, a 2.6B model running on your own hardware is now a serious option.
What "on-device agent" actually means for a team
The model is small enough to run on a phone, fast enough to stay responsive on a CPU, and capable enough to power agentic workflows: planning, calling tools, and tackling multi-step tasks. Unlike agents that depend on cloud APIs, local agents give you free inference, low latency, and real privacy.
"Free inference" is the number most teams skip past. If a support or ops team runs 50,000 agent turns a month against a cloud API at $1.50 per million tokens - at roughly 500 tokens per turn, that is $37.50/month, which sounds cheap until you have five agents and three teams each running similar volumes. A model that fits on a MacBook Pro eliminates that line item entirely and keeps data off third-party infrastructure, which matters when the context is internal tickets, personnel records, or unreleased roadmaps.
The privacy argument is not hypothetical. Because inference stays local, data never leaves the device and the marginal cost of each run is zero beyond electricity. That is a meaningful constraint to remove for teams that cannot send data to external APIs.
Beagle in action#ops-tools, 10:52amA teammate like Beagle running on a local agent model like LFM2.5-2.6B keeps the whole loop - the retrieval, the reasoning, the draft - inside your own hardware boundary.
Where the hype outruns the reality
The "beats models 4x its size" framing is technically defensible on the benchmarks Liquid AI chose, but it is worth noting what those benchmarks measure: instruction following and single-step tool calls. Multi-hop reasoning chains, complex code generation, and deep math still favor larger models with real margins.
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.
The architecture claim also deserves scrutiny. The hybrid convolution-attention design is genuinely novel at this scale, but it is less tested in production than transformer architectures. Compatibility with the llama.cpp ecosystem is real, but edge cases in quantization behavior - particularly at Q4 - have not been documented by independent reviewers as of this writing.
The open-weights license is permissive for commercial use; verify the current terms at Liquid AI's model page before deploying in a production context, as on-device model licenses sometimes include redistribution or modification restrictions that the headline "open weights" framing does not surface.
On-device agent model: common questions
What does "on-device agent model" mean?
An on-device agent model runs entirely on local hardware - a laptop, phone, or workstation - without sending requests to a cloud API. It handles multi-step tasks like planning, tool calling, and context tracking. LFM2.5-2.6B does this in under 2.5 GB of memory, making it viable on consumer hardware without a discrete GPU.
Can LFM2.5-2.6B actually replace a cloud model for agent workloads?
For lightweight agentic tasks - tool routing, summarization, instruction following, and API calls - it competes with models up to 9B parameters. For coding, advanced math, or multi-hop reasoning chains, larger cloud models still outperform it. The right answer depends on your specific task distribution.
How fast does LFM2.5-2.6B run on a laptop CPU?
Liquid AI measured 220 tokens/s 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. At 30 tokens/s on modest hardware, a 300-token agent response takes about 10 seconds - slow for chat, fine for background agent tasks.
What inference runtimes does it support?
LFM2.5-2.6B ships with day-one support across the inference ecosystem, including llama.cpp, MLX, vLLM, SGLang, and ONNX. This covers the main local deployment paths without requiring any custom runtime.
Where does it fall short compared to larger models?
Coding and mathematical reasoning are the documented gaps. Coding is the one area where the larger models keep an edge. BrowseComp+ (complex web research) also scored low at 26.89, suggesting deep multi-source reasoning is still a weak point at this scale.