Liquid AI LFM2.5-2.6B Puts Free Always-On Agents on Every Phone

Liquid AI released LFM2.5-2.6B on August 4, a 2.69-billion-parameter agentic model that plans, calls tools and completes multi-step tasks entirely on phones, laptops and robots. It holds a 131,072-token context window, ships open weights, and decodes at 220 tokens per second on an M5 Max while staying under 2.5 GB.

Because every token stays local, data never leaves the device and the marginal cost of each run drops to near zero. That economics shift is the part that lasts past the launch numbers.

What the Model Ships

LFM2.5-2.6B totals 2.69B parameters across 30 layers: 22 double-gated short convolution blocks plus 8 grouped-query attention blocks. Vocabulary size is 128,000. Pre-training consumed roughly 34 trillion tokens. The model covers 16 languages and remains text-only.

Two checkpoints landed the same day. LFM2.5-2.6B-Base is the starting point for fine-tuning. The post-trained LFM2.5-2.6B is ready for agentic workloads. Both sit under the lfm1.0 license and appear in native, GGUF, MLX and ONNX formats with day-one support in llama.cpp, vLLM, SGLang and LM Studio.

Liquid AI built the release so developers can deploy agents everywhere on-device. The company explicitly recommends it for tool use, data extraction, RAG and long-context workflows. It does not recommend the model for agentic coding or knowledge-heavy tasks.

• Base and instruct-style agent checkpoints both public
• 128K context after a dedicated mid-training extension phase
• Tokenizer expanded in place to 128K without full retrain
• Native tool-calling format with optional JSON override

The hybrid stack is the same LFM2 family architecture that prioritizes edge latency and memory. Short convolutions handle most layers; a minority of GQA blocks recover long-range quality.

That split is deliberate. Most of the depth runs as cheap local operations, so memory traffic stays low on phones and laptops. The eight attention blocks still give the model enough global reach for 131K-token contexts and multi-step tool chains. The result is a checkpoint that fits under 2.5 GB without giving up the long-context behaviors agents need.

Four Stages That Turn Base Into Agent

Post-training follows a deliberate four-stage recipe that starts from the base checkpoint.

1. Two supervised fine-tuning rounds, broad coverage first, then heavy agentic weighting. The SFT mix is roughly seven times larger than the one used for LFM2.5-8B-A1B.
2. Teacher specialization, one expert per domain (instruction following, math, knowledge, code, tool use, long context) trained with reinforcement learning on verifiable rewards.
3. Multi-domain on-policy distillation, the student rolls out under its own policy while each prompt routes to the matching domain teacher for token-level feedback.
4. Agentic reinforcement learning, GRPO inside real harnesses including Hermes Agent and OpenClaw, with outcome rewards from LLM judges, programmatic checks and a safety gate.

Training inside live harnesses teaches the model the actual tools, system prompts and interaction patterns those environments use. The result is an agent that works across those stacks without custom glue on every new project.

The seven-times-larger SFT mix relative to LFM2.5-8B-A1B matters because the smaller student needs denser coverage of tool patterns before distillation begins. Domain teachers then supply focused signal on instruction following, math, knowledge, code, tool use and long context. On-policy distillation keeps the student honest: it generates under its own policy, so the feedback matches the distribution it will see at inference. Final GRPO inside Hermes Agent and OpenClaw closes the loop on real harness behavior, including the safety gate that filters unsafe trajectories.

Where the Small Model Leads the Pack

Liquid AI compared LFM2.5-2.6B against gemma-4-E2B-it (5.1B), gemma-4-E4B-it (8B), Qwen3.5-4B (4.7B) and Qwen3.5-9B (9.7B). The 2.6B model leads every instruction-following benchmark reported and nearly every tool-use score.

It trails only on BFCLv4 against the largest Qwen and sits clearly behind on coding. Liquid AI states that larger models still hold the edge for coding-heavy or highly complex agentic work. Independent testers on X have already shown the tool-calling strength in practice: one Atomic Chat run matched a much larger DeepSeek-V4-Flash model on 35 consecutive tool calls while running more than three times faster on the same hardware.

