LFM2.5-2.6B arrives to put capable agents directly on your devices: small, optimized for tool use and multi-turn interaction, and with latencies that let you deploy on CPU, GPU and even phones. Do you want an agent that follows instructions, calls APIs and runs inside a harness without relying on the cloud? This is headed that way.
What is LFM2.5-2.6B
LFM2.5-2.6B is a ~2.6B-parameter language model designed as a high-performance "agent model." It was trained on ~34T tokens and went through an intermediate phase to extend context length up to 128K tokens. Then it’s converted into an agent through a sequence of phases meant to cover many real ways of interacting with tools.
Practical result? A small model that competes with models four times its size on tasks involving tool use, instruction following and multi-step agentic tasks.
Architecture and training pipeline
The post-training process has four key stages:
Supervised Fine-Tuning (SFT): two rounds of SFT, heavily weighted toward agentic data: tool use, web searches and harness trajectories.Teacher specialization: a specialist teacher is trained per domain (e.g., math, code, tool use).Multi-domain On-Policy Distillation (MOPD): those specialized teachers are distilled into a single student.Agentic Reinforcement Learning (Agentic RL): multi-turn RL is run inside real harnesses so the model learns to coordinate tools, system prompts and stateful environments.
Agentic RL separates optimization, inference and environment execution into distinct components:
- Training Engine: optimizes the model.
- Rollout Engine: generates actions with the latest policy.
- Sandbox Service: runs actions in an isolated environment.
- Blackbox Harness: hosts the agent (e.g., OpenClaw, Hermes Agent) and coordinates interaction with the environment.
- Harness Proxy: lets you treat harnesses as black boxes without modifying them, while capturing token-level trajectories needed to reconstruct and validate RL samples.
That means you can use existing harnesses without rewriting them and still get valid, reproducible training data.
Performance vs larger models
In a suite of benchmarks (STEM, instruction following, tool use and agentic tasks), LFM2.5-2.6B competes with — and often beats — models four times its size. Its strengths are instruction following and tool use; it loses ground on code, where larger models still hold an edge.
Key points:
- Leads on instruction following benchmarks and almost all tool use benchmarks.
- In agentic tasks it outperforms comparable Gemma models and ties with Qwen on many tests.
- Holds up well on knowledge and math; for intensive coding work consider larger models.
If you’re building an agent that must coordinate APIs, browse and execute tools across long flows, this model is an efficient, competitive choice.
Inference and deployment: where it shines
LFM2.5-2.6B was built to run in real places: from H100 servers down to CPUs and mobile devices.
- CPU efficiency: 220 tok/s on an Apple M5 Max and 113 tok/s on an AMD Ryzen AI Max+ 395, using under 2.5 GB of memory. At 30 tok/s it’s already feasible to run agents on a phone.
- GPU efficiency: nearly 15K tokens/s under high concurrency on an H100, approaching ~1.3B tokens per day on a single GPU.
- Ecosystem: day-one support in
llama.cpp, MLX, vLLM, SGLang and ONNX.
Practical consequence: you can deploy high-volume local agents without relying exclusively on expensive servers or network latencies. For apps that need high throughput and edge deployment, LFM2.5-2.6B is a solid pick.
Quick example to try it
Install a recent transformers (>=5.0.0):
pip install -U transformers
Load the model in Python (practical hints: device_map="auto", dtype="bfloat16"):
from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "LiquidAI/LFM2.5-2.6B"
model = AutoModelForCausalLM.from_pretrained(
model_id,
device_map="auto",
dtype="bfloat16",
# attn_implementation="flash_attention_2" # uncomment on compatible GPU
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
prompt = "What is C. elegans?"
input_ids = tokenizer.apply_chat_template(
[{"role": "user", "content": prompt}],
add_generation_prompt=True,
return_tensors="pt",
tokenize=True,
).to(model.device)
output = model.generate(
input_ids,
do_sample=True,
temperature=0.2,
top_k=80,
repetition_penalty=1.05,
max_new_tokens=512,
)
print(tokenizer.decode(output[0], skip_special_tokens=False))
Practical recommendations
- Use LFM2.5-2.6B when you need local agents that interact with tools, perform searches and carry out multi-turn tasks with low latency.
- If your priority is intensive coding or complex code generation, consider larger models.
- Take advantage of
llama.cppand ONNX support for deployments on resource-limited devices. - For integration into RL pipelines and harnesses like OpenClaw or Hermes, the pipeline architecture makes it easy to use existing harnesses without changing them.
Think of concrete use cases: a research assistant that queries APIs and writes summaries, a support agent that runs diagnostics on local machines, or a scraping bot controlled securely on-device. With LFM2.5-2.6B you can move a lot of logic to the edge.
Final thoughts
This isn’t just a small, fast model: LFM2.5-2.6B is a bet on practical agents that run where you need them. If you’re building agents that must work with real tools and deliver low latencies, this model shifts the balance between cost, speed and capability. Want to try it in your next prototype?