Liquid AI just dropped LFM2.5-24B-A2B, a 24-billion-parameter reasoning model with a twist: only 2 billion parameters are active per token. It's a mixture-of-experts (MoE) architecture designed explicitly for on-device agents—the kind that need to think through multi-step tasks, call tools, and keep running continuously without burning through your GPU budget or phoning home to a cloud API.
The pitch is simple. Reasoning models are expensive because they generate a lot of tokens before they answer. If each reasoning token activates 2B parameters instead of 24B, you can run the same workload at a fraction of the cost. On an Apple M5 Max, it decodes at 184 tokens per second. On a single NVIDIA B300, it hits over 21,000 output tokens per second at high concurrency. That's fast enough to run agents continuously on your own hardware, and private enough that your data never leaves the device.
Architecture and training: hybrid convolutions, 64 experts, and 33T tokens
LFM2.5-24B-A2B builds on the earlier LFM2-24B-A2B architecture: 40 layers, 64 experts per MoE block with top-4 routing, and a hybrid of gated short convolutions and grouped query attention (GQA). The context window grew from 32K to 131K tokens, and the tokenizer vocabulary doubled from 65K to 128K tokens—an in-place expansion aimed at better non-Latin tokenization.
Pre-training scaled from roughly 17 trillion tokens to 33 trillion. Mid-training added another 2 trillion tokens at 32K context, weighted toward reasoning, math, code, instruction-following, and multilingual text, plus 300 billion tokens at 131K context, weighted toward long-context data. Tool calls and multi-turn trajectories appeared throughout both phases.
Post-training turned the base model into an agent across five stages: supervised fine-tuning, teacher specialization, two rounds of multi-domain on-policy distillation (one non-agentic, one agentic), and finally agentic reinforcement learning inside harnesses like OpenClaw, Hermes Agent, Pi, and OpenCode. Unlike its predecessor, this is a reasoning-only model—it always produces an explicit chain of thought before the final answer.
Benchmark results: competitive with models 50% larger
Liquid AI evaluated LFM2.5-24B-A2B against Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it, and Nemotron-3.5-Lightning (30B with 3B active) across 16 benchmarks covering tool use, agentic workflows, knowledge, instruction-following, math, and coding. The new model is the smallest in the group, yet it's competitive with MoEs that have roughly 50% more total and active parameters.
On tool-use and agentic tasks, it leads or matches the competition on five of eight benchmarks. On AutomationBench, it scores 27.69—more than three times the next-best model (Qwen's 8.72). It also leads on all three instruction-following benchmarks: IFEval (96.75), IFBench (74.69), and Multi-IF (84.38). On LiveClaw, a benchmark for agentic tool use, it scores 48.09 versus Qwen's 38.19.
Larger models retain an edge on knowledge-heavy benchmarks like GPQA Diamond (74.42 vs. Qwen's 83.69) and on coding tasks like SWE-Bench Verified (51.00 vs. Qwen's 66.20). The team suggests pairing LFM2.5-24B-A2B with retrieval or web search for knowledge-heavy workloads—a sensible trade when you're optimizing for fast, local reasoning over encyclopedic recall.
What "reasoning-only" means in practice
The model doesn't offer a mode where it skips reasoning and just answers. Every response includes the chain of thought. That's a deliberate trade: reasoning tokens are cheap when only 2B parameters are active, so the tax is low, and the payoff in reliability and tool-use accuracy is high.
This design choice makes sense for agents, where you want the model to think through each step, but it's worth noting if you're comparing raw speed on single-turn Q&A. You're paying for reasoning tokens even when the task is trivial.
Inference speed: edge and datacenter
LFM2.5-24B-A2B ships with day-one support across llama.cpp, MLX, vLLM, SGLang, and ONNX. On edge hardware, it's the fastest of the compared MoEs, decoding at 184 tokens per second on an M5 Max and 114 tokens per second on a Ryzen AI Max+ 395—up to 1.7x faster than the next-best model while using the least memory.
On datacenter GPUs, it reaches over 21,000 output tokens per second at high concurrency on a single B300. That's the fastest in its size class, and it's fast enough to serve hundreds of concurrent agent sessions from a single GPU.
The memory story
The source doesn't give exact memory footprints, but the implication is clear: 2B active parameters means lower memory pressure during inference. For on-device deployment, that's the difference between fitting on a laptop and needing a workstation.
How to use it in your agent harness
The recommended workflow is to serve LFM2.5-24B-A2B locally behind any OpenAI-compatible backend, then point your agent harness at it. For Hermes Agent, you'd run:
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 depends on your backend: llama.cpp and MLX use 8080, vLLM uses 8000, SGLang uses 30000, and LM Studio uses 1234. The model card includes configurations for OpenClaw and Pi.
Why this matters: the economics of reasoning agents
Reasoning models are expensive to run in production. Every task that requires multi-step planning, tool use, or verification burns through tokens. If you're running agents continuously—monitoring systems, answering support tickets, processing documents—the cost adds up fast.
LFM2.5-24B-A2B's 2B active parameters make each reasoning token cheaper. You can run more agents, run them longer, and run them locally without worrying about API costs or latency. The model is open-weight (licensed under Liquid AI's terms), so you can fine-tune it, quantize it, and deploy it however you want.
The trade-off is knowledge. Larger models with more active parameters do better on factual recall and complex coding tasks. But if your agent workload is tool-heavy—calling APIs, navigating UIs, orchestrating workflows—LFM2.5-24B-A2B's instruction-following and tool-use performance makes it a strong fit.
What's still missing
The benchmarks are solid, but they're mostly academic. AutomationBench and LiveClaw are proxies for real-world agent reliability, not the thing itself. We don't yet know how this model behaves in production over thousands of sessions—whether it degrades gracefully under distribution shift, whether it handles tool-call errors well, whether it gets stuck in loops.
The post also doesn't discuss fine-tuning cost or data requirements. If you want to adapt this model to your domain, how much data do you need? How long does it take? The team mentions fine-tuning tutorials, but the source doesn't provide specifics.
The bigger picture: MoEs for edge reasoning
Liquid AI is betting that the future of agents is local, private, and built on sparse architectures. LFM2.5-24B-A2B is the clearest statement of that thesis so far: a reasoning model that's fast enough for real-time interaction, small enough for edge deployment, and capable enough to beat models with 50% more parameters on the tasks that matter for agents.
If they're right, we'll see more models like this—MoEs optimized for active-parameter efficiency rather than total parameter count, trained explicitly for agentic workflows, and designed to run on hardware you already own. If they're wrong, the bottleneck will turn out to be knowledge or robustness, and we'll end up back at larger models and cloud APIs.
Either way, LFM2.5-24B-A2B is now the benchmark for on-device reasoning agents. The model and base are available on Hugging Face today.