The parameter gap makes the wins sharper. A 2.69B model outscoring 8B and 9.7B checkpoints on Multi-IF, IFStruct and IFBench shows that the post-training recipe, not raw width, is carrying instruction following. ToolSandbox at 77.83 versus 65.00 for gemma-4-E4B-it points the same way for tool use. The coding gap on LiveCodeBenchv6 is the explicit tradeoff Liquid AI accepts when it steers heavier coding agents toward bigger checkpoints.

Speed Numbers That Fit Real Hardware

Decode hits 220 tokens/s on an Apple M5 Max and 113 tokens/s on a Ryzen AI Max+ 395, both under 2.5 GB. Phones still clear about 30 tokens/s, enough for a responsive agent. On a single NVIDIA H100 SXM5 the model reaches roughly 15K output tokens per second at high concurrency, or about 1.3 billion tokens per day.

Supported runtimes cover the full edge-to-server range:

• llama.cpp via GGUF for CPU and mobile
• MLX for Apple Silicon
• vLLM and SGLang for GPU production serving
• ONNX for cross-accelerator and OEM fleets

Developers pull the LFM2.5-2.6B weights on Hugging Face and follow the official run and fine-tune docs. LoRA fine-tuning works through TRL and Unsloth. Serving behind an OpenAI-compatible endpoint then pointing Hermes, OpenClaw or Pi at it is a two-step local agent setup.

That two-step path is the practical bridge from weights to product. An OpenAI-compatible endpoint lets existing harnesses treat the local process like any other backend. Hermes, OpenClaw and Pi already know how to drive tool loops; they only need a stable base URL. LoRA through TRL or Unsloth then lets teams specialize the same base without standing up a full training stack.

Who Ships With It First

Solo developers and startups can pilot on hardware they already own. Mid-market teams self-host on one GPU. Enterprises and OEMs push the same weights to device fleets through GGUF and ONNX. Liquid AI lists automotive, consumer electronics, industrial robotics, healthcare, financial services, e-commerce and defense as target verticals.

• Solo developers and startups on existing laptops and phones
• Mid-market teams on a single GPU
• Enterprises and OEMs via GGUF and ONNX device fleets
• Verticals spanning automotive, consumer electronics, industrial robotics, healthcare, financial services, e-commerce and defense

Regulated and air-gapped settings gain the most because no prompt ever reaches a third-party API. Background agents that triage documents, extract invoices or parse robot commands can run continuously without metering. The same pattern appears in other recent on-device agent pushes, including another on-device agentic phone push that treats the handset itself as the agent host.

Practical builds already circulating include offline 128K document triage, form extraction, robotics command parsing and phone-native assistants that touch calendar, reminders and health connectors without leaving the device.

Air-gapped healthcare and defense deployments care less about peak tokens per second and more about the guarantee that prompts never cross a network boundary. Continuous invoice extraction in financial services and e-commerce cares about the near-zero marginal cost of leaving an agent running. Robotics command parsing cares about the sub-2.5 GB footprint that fits beside other onboard software. The same weights serve all three constraints.

License Terms That Favor Small Teams

The lfm1.0 license is Apache-based. It grants broad rights to use, modify and distribute, including commercial use, as long as the company’s annual revenue stays under $10 million. Research and qualified non-profits face no revenue threshold. Fine-tunes can stay proprietary; there is no copyleft requirement. Attribution notices must travel with distributions.

Once revenue crosses the line, commercial use requires a paid license from Liquid AI. The structure keeps the model free for the long tail of builders while reserving enterprise pricing for companies that scale. Full terms live on Liquid’s page describing free commercial use under $10M revenue.

For a startup still under the threshold, the path is straightforward: ship a fine-tune, keep weights proprietary if needed, and only open a commercial conversation with Liquid AI after revenue crosses $10 million. Research labs and qualified non-profits never hit that gate. Attribution is the main ongoing obligation for everyone distributing the model or derivatives.

How Local Tool Loops Stay Under Budget

