LFM2.5-2.6B shipped August 4, 2026.
Open-weight, on-device, built for agents that plan and call tools without touching a cloud. Phone, laptop, PC, robot. Doesn’t matter. The whole loop runs local.
Quantized footprint: under 2.5 GB.
Context window: 128K tokens. No API means no server bill, which means each agent run costs basically nothing. That flips the default assumption most builders carry around. Real agents don’t necessarily need a hosted frontier model anymore. If the job is local planning and tool-calling over private data, LFM2.5-2.6B runs where the data already lives.
LFM2.5-2.6B Memory and Speed Benchmarks
The honest constraint on “runs on-device” claims? Memory. Not speed.
A standard 7B transformer quantizes down to roughly 4 GB.
Already a fight on a phone running a browser, camera app, and messaging stack all at once. The OS will eventually kill it for RAM.
LFM2.5-2.6B lands under 2.5 GB quantized. That’s the gap between a model coexisting with real device workload versus getting murdered by the operating system.
Throughput backs the claim:
– ~220 tokens/s decoding on Apple M5 Max
– ~113 tokens/s on AMD Ryzen AI Max+ 395
– ~30 tokens/s on a phone, all inside the 2.5 GB budget
Thirty tokens per second on a phone. Agent loop feels snappy instead of spinner death. Desktop CPU clearing 100+ tokens/s? You can run an agent making ten tool calls in a workflow and nobody notices the wait.
Server-side operators should flag a second number. At high concurrency, Liquid AI claims roughly 15,000 output tokens per second. That’s about 1.3 billion tokens per day on a single NVIDIA H100. If you’re indie-hosting for customers, that’s the number that shifts your unit economics.
LFM2.5-2.6B Architecture Explained
Not a transformer. Not in the usual sense.
LFM2.5-2.6B is a hybrid with 30 layers: 22 double-gated short convolution blocks plus 8 grouped-query attention (GQA) layers, sitting on a 128K-token vocabulary and a 131,072-token context window. Those convolution blocks are why it decodes at hundreds of tokens per second on a CPU. They sidestep quadratic attention cost on long sequences for most of the network depth.
Pre-training ran on about 34 trillion tokens.
Then a dedicated 128K context-extension phase. Liquid AI also doubled the tokenizer vocabulary to 128K by extending the existing tokenizer in place rather than retraining from scratch, mostly to improve non-Latin script support. Version counting is worth keeping straight: finance and developer coverage rounds to 2.69B parameters, while Hugging Face lists 2,569,272,320 for the base architecture. Same model, different rounding conventions.
Here’s why this matters for agents specifically. Agentic workloads spend most of their tokens on short structured output. Tool calls, JSON, step plans. Not long creative prose. A convolution-heavy hybrid fits that pattern well, which is too why the benchmarks look the way they do.
On-Device Agent vs Cloud: When to Use Each
Benchmark numbers are where this gets interesting.
On ToolSandbox, LFM2.5-2.6B scores 77.83. Qwen3.5-9B sits at 76.44.
On IFStruct, it’s 85.49 against Gemma-4-E4B at 76.65.
Liquid AI’s own sweep covered gemma-4-E2B-it, gemma-4-E4B-it, Qwen3.5-4B, and Qwen3.5-9B. Their model leads on every instruction-following benchmark and nearly every tool-use benchmark, trailing only Qwen3.5-9B on BFCLv4.
Tool-use benchmark comparison:
– ToolSandbox: LFM2.5-2.6B at 77.83 vs Qwen3.5-9B at 76.44
– IFStruct: LFM2.5-2.6B at 85.49 vs Gemma-4-E4B at 76.65
– BFCLv4: Qwen3.5-9B still wins. The harder function-calling benchmark
A 2.6B model beating a 9B model on tool-use. That’s the part worth underlining.
Developer’s Digest notes the training method likely drives the agentic strength — LFM2.5-2.6B was trained inside real agent runtimes rather than on static chat data. Fine-tuning and reinforcement learning happened in actual agent evaluation environments. Tracks with what the benchmarks show. But these are vendor-run numbers, so treat exact margins as a Liquid AI claim, not independent verification.
The pattern holds across tables though.
BFCLv4 is the honest gap. Losing to a model more than three times your size on the harder function-calling benchmark tells you where the ceiling sits. Deep coding, broad factual recall, anything rewarding raw parameter count. Hosted frontier model, still the right call. For structured local agent loops, the gap’s mostly closed.
Deploying LFM2.5-2.6B Locally
Deployment math is what I care about as someone running a small shop.
Three things move simultaneously when agents run on-device: API bill drops to zero, latency shrinks to local speed. And client data never touches a third-party server. For work like mine. Routing client emails, parsing internal docs, triggering local tools against private systems, “data never leaves the device” isn’t a nice-to-have.
It’s the difference between a workflow I can ship and one I have to redact around.
Format support makes it practical to pull down. Liquid AI publishes base and post-trained checkpoints on Hugging Face in GGUF, ONNX, and MLX formats. Mac, Windows, Linux edge box, phone — no re-engineering required.
Getting it running:
1. Download the GGUF from Hugging Face
2. Load it through your local runner. Llama.cpp, Ollama, LM Studio, whatever you already use
3. Point your agent runtime at it
4. Measure against one real client workflow
Tbh, if your client job is tool-calling over a local knowledge base, spend a day testing this before paying for another hosted agent run.
Stay skeptical on depth though.
A 2.6B model isn’t writing your backend or reasoning through a novel integration architecture. Use it for the loop, the routing, the structured calls. Use a hosted model for the hard creative and reasoning work. Let the local agent own the part that touches private data and runs a thousand times a day.
Side note: the Hugging Face repo has like six GGUF variants and honestly I had to read the README twice to figure out which one I wanted. Minor thing.
LFM2.5-2.6B FAQ: Common Questions
What is LFM2.5-2.6B?
Open-weight model from Liquid AI, shipped August 4, 2026. Hybrid architecture — 22 double-gated short convolution blocks, 8 GQA layers, 30 layers total. 2.6B parameters, fits under 2.5 GB quantized, 128K context window. Built for on-device agent workloads: planning, tool-calling, multi-step workflows. No cloud required.
How fast is Liquid AI on-device?
Depends on hardware. Apple M5 Max hits ~220 tokens/s. AMD Ryzen AI Max+ 395 manages ~113 tokens/s. Phone gets ~30 tokens/s. All within the 2.5 GB memory budget. On desktop CPU, over 100 tokens/s means agent loops with multiple tool calls feel responsive, not laggy.
Can it replace GPT-4 for agents?
Not entirely. For structured local agent loops. Routing, tool calls, JSON, step plans. The gap has largely closed. LFM2.5-2.6B beats models three times its size on tool-use benchmarks. But BFCLv4, the harder function-calling benchmark, still goes to larger models. Deep coding, broad factual recall, complex reasoning. Hosted frontier models win there. Use the local model for the loop.
Use cloud for the hard stuff.
What formats is LFM2.5-2.6B available in?
GGUF, ONNX, and MLX. Base and post-trained checkpoints are on Hugging Face. Targets Mac, Windows, Linux, and phone deployments without re-engineering. Run through llama.cpp, Ollama, or LM Studio.
