LFM2.5-2.6B: Deploy Agents Everywhere

Today, we release LFM2.5-2.6B, an agentic model that runs entirely on-device. It 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. Removing the per-token cost changes how developers build: agents can now be massively parallelized on local hardware, running background tasks that burn through millions of tokens at no marginal cost. When token spend is no longer a constraint, agents can be run everywhere around the clock.

The base (LFM2.5-2.6B-Base) and post-trained (LFM2.5-2.6B) models are available today on Hugging Face. Check out our docs on how to run and fine-tune them locally.

Training

LFM2.5-2.6B is a 2.6B parameter model specifically trained for agentic workloads. It's pre-trained on ~34T tokens. To better support non-Latin scripts in LFM2.5, we doubled the vocabulary to 128K by extending the existing tokenizer in place rather than retraining the model from scratch, using the same procedure as in LFM2.5-8B-A1B. Mid-training includes a dedicated 128K context-extension phase so the model can handle the long inputs that agentic workloads require.

The schematic summarizes the four-stage post-training pipeline that turns LFM2.5-2.6B-Base into the agentic LFM2.5-2.6B: Supervised Fine-Tuning (SFT), Teacher Specialization, Multi-Domain On-Policy Distillation (MOPD), and Agentic Reinforcement Learning (Agentic RL).

Supervised fine-tuning. Post-training begins with two consecutive SFT stages: starting with broad coverage across all domains, followed by targeted shaping on priority skills like agentic tasks, reasoning, and tool use. Across the two stages, the SFT training mix is about seven times the size of the one used for LFM2.5-8B-A1B, with heavier weighting toward agentic tasks such as tool use, web search, software engineering, and agent traces. The final SFT checkpoint serves as both the student model and the initialization checkpoint for training a set of specialist teachers for a later distillation stage. 

Teacher Specialization. From the shared SFT checkpoint, we train one expert per target domain through a focused SFT round on a reweighted mix, followed by reinforcement learning with verifiable rewards (RLVR). The resulting specialists cover instruction following, math, knowledge including hallucination control, code, tool use, and long context. Training them separately lets each expert optimize deeply for its own domain, using targeted data and rewards without competing updates from unrelated objectives.

MOPD. We then use the specialized experts as teachers and distill their capabilities into a single student model. Unlike off-policy distillation, where the student learns from trajectories generated by another model, MOPD lets the student roll out under its own policy. Each prompt is routed to the teacher for its corresponding domain, which supervises the student's response with token-level feedback. 

Because the teachers branch from the same SFT checkpoint as the student, their feedback stays close enough to the student's distribution to guide learning without destabilizing training. This dense, routed supervision helps the student converge quickly while integrating domain-specialized capabilities into a single model.

Agentic RL. The final stage teaches the model to operate inside real agent environments. We run multi-turn agentic RL through real agent harnesses, where the model works through realistic productivity tasks that evaluate its ability to research, write, code, analyze data, manage documents, use external tools, and automate multi-step workflows.

During training, we sample a task and randomly select a corresponding harness. Each rollout runs in a dedicated sandbox with its own runtime. We optimize with GRPO, using an outcome-based reward that combines an LLM-as-a-judge rubric, programmatic checks, and a hard safety gate. Training directly inside Hermes Agent, OpenClaw, and other harnesses exposes the model to their tools, system prompts, and interaction patterns, helping it work reliably across agent environments.

The training pipeline separates model optimization, inference, and environment execution into distinct components. The Training Engine (FSDP) optimizes the model, while the Rollout Engine (SGLang) generates actions using the latest policy. The RL framework (verl) orchestrates the training loop by launching rollouts, collecting trajectories and rewards, and updating the model.

Actions are executed within a Sandbox Service, where the Blackbox Harness hosts the agent (e.g., OpenClaw or Hermes Agent) and coordinates interactions with the task environment through tool calls, code execution, and other task-specific operations. The Harness Proxy lets us treat agentic harnesses as black boxes with no modification, while transparently capturing the token-level trajectories needed to reconstruct and validate RL training samples. This includes linear trajectory consistency, token mismatch checks, and Rollout Routing Replay (R3).

Benchmarks

