Running a capable AI agent used to mean renting a cloud GPU and sending your data to someone else’s server. LFM2.5-24B-A2B changes that equation: it is an open-weight reasoning model from Liquid AI that holds 24 billion parameters but activates only 2 billion for each token, so it can think, call tools, and finish multi-step tasks on hardware you control. Released on October 13, 2026, it posts the strongest tool-use scores in its comparison group while decoding at 184 tokens per second on an Apple M5 Max laptop. LFM2.5-24B-A2B AI Agent
If you build, teach, or evaluate AI agents, this is one of the most practical releases of the year. In this guide, you will learn what the model is, how it is built, how it performs against rivals, which hardware it runs on, and when it is the right choice.
Quick Facts: Key Specs at a Glance
This model is a reasoning-only, open-weight language model with 24B total parameters and 2B active parameters per token, built for fast, private agents that run on-device. The table below collects the specifications published by Liquid AI so a reader (or an AI assistant) can find each fact in one place.
| Specification | Value |
|---|---|
| Developer | Liquid AI |
| Release date | October 13, 2026 |
| Total parameters | 24 billion |
| Active parameters per token | 2 billion |
| Architecture | 40 layers, 64 experts per MoE block, top-4 routing, gated short convolutions plus GQA |
| Context window | 131K tokens (up from 32K) |
| Vocabulary size | About 128K tokens (up from 65K) |
| Pre-training | About 33T tokens |
| Mode | Reasoning-only (thinks before answering) |
| Edge speed | 184 tokens/s on Apple M5 Max, 114 tokens/s on Ryzen AI Max+ 395 |
| GPU speed | Over 21K output tokens/s on one NVIDIA B300 at high concurrency |
| Availability | Open weights on Hugging Face (instruct and base checkpoints) |
What Is LFM2.5-24B-A2B?
LFM2.5-24B-A2B is a 24-billion-parameter reasoning model from Liquid AI that activates only 2 billion parameters per token, designed so that agents can run continuously on local hardware. It produces an explicit chain of thought before its final answer, calls tools, and works through multi-step tasks inside popular agent harnesses.
The “expansion” matters as much as the definition. Because each reasoning token touches only a small slice of the network, thinking is cheap. A reasoning model that spends thousands of tokens deliberating is expensive when every token activates tens of billions of parameters. When only 2B parameters fire, the same deliberation costs a fraction of the compute, which is what makes always-on, on-device AI agents realistic.
What Does “24B-A2B” Mean?
The name encodes the model’s size and its efficiency. “24B” is the total parameter count, the full set of weights that must be stored in memory. “A2B” means roughly 2 billion parameters are active for any single token. The gap between the two numbers is the whole point of a mixture-of-experts design: you keep the knowledge capacity of a large model while paying the per-token compute cost of a small one.
Why a Mixture-of-Experts Model Suits On-Device Agents
A mixture-of-experts model splits its feed-forward layers into many specialist sub-networks called experts, and a router picks a few of them for each token. In this model, each MoE block has 64 experts and routes every token to the top 4.
Agents are a natural fit for this design because they generate a lot of tokens. A typical agent loop plans, calls a tool, reads the result, reflects, and plans again. Each step produces reasoning text, and the cost of that text adds up quickly. A mixture-of-experts model keeps the per-token cost low, so the loop stays fast and affordable.
There is one trade-off to keep in mind. Even though only 2B parameters are active, all 24B parameters still need to live in memory. As a rule of thumb (our estimate, not a Liquid AI figure), 24B weights in 16-bit precision take roughly 48 GB, while a 4-bit quantized build lands closer to 12-14 GB before overhead. Memory capacity, not compute, is usually the limiting factor for on-device use.
How LFM2.5-24B-A2B Is Built
The model keeps the architecture of its predecessor, LFM2-24B-A2B, and upgrades the context length, vocabulary, training scale, and post-training recipe. Understanding these four upgrades explains most of the model’s behavior.
Architecture: Gated Short Convolutions Meet Attention
The model has 40 layers and uses a hybrid design that mixes gated short convolutions with grouped-query attention (GQA). Short convolutions are cheap and fast for local patterns, while attention handles long-range dependencies. Combining them with sparse expert routing plausibly contributes to why Liquid AI’s model is the fastest of the compared mixture-of-experts models on edge hardware while using the least memory.
Context Window and Tokenizer Upgrades
The context window grows from 32K to 131K tokens, which matters for agents that carry long tool outputs, file contents, and conversation history. Liquid AI also expanded the tokenizer in place, doubling the vocabulary from roughly 65K to 128K tokens. A larger vocabulary improves tokenization of non-Latin scripts, which is useful for multilingual and Indic-language workloads because fewer tokens are needed to represent the same text.
Training Scale: From 17T to 33T Tokens
Pre-training was scaled from about 17 trillion to about 33 trillion tokens. Mid-training then added two further stages: 2 trillion tokens at 32K context, weighted toward reasoning, math, code, instruction following, and multilingual text, and 300 billion tokens at 131K context, weighted toward long-context data. Tool calls and multi-turn trajectories appear throughout both phases, so agentic behavior is introduced early rather than bolted on at the end.
The Five-Stage Post-Training Recipe
Post-training converts the base model into an agent through five stages:
- Supervised fine-tuning (SFT): teaches the base model to follow instructions and reason step by step.
- Teacher specialization: builds specialist teacher models for different domains.
- Multi-domain on-policy distillation (MOPD), non-agentic: distills the specialists on non-agentic tasks.
- MOPD, agentic: a second distillation round focused on agentic tasks.
- Agentic reinforcement learning: trains the model inside real agent harnesses, including OpenClaw, Hermes Agent, Pi, and OpenCode.
The last stage is the one that most directly explains the tool-use results. A model trained inside the harnesses it will later run in has seen the formats, error messages, and retry patterns that real agents produce.
Benchmark Results: Where LFM2.5-24B-A2B Wins and Loses
The model leads or matches its comparison group on five of eight tool-use and agentic benchmarks and on all three instruction-following benchmarks, but larger models keep an edge on knowledge and coding. Liquid AI compared it against Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it, and Nemotron-3.5-Lightning (30B-A3B) across 16 benchmarks, evaluating every model with vLLM and each benchmark’s recommended generation settings.
These are vendor-reported numbers, so treat them as a strong starting signal and validate on your own tasks before committing.
| Benchmark | LFM2.5-24B-A2B | Qwen3.6-35B-A3B | Gemma-4-26B-A4B-it | Nemotron-3.5-Lightning |
|---|---|---|---|---|
| AutomationBench | 27.69 | 8.72 | 5.46 | 2.61 |
| BFCLv4 | 65.01 | 65.00 | 57.09 | 53.78 |
| ToolSandbox | 80.71 | 75.02 | 72.09 | 75.13 |
| LiveClaw | 48.09 | 38.19 | 41.25 | 37.72 |
| IFEval | 96.75 | 93.06 | 92.00 | 94.19 |
| IFBench | 74.69 | 64.21 | 47.44 | 71.67 |
| GPQA Diamond | 74.42 | 83.69 | 74.90 | 72.42 |
| SWE-Bench Verified (OpenCode) | 51.00 | 66.20 | 25.80 | 53.40 |
Bold marks the best score in each row. The full 16-benchmark table is on the original Hugging Face post.
Where It Wins: Tool Use and Instruction Following
On AutomationBench, the model scores 27.69, more than three times the next-best score in the group. On LiveClaw it scores 48.09 against 38.19 for Qwen3.6-35B-A3B, a model with roughly 50% more total and active parameters. It also leads IFEval, IFBench, and Multi-IF, which measure how reliably a model follows detailed instructions. For agents, instruction following is not a nice-to-have, because an agent that drifts from its instructions breaks workflows.
Where Larger Models Still Lead: Knowledge and Coding
The model trails on GPQA Diamond (74.42 versus 83.69 for Qwen3.6-35B-A3B), on SWE-Bench Verified with OpenCode (51.00 versus 66.20), and on SciCode, WebArena Verified, and PinchBench. On AA-Omniscience, which penalizes confident wrong answers, Nemotron-3.5-Lightning scores best. The practical lesson from Liquid AI is to pair the model with retrieval or web search for knowledge-heavy work rather than relying on its stored knowledge alone.
Speed and Hardware: Local LLM Inference in Practice
The model is the fastest of the compared mixture-of-experts models on edge hardware and the fastest in its size class on data-center GPUs, according to Liquid AI. Speed is not cosmetic for agents, because a loop that takes 40 seconds per step feels broken while one that takes 4 seconds feels like a tool.
Laptops and Mini PCs
On edge hardware, the model decodes 184 tokens per second on an Apple M5 Max and 114 tokens per second on an AMD Ryzen AI Max+ 395. Liquid AI reports this is up to 1.7x faster than the next-best compared model, while using the least memory. For local LLM inference, that combination of speed and a small memory footprint is what turns a demo into a daily driver.
Data-Center GPUs
On a single NVIDIA B300 GPU, the model reaches more than 21K output tokens per second at high concurrency, which makes it the fastest in its size class according to Liquid AI. For teams serving many agent sessions at once, that throughput lowers cost per task.
How to Run the Model Locally
You can run it with Hugging Face Transformers or with any of the major inference runtimes, then point an agent harness at the local server. Day-one support covers llama.cpp, MLX, vLLM, SGLang, and ONNX, so most hardware and operating system combinations are covered.
The quickest path has three steps:
- Download the weights from Liquid AI’s Hugging Face page. Both the instruct model and a base checkpoint are open-weight.
- Serve the model behind an OpenAI-compatible endpoint using your preferred runtime. Default ports differ: llama.cpp and MLX use 8080, vLLM uses 8000, SGLang uses 30000, and LM Studio uses 1234.
- Connect an agent harness such as Hermes Agent, OpenClaw, or Pi by setting the base URL, the model name, and a context length of 131,072 tokens.
For direct use in Python, Liquid AI’s example uses Transformers version 5.0.0 or newer, loads the model in bfloat16, and applies the tokenizer’s chat template. The model card lists the exact sampling settings and the OpenClaw and Pi configurations, so follow it rather than guessing at parameters.
If you want to specialize the model for a narrow task, Liquid AI also publishes fine-tuning notebooks in its cookbook repository.
When to Choose LFM2.5-24B-A2B
Choose this model when you need a private, fast agent that follows instructions precisely and calls tools reliably. The strongest use cases share a profile: lots of tokens, lots of tool calls, and data you would rather not send out.
- Private workflow automation: summarizing, routing, and acting on internal documents without cloud exposure.
- Always-on assistants: background agents that run continuously, where per-token cost dominates.
- Tool-heavy pipelines: form filling, data lookups, and API orchestration, where tool-calling benchmarks matter most.
- Multilingual products: the expanded 128K-token vocabulary helps with non-Latin scripts.
- Fine-tuning projects: teams adapting an open-weight base to a narrow domain.
Look elsewhere, or add retrieval, when the job is deep scientific question answering, large-scale software engineering, or open-ended factual recall. In those areas the comparison table shows larger models ahead.
Local Model vs. Cloud API: How to Decide
A local model wins on privacy, cost predictability, and latency for repetitive agent loops. A frontier cloud model wins on raw knowledge and the hardest coding tasks. Many teams will route easy, high-volume steps to a local model and escalate only the hard cases to a hosted one. That hybrid pattern captures most of the savings without giving up quality where it counts.
What LFM2.5-24B-A2B Means for India
For Indian developers, students, and startups, an open-weight agent model that runs locally removes two common barriers: recurring API cost and data-residency worry. Indian teams that handle customer records, financial data, or student information often prefer not to ship that data offshore, particularly with the Digital Personal Data Protection Act, 2023 shaping compliance conversations. A model that runs on a high-end laptop or a modest on-premise server keeps data in-house by design.
There is a talent angle as well. Freshers and early-career engineers can learn agent engineering, harness configuration, and fine-tuning on their own machines, without needing a cloud budget. The expanded tokenizer also signals better handling of non-Latin scripts, which is relevant for Indic-language products, although you should test any specific language before promising quality.
FAQ: LFM2.5-24B-A2B Questions Answered
What is LFM2.5-24B-A2B?
LFM2.5-24B-A2B is an open-weight reasoning model from Liquid AI with 24 billion total parameters and 2 billion active parameters per token. It is built for fast, private agents that call tools and complete multi-step tasks on local hardware.
Is LFM2.5-24B-A2B open source?
Liquid AI describes LFM2.5-24B-A2B as open-weight, with both the instruct and base checkpoints available on Hugging Face. Open-weight means you can download and run the weights, but you should read the license on the model card to confirm the exact terms for commercial use.
How fast is LFM2.5-24B-A2B?
It decodes 184 tokens per second on an Apple M5 Max and 114 tokens per second on a Ryzen AI Max+ 395, and it exceeds 21K output tokens per second on a single NVIDIA B300 at high concurrency. These are vendor-reported figures.
What is the context length of LFM2.5-24B-A2B?
The context window is 131K tokens, up from 32K in LFM2-24B-A2B. That is enough for long tool outputs and extended agent sessions.
Does LFM2.5-24B-A2B beat larger models?
On tool use and instruction following, it matches or beats Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it, and Nemotron-3.5-Lightning on most benchmarks Liquid AI reports. On knowledge-heavy and coding benchmarks, larger models still lead.
Which agent frameworks work with LFM2.5-24B-A2B?
Liquid AI trained and documented the model with OpenClaw, Hermes Agent, Pi, and OpenCode. Any harness that can talk to an OpenAI-compatible endpoint should be able to use it once the model is served locally.
Can I run LFM2.5-24B-A2B on a laptop?
Yes, on a high-memory laptop. Liquid AI reports 184 tokens per second on an Apple M5 Max. Because all 24B weights must fit in memory, a quantized build is the practical choice on most consumer machines.
Conclusion: A Practical Step Toward Private, Always-On Agents
LFM2.5-24B-A2B shows that agent quality does not have to scale with active parameter count. By activating just 2B of 24B parameters, training inside real agent harnesses, and extending context to 131K tokens, Liquid AI built a model that leads on tool use and instruction following while staying fast on laptops and efficient on GPUs. Its weaknesses are honest and predictable: knowledge-heavy and coding-heavy tasks still favor larger models, so pair it with retrieval and escalate the hardest jobs.
The sensible next step is to test it on your own workflow. Pick one repetitive, tool-heavy task, serve the model locally, and measure accuracy, latency, and cost against your current setup.
Want to build with agents like this? Explore more AI explainers, tutorials, and hands-on training from Kalinga.ai to turn new model releases into real skills and real projects.