LFM2.5-2.6B is the first 2.6B-parameter model purpose-built to run a real agentic workflow — planning, tool calls, and multi-step tasks — entirely on-device. Released by Liquid AI on August 4, 2026, it is small enough to fit in under 2.5 GB of memory, fast enough to decode at ~30 tokens/second on a phone, and competitive with models four times its size on tool use and instruction following. For builders, small-business owners, and anyone who has hit the ceiling of per-token API pricing, it is the most credible free local AI model for agent work as of August 2026 — with one caveat: do not use it as your coding brain.
Last verified: 2026-08-05 · Best for on-device agents · 128K context · Under 2.5 GB RAM · LFM Open License v1.0 (free commercial use under $10M revenue)
What is LFM2.5-2.6B and why does it matter?
LFM2.5-2.6B is a 2.69-billion-parameter text model from Liquid AI, the second generation of the company's Liquid Foundation Model (LFM) family, released August 4, 2026. Unlike most small models tuned for chat, LFM2.5-2.6B was post-trained specifically for agentic workloads — planning, calling tools, and working through multi-step tasks — and it runs entirely on consumer hardware with no cloud dependency.
The reason it matters is simple economics. Cloud API agents bill you per token; a background agent that runs day and night can rack up serious spend even on cheap models. A local agent has zero marginal inference cost. Liquid AI's pitch is that removing the per-token ceiling is what unlocks the use cases that never made sense before: agents that parallelize across dozens of tasks, run around the clock, and never send your data anywhere.
How fast is LFM2.5-2.6B on consumer hardware?
LFM2.5-2.6B is the fastest model in its class on the hardware Liquid AI tested, thanks to the hybrid LFM2 architecture (22 double-gated short-convolution blocks plus 8 grouped-query-attention blocks across 30 layers).
| Hardware | Speed | Memory | Source |
|---|---|---|---|
| Apple M5 Max | 220 tokens/second | under 2.5 GB | Liquid AI launch blog, Aug 2026 |
| AMD Ryzen AI Max+ 395 (CPU) | 113 tokens/second | under 2.5 GB | Liquid AI launch blog, Aug 2026 |
| Phone (device class unspecified) | ~30 tokens/second | under 2.5 GB | Liquid AI launch blog, Aug 2026 |
| NVIDIA H100 (high concurrency, SGLang) | ~15,000 output tokens/second | BF16 | Liquid AI launch blog, Aug 2026 |
For context, 220 tokens/second on an M5 Max is comfortably faster than you can read — a usable agent loop feels instant. The sub-2.5-GB footprint is what makes a phone-class deployment realistic; most recent phones have 6-8 GB of RAM, so the model leaves room for the OS and the agent harness.
How does LFM2.5-2.6B compare to other small local models?
The honest read of LFM2.5-2.6B's benchmark profile is that it is unusually lopsided in a good way: it leads on agentic and instruction-following work, and trails on raw coding and the deepest knowledge tasks.
| Benchmark | LFM2.5-2.6B (2.6B) | Gemma-4-E4B-it (8B) | Qwen3.5-4B (4.7B) | Qwen3.5-9B (9.7B) |
|---|---|---|---|---|
| ToolSandbox (tool use) | 77.83 | 65.00 | 75.55 | 76.44 |
| IFBench (instruction following) | 59.17 | 39.24 | 48.40 | 56.47 |
| Multi-IF (instruction following) | 80.07 | 77.35 | 55.67 | 62.55 |
| BFCLv4 (function calling) | 56.88 | 46.39 | 50.56 | 60.13 |
| τ³-Bench Banking (agentic) | 5.67 | 4.12 | 5.45 | 5.15 |
| AIME25 (math) | 51.87 | 34.27 | 49.33 | 56.07 |
| LiveCodeBenchv6 (coding) | 59.41 | 63.77 | 60.85 | 69.86 |
Sources: All scores as reported by Liquid AI in the official launch benchmark table, Aug 2026.
Three things to take away. First, LFM2.5-2.6B leads every instruction-following benchmark tested, despite being the smallest model in the comparison. Second, it wins or ties on most tool-use and agentic benchmarks, trailing only Qwen3.5-9B (a model roughly 4x its size) on BFCLv4. Third, coding is the one place larger models keep a clear edge — Liquid AI itself says LFM2.5-2.6B is "not recommended for agentic coding and knowledge-heavy tasks."
For practical guidance on how to size your local model to your task, our Guide to Building a Multi-Model AI Coding Workstation walks through the same system-over-model logic that makes LFM2.5-2.6B a sub-agent, not a primary brain.
How was LFM2.5-2.6B trained for agents?
The model's training pipeline is the differentiator. Pre-training covers roughly 34 trillion tokens, and a mid-training phase extends the context window to 128K tokens. But the part that matters for agent builders is the four-stage post-training:
- Supervised fine-tuning (two rounds) — broad coverage, then targeted shaping for agentic tasks, reasoning, and tool use. The training mix is roughly 7x larger than LFM2.5-8B-A1B's, weighted heavily toward tool use, web search, software engineering, and agent traces.
- Teacher specialization — one expert per domain (instruction following, math, knowledge, code, tool use, long context) trained via focused SFT plus reinforcement learning with verifiable rewards.
- Multi-domain on-policy distillation (MOPD) — the specialized experts act as teachers, distilling capabilities back into a single student model that rolls out under its own policy.
- Agentic reinforcement learning — multi-turn RL through real agent harnesses (Hermes Agent, OpenClaw, and others), using GRPO with outcome-based rewards and a hard safety gate.
Stage 4 is the key. By training inside real harnesses rather than on synthetic tool-call data alone, the model is exposed to actual tool schemas, system prompts, and interaction patterns. Liquid AI credits this for the outsized tool-use and instruction-following scores relative to the 2.6B size.
How to run LFM2.5-2.6B locally (three paths)
Option 1: LM Studio (no code)
If you want the lowest-friction path, LM Studio is a desktop app that loads GGUF checkpoints and exposes an OpenAI-compatible local endpoint.
- Install LM Studio from lmstudio.ai.
- Search for
LiquidAI/LFM2.5-2.6Band download the GGUF quantization that fits your RAM (the Q4_K_M is a good starting point for 8 GB machines). - Load the model, start the local server, and point your agent harness at
http://localhost:1234/v1.
Option 2: llama.cpp (cross-platform, CPU-friendly)
# From the llama.cpp build directory, with a downloaded GGUF checkpoint:
./llama-cli -m LFM2.5-2.6B-Q4_K_M.gguf -p "Plan a 3-step research workflow for summarizing a 50-page PDF." -n 512
For an OpenAI-compatible server that an agent harness can call:
./llama-server -m LFM2.5-2.6B-Q4_K_M.gguf --host 0.0.0.0 --port 8080
Option 3: vLLM (GPU, production throughput)
pip install vllm
vllm serve "LiquidAI/LFM2.5-2.6B"
# OpenAI-compatible API at http://localhost:8000/v1/chat/completions
vLLM is the right pick if you want to serve LFM2.5-2.6B as the local backend for a fleet of parallel sub-agents. On a single H100, Liquid AI reports roughly 15,000 output tokens/second at high concurrency — about 1.3 billion tokens per day. The economics of running background agent fleets at that throughput, with zero per-token cost, are what make the local-agent thesis real.
If you are wiring LFM2.5-2.6B into an open-source agent harness, our Qwen3.8-Max with Hermes Agent guide walks through the same pattern — point the harness at a local OpenAI-compatible endpoint and swap the model name.
What is LFM2.5-2.6B's context window and language support?
LFM2.5-2.6B has a 131,072-token (128K) context window, reached via a dedicated context-extension phase during mid-training. The vocabulary is 128,000 tokens — doubled from the previous generation to support non-Latin scripts via in-place tokenizer expansion rather than a from-scratch retrain. The model supports 16 languages: English, Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian, and Polish.
For long-context agent tasks — summarizing long documents, RAG over a personal knowledge base, or working through multi-step research — 128K at this model size is unusual. Most 2-3B models top out at 32K.
Is LFM2.5-2.6B actually free? (Read the license)
Yes, with a threshold. LFM2.5-2.6B ships under the LFM Open License v1.0, which is based on Apache 2.0 with one key change: free commercial use is limited to companies with annual revenue under $10 million USD. Above that threshold, you need to contact Liquid AI for a commercial license. Qualified nonprofits (501(c)(3) or equivalent) have no revenue threshold for non-commercial or research use.
Practically: if you are an indie builder, a small business under $10M revenue, or a researcher, the model is free to use, fine-tune, and distribute — with no copyleft requirement on your modifications. If you are inside a large enterprise, budget for a commercial license conversation.
What is LFM2.5-2.6B best at — and where should you not use it?
Use it for: agentic workloads, tool use, data extraction, RAG, and long-context workflows on edge devices.
Do not use it for: agentic coding and knowledge-heavy tasks — Liquid AI's own guidance. Coding is the one area where larger comparison models (Qwen3.5-9B at 69.86% on LiveCodeBenchv6) keep a clear edge, and LFM2.5-2.6B is explicit about that. For serious code generation locally in 2026, look at the Zenith Precision Compiler project or larger dense models like Qwen 3.6 27B.
The "brain + hands" pattern: when to pair LFM2.5-2.6B with a frontier model
The most practical architecture for a 2026 agent stack is not "big model for everything" — it is a frontier brain for the hard parts and a fast local model for the grunt work. LFM2.5-2.6B is the grunt-work model.
The pattern: use a frontier model (Claude Opus 5, GPT-5.6, or Qwen 3.8 Max) as the orchestrator for the decisions that need deep reasoning, and delegate the high-token-volume-but-low-frontier-difficulty work — data extraction, summarization, simple tool calls, document chunking — to LFM2.5-2.6B running locally. The frontier brain stays cheap because it only sees the thinking; the local hands stay free because they run on your hardware.
This is the same architecture described in our AI Subagents: How to Parallelize Your AI Work Without Freezing Your Screen guide, where LFM2.5-2.6B slots in as the leaf worker that lets you parallelize dozens of cheap threads without a cloud bill.
For a worked example of plugging an open-weights model into an agent harness and running it as the local layer, our Hermes Agent Power User Playbook covers the configuration knobs that matter for local-model routing.
What this means for you
For small-business owners and indie builders: LFM2.5-2.6B is the first local model where the agent loop is fast enough to actually use interactively on commodity hardware — 220 tok/s on an M5 Max, 30 tok/s on a phone, under 2.5 GB. If you have been priced out of running a 24/7 agent on cloud APIs, this is your on-ramp. Start with LM Studio, point your harness at the local endpoint, and use it for the repetitive high-volume tasks.
For developers and agent builders: the agentic RL training stage — direct training inside real harnesses like Hermes Agent and OpenClaw — is the technical bet that pays off in tool-call reliability. If you have tried small local models before and given up on them dropping tool calls or hallucinating schemas, LFM2.5-2.6B is worth a fresh look. Keep the frontier model for code and deep knowledge work; route everything else here.
For anyone under an NDA or privacy constraint: a model that runs offline, on your device, with zero network requests after download, is the cleanest answer to "can I use AI on this data?" There is no data exfiltration surface if the Wi-Fi is off.
FAQ
Q: Is LFM2.5-2.6B free? A: Yes. The model is open-weights under the LFM Open License v1.0, free for commercial use by companies with annual revenue under $10 million USD. Above that threshold, contact Liquid AI for a commercial license. Nonprofits and research use have no threshold.
Q: Can LFM2.5-2.6B run on a phone? A: Yes. Liquid AI reports roughly 30 tokens/second on a phone in under 2.5 GB of memory, enough for an interactive agent loop. A recent phone with 6-8 GB of RAM is the realistic minimum.
Q: What is LFM2.5-2.6B's context window? A: 131,072 tokens (128K), reached via a dedicated context-extension phase during mid-training. The vocabulary is 128,000 tokens across 16 languages.
Q: Is LFM2.5-2.6B good for coding? A: No — and Liquid AI says so explicitly. It scores 59.41% on LiveCodeBenchv6, behind Qwen3.5-9B at 69.86%. It is built for agentic, tool-use, and long-context work, not agentic coding or knowledge-heavy tasks.
Q: How is LFM2.5-2.6B different from Qwen3.5-4B or Gemma-4-E4B? A: LFM2.5-2.6B is smaller (2.69B) but leads on instruction following (IFBench, Multi-IF, IFStruct) and tool use (ToolSandbox, τ³-Bench), and is explicitly trained inside agent harnesses. Qwen3.5-9B wins on BFCLv4 function calling and coding; Gemma-4-E4B is larger and trails on most agentic benchmarks. LFM2.5-2.6B is the agentic-and-privacy pick; the others are broader-purpose.
Q: What inference engines support LFM2.5-2.6B? A: llama.cpp (GGUF), MLX (Apple Silicon), vLLM (GPU), SGLang (GPU), ONNX (cross-platform), and LM Studio (desktop). All are documented in Liquid AI's inference docs.
Discussion
0 comments