Local decode at 220 tokens/s on an M5 Max or 113 tokens/s on a Ryzen AI Max+ 395 changes how teams budget multi-step agents. A loop that issues dozens of tool calls no longer accumulates cloud invoice lines. The Atomic Chat demonstration of 35 consecutive tool calls matching a larger DeepSeek-V4-Flash model, at more than three times the speed on the same hardware, is the pattern product teams can now treat as routine rather than exceptional.

Phone-class throughput near 30 tokens/s is still enough for interactive assistants that touch calendar, reminders and health connectors. The 131,072-token window lets a single on-device session hold a long document set for offline triage without chunking tricks. Because the native tool-calling format ships with an optional JSON override, harness authors can match existing schemas without rewriting the model side.

Server-side, a single H100 at roughly 15K output tokens per second and about 1.3 billion tokens per day gives mid-market teams a private pool large enough for continuous background agents. Those agents can extract invoices, parse robot commands or monitor document streams without a per-token line item. The cost floor becomes power and hardware amortization, not API spend.

Why Recommended Workloads Match the Training Mix

Liquid AI’s recommendation list tracks the post-training emphasis. Tool use, data extraction, RAG and long-context workflows align with the agentic SFT weighting, the tool-use and long-context teachers, and the final GRPO runs inside Hermes Agent and OpenClaw. Agentic coding and knowledge-heavy tasks fall outside that focus, which matches the LiveCodeBenchv6 gap against Qwen3.5-9B and the company’s own guidance to prefer larger checkpoints there.

The base checkpoint still exists for teams that need a different specialty. LoRA through TRL or Unsloth can tilt the model toward a narrower domain while keeping the hybrid stack’s latency profile. The instruct-style agent checkpoint remains the default for anyone who wants harness-ready behavior on day one.

Sixteen-language coverage and a text-only scope keep the package small enough for the edge targets. Teams that need multimodal inputs or heavier world knowledge still reach for larger cloud models. For the slice of work that is tool-heavy, privacy-sensitive and high-volume, the training mix and the hardware numbers point at the same sweet spot.

Always-On Agents Become Default Infrastructure

The second-order change is simple. When inference cost falls to zero and privacy is automatic, developers stop treating agents as occasional cloud calls. They start treating them as always-running background processes that can burn millions of tokens on local silicon without a bill.

Massive parallelization on owned hardware becomes normal. Continuous monitoring agents, multi-step research loops and device-native tool chains move from expensive demos to everyday product features. Larger cloud models still win at coding and deep knowledge work. For the high-volume, tool-heavy, privacy-sensitive slice of agent workloads, the economics and latency of a 2.6B local model now set the floor.

Liquid AI’s release does not invent on-device AI. It makes free, capable, harness-ready agents small enough and fast enough that the default architecture for many products can finally leave the cloud.

Frequently Asked Questions

What are the exact parameter count and context length of LFM2.5-2.6B?

The model has 2.69 billion total parameters and a 131,072-token context window after a dedicated mid-training extension. Vocabulary size is 128,000 tokens and the architecture uses 30 layers (22 short-convolution plus 8 GQA).

Can companies use LFM2.5-2.6B commercially for free?

Yes under the lfm1.0 license if annual revenue stays below $10 million USD. Research and qualified non-profits have no revenue limit. Crossing the threshold requires contacting Liquid AI for a commercial license.

Which tasks does Liquid AI recommend for this model?

Agentic workloads, tool use, data extraction, RAG and long-context workflows are the recommended fits. The company states it is not recommended for agentic coding or knowledge-heavy tasks where larger models retain an edge.

What inference formats and runtimes ship on day one?

Native weights plus GGUF, MLX and ONNX. Supported engines include llama.cpp, MLX, vLLM, SGLang and LM Studio, covering phone, laptop, Apple Silicon and single-GPU server deployments.

How does LFM2.5-2.6B compare on coding benchmarks?

LiveCodeBenchv6 scores 59.41 for LFM2.5-2.6B versus 69.86 for Qwen3.5-9B. Larger models keep a clear lead on coding, which is why Liquid AI points heavier coding agents toward bigger checkpoints.