LFM2.5-24B-A2B runs local AI agents with just 2B active parameters

Liquid AI published LFM2.5-24B-A2B on October 13, 2026, on the Hugging Face blog: a 24-billion-parameter model that activates only 2 billion per token, designed specifically for agents that reason, call tools, and run continuously on local hardware. The core proposition is simple to state and hard to deliver: give developers a model good enough to replace API calls with on-device inference, without sacrificing quality on agentic tasks.

This matters because an agent running locally solves two problems at once: token costs that scale with usage, and dependence on an external API that can change pricing, rate limits, or data policy overnight. For anyone handling sensitive data, whether legal, medical, or financial, running the model within one's own infrastructure also simplifies the conversation around LGPD (Brazil's data protection law), since the data never leaves the machine.

How the Model Is Built Under the Hood

LFM2.5-24B-A2B inherits the architecture of LFM2-24B-A2B: 40 layers, MoE (mixture-of-experts) blocks with 64 experts and top-4 routing, combined with gated short convolutions and GQA (grouped-query attention). The difference between MoE and an equivalent dense model is that only a fraction of the parameters participate in each processed token, which cuts computational cost per inference without throwing away the model's total capacity.

Compared to its predecessor, three concrete changes appear in version 2.5:

• The context window jumps from 32,000 to 131,000 tokens.
• The tokenizer vocabulary doubles from 65,000 to 128,000 tokens via in-place expansion, improving tokenization for non-Latin languages.
• The model no longer has a direct-response mode: it is now reasoning-only, meaning it always produces an explicit chain of thought before the final answer.

Liquid AI also scaled pre-training from roughly 17 trillion to 33 trillion tokens, and added two mid-training phases: 2 trillion tokens at a 32K context (weighted toward reasoning, math, code, instruction following, and multilingualism) and 300 billion tokens at a 131K context, focused on long-context data. Tool calls and multi-turn trajectories appear from this phase onward, not just in the final fine-tuning.

Five Stages to Become an Agent

The post-training process that turns the base model into an agent follows five stages described by the team: supervised fine-tuning (SFT), teacher specialization, two rounds of on-policy multi-domain distillation (MOPD, one on non-agentic tasks and another focused on agentic tasks), and finally, agentic reinforcement learning (Agentic RL), trained inside real agent harnesses such as OpenClaw, Hermes Agent, Pi, and OpenCode.

This last detail is what sets LFM2.5-24B-A2B apart from a generalist model with generic tool calling: it was exposed, during the RL training itself, to the same agent frameworks developers will use in production. This tends to narrow the gap between benchmark results and the agent's actual behavior when running with real tools.

What the Benchmarks Show (and Don't Show)

Liquid AI compared the model with Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it, and Nemotron-3.5-Lightning (30B-A3B) across 16 benchmarks, using vLLM and the generation parameters recommended for each test. LFM2.5-24B-A2B is the smallest model in the group, but it leads or ties in five of the eight tool-use and agentic-task benchmarks:

On AutomationBench, the model scores more than triple the runner-up, and on LiveClaw it's ten points ahead of Qwen3.6-35B-A3B, which has about 50% more total and active parameters. The model also leads all three instruction-following metrics tested (IFEval, IFBench, and Multi-IF). But the advantage disappears on knowledge and code benchmarks: on GPQA Diamond, HLE, AA-Omniscience, and SWE-Bench Verified, larger models like Qwen3.6-35B-A3B remain ahead.

In short: LFM2.5-24B-A2B is built for an agent's loop (understanding the task, deciding to call a tool, following instructions), not to replace a general-knowledge model or a code specialist. The team itself recommends pairing it with search or RAG for workloads that depend on factual knowledge.

Speed: The Real Argument for Running Locally

The inference numbers are what back up the promise of a 'continuous agent on your own hardware.' On edge devices, the model decodes 184 tokens per second on an Apple M5 Max and 114 tokens per second on a Ryzen AI Max+ 395, outperforming the other compared MoEs by up to 1.7x while using less memory. On GPU, on a single NVIDIA B300, the model exceeds 21,000 output tokens per second under high concurrency.

For developers, this translates into a practical calculation: if the marginal cost per reasoned token is low enough, you can let an agent keep 'thinking' continuously (monitoring a repository, triaging tickets, watching logs) without the API bill becoming the project's bottleneck. It's an argument about operational economics, not just benchmark performance.

How to Run It in Practice

The model has day-one support in llama.cpp, MLX, vLLM, SGLang, and ONNX. Via transformers (version 5.0.0 or higher), loading follows the familiar pattern for causal models:

from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer

model_id = "LiquidAI/LFM2.5-24B-A2B"
model = AutoModelForCausalLM.from_pretrained(
 model_id,
 device_map="auto",
 dtype="bfloat16",
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)

prompt = "What is C. elegans?"
input_ids = tokenizer.apply_chat_template(
 [{"role": "user", "content": prompt}],
 add_generation_prompt=True,
 return_tensors="pt",
 tokenize=True,
)["input_ids"].to(model.device)

output = model.generate(
 input_ids,
 do_sample=True,
 temperature=0.1,
 top_k=50,
 repetition_penalty=1.05,
 max_new_tokens=512,
 streamer=streamer,
)

To plug it into an agent harness, Liquid AI recommends serving the model behind an OpenAI API-compatible backend and pointing the harness to it. With Hermes Agent, for example:

hermes config set model.provider custom
hermes config set model.base_url http://localhost:8080/v1
hermes config set model.default LFM2.5-24B-A2B
hermes config set model.context_length 131072
hermes config set model.api_mode chat_completions
hermes config set agent.tool_use_enforcement true

The port varies by backend: llama.cpp and MLX use 8080, vLLM uses 8000, SGLang uses 30000, and LM Studio uses 1234. The model card on Hugging Face provides equivalent configurations for OpenClaw and Pi.

When It's Worth It (and When It's Not)

LFM2.5-24B-A2B and its base version, LFM2.5-24B-A2B-Base, are available as open weights on Hugging Face. It makes sense to consider the model if the project depends on an agent that calls tools frequently, needs to follow instructions strictly, and runs on hardware with limited memory, whether a Mac with Apple Silicon, a laptop with a Ryzen AI line NPU, or a single datacenter GPU. It makes less sense if the workload is mostly complex code generation or deep general-knowledge questions, where the benchmarks show larger models still ahead.

It remains open, since Liquid AI's blog post doesn't detail it, how the model behaves in end-to-end agentic tasks outside controlled benchmarks, for example an agent operating for hours over a real codebase, or what the fine-tuning cost looks like for a specific vertical domain. The company promises fine-tuning tutorials, but the material released so far covers only the architecture, the benchmarks, and the initial setup.