We evaluated LFM2.5-2.6B across benchmarks covering STEM, instruction following, tool use, and agentic workflows. Despite being the smallest model in the comparison, it is competitive with, and often outperforms, models nearly four times its size.

LFM2.5-2.6B leads on every instruction-following benchmark and nearly every tool use benchmark, trailing only Qwen3.5-9B on BFCLv4. On agentic tasks, it outperforms both Gemma models across the board and trades closely with the Qwen models. On STEM, it leads on AA Omniscience and trails only Qwen3.5-9B on math. Coding is the one area where the larger models keep an edge.

These results make LFM2.5-2.6B a strong fit for high-volume agentic workloads on edge devices, especially when speed, privacy, and local deployment matter. For more complex agentic tasks or coding-heavy workloads, larger models may still be a better fit.¹

Fast Inference Everywhere

LFM2.5-2.6B ships with day-one support across the inference ecosystem:

• llama.cpp — GGUF checkpoints for efficient edge inference
• MLX — Optimized inference for Apple Silicon
• vLLM — GPU-accelerated serving for production throughput
• SGLang — GPU-accelerated serving for production throughput
• ONNX — Cross-platform inference across diverse accelerators

CPU inference. Due to the efficient LFM2 architecture, LFM2.5-2.6B is the fastest model we tested at reading in prompts and generating answers, decoding 220 tokens/s on an M5 Max and 113 tokens/s on a Ryzen AI Max+ 395 while staying under 2.5 GB. It even holds 30 tokens/s on a phone, so a capable agent runs instantly and privately on your own device.

GPU inference. We also measure output throughput (total output tokens / wall time) on a single NVIDIA H100 SXM5 GPU using a sustained-load setting: at each concurrency level, we continuously maintain the target number of in-flight requests, replacing each completed request immediately.

We benchmark each model with SGLang 0.5.16, 1,024 input tokens, up to 256 output tokens, in BF16, averaging 3 runs per concurrency level. LFM2.5-2.6B is the fastest model in its size class, reaching almost 15K output tokens per second at high concurrency, roughly 1.3B tokens per day on a single H100.

Run local agents with LFM2.5-2.6B

LFM2.5-2.6B’s size, speed, and capabilities make it a great choice for high-volume agentic workloads on edge devices. In the demo below, we run it inside the Liquid Agent harness on a phone, where it plans, calls tools, and works through a real task entirely on-device, without any cloud API calls.

Setting up your own local agent takes only two steps. First, serve LFM2.5-2.6B behind an OpenAI-compatible endpoint, then point your agent harness at it. It works out of the box with popular harnesses like Hermes Agent, OpenClaw, and Pi. Check out our guide for how to serve the model locally and connect it with the agent harness of your choice.

Get Started

Start building today with LFM2.5-2.6B and LFM2.5-2.6B-Base, available on Hugging Face.

With LFM2.5, we're delivering on our vision of AI that runs anywhere. These models are:

• Open-weight — Download, fine-tune, and deploy without restrictions
• Fast from day one — Native support for llama.cpp, MLX, and vLLM across Apple, AMD, Qualcomm, and NVIDIA hardware
• A complete family — From base models for customization to specialized audio and vision variants, one architecture covers diverse use cases

We can't wait to see what you build.

Download on Hugging Face

Read our docs

Try on Playground

Citation

Please cite this article as:

@article{liquidAI202626B,
  author  = {Liquid AI},
  title   = {LFM2.5-2.6B: Deploy Agents Everywhere},
  journal = {Liquid AI Blog},
  year    = {2026},
  note    = {www.liquid.ai/blog/lfm2-5-2-6b},
}

¹ All the models were evaluated with vLLM and the following generation parameters:

• BFCLv4: temperature = 0.001, max output tokens = 4096.
• ToolSandBox: temperature = 0, max output tokens = 1024.
• PinchBench: temperature = 0.6, max output tokens = 8192.
• τ³-Bench, Claw-Eval: temperature = 0, no output limit. Qwen models use temperature = 0.6 (per the recommended settings), as greedy decoding degrades performance due to doom looping.
• Other evals: temperature = 0.6, max output tokens = 32768.