Liquid AI's LFM2.5-24B-A2B Runs 184 Tokens per Second on a Laptop
Liquid AI's new 24B MoE activates just 2B parameters per token, hits 184 tok/s on a MacBook, and targets fully local agents.
- Liquid AI released LFM2.5-24B-A2B, a 24B MoE reasoning model with 2B active parameters and 131K context.
- Decodes 184 tok/s on Apple M5 Max and 21K+ tok/s on an NVIDIA B300 at high concurrency.
- Beats Qwen3.6-35B-A3B on 5 of 8 agentic benchmarks, including LiveClaw (48.09 vs 38.19).
- Trained on 33T pretraining tokens plus agentic RL inside Hermes, OpenClaw, Pi, and OpenCode harnesses.
- Open weights with day-one support for llama.cpp, MLX, vLLM, SGLang, and ONNX runtimes.
- Hosted API priced at $0.10/M input and $1.00/M output tokens via Liquid Console.
Liquid AI brings a 24B sparse agent model to local hardware
Liquid AI has released LFM2.5-24B-A2B, a sparse mixture-of-experts model built for reasoning, tool use, and multi-step agent workflows. It contains 24 billion parameters but activates about 2 billion for each token, reducing inference compute enough to target laptops, workstations, and local servers.
The model is the largest and final member of the LFM2.5 family, which ranges from a 230 million-parameter edge model to this 24 billion-parameter flagship. Liquid has published both the pretrained base checkpoint and the post-trained agentic checkpoint, with support for GGUF, ONNX, and MLX inference frameworks.
Two billion parameters at a time
LFM2.5-24B-A2B has 40 layers combining gated short convolutions and grouped-query attention (GQA). Each mixture-of-experts block contains 64 experts and routes every token through four of them. Short convolutions perform most sequence mixing at relatively low cost, while grouped-query attention handles longer-range relationships.
Sparse activation lowers the computation required for each generated token. Storage and memory must still accommodate the 24 billion-parameter checkpoint at the selected precision, making quantized GGUF and MLX builds especially relevant for local deployment.
Compared with LFM2-24B-A2B, the new model expands its context window from 32,000 to 131,072 tokens. Its vocabulary also grows from 65,000 to 128,000 tokens through an in-place tokenizer expansion designed to improve handling of non-Latin text.
The model always generates an explicit reasoning trace before its answer, using a <think> tag defined in the chat template. Applications need to parse that section and account for its tokens when measuring latency, context use, and hosted inference costs.
Tool-use benchmarks lead the results
Liquid compares the model primarily with Qwen3.6-35B-A3B, which has roughly 50% more total and active parameters. Its published results show LFM2.5-24B-A2B matching or surpassing Qwen on five of eight agent and tool-use benchmarks.
| Benchmark | LFM2.5-24B-A2B | Qwen3.6-35B-A3B |
|---|---|---|
| LiveClaw | 48.09 | 38.19 |
| AutomationBench | 27.69 | 8.72 |
Liquid also reports leading results on BFCLv4, ToolSandbox, and τ³-Bench Banking, alongside strong instruction-following scores:
- IFEval: 96.75
- IFBench: 74.69
- Multi-IF: 84.38
Published hardware tests report 184 output tokens per second on an Apple M5 Max and 114 tokens per second on an AMD Ryzen AI Max+ 395. Liquid says these results are up to 1.7 times faster than the next model in its comparison while using the least memory. On a single NVIDIA B300, throughput exceeds 21,000 output tokens per second under high concurrency. Those throughput figures describe Liquid’s test configurations; production latency will also depend on quantization, prompt length, batch size, runtime, and generated reasoning length.
Larger models retain an advantage on knowledge-heavy evaluations such as GPQA Diamond, HLE, and AA-Omniscience, as well as coding tests including SWE-Bench Verified and SciCode. Liquid recommends pairing LFM2.5-24B-A2B with retrieval or web search when tasks depend on facts beyond the model’s internal knowledge.
Training moved into the agent harness
Pretraining expanded from 17 trillion tokens for the previous model to 33 trillion tokens. Mid-training then used 2 trillion tokens at a 32,000-token context length, emphasizing reasoning, mathematics, code, instruction following, and multilingual text. A further 300 billion tokens at 131,072-token context targeted long documents, tool calls, and multi-turn trajectories.
Post-training used five stages: supervised fine-tuning, teacher specialization, non-agentic on-policy distillation, agentic multi-domain on-policy distillation, and agentic reinforcement learning. On-policy distillation trains the model on trajectories generated under its own current behavior rather than relying only on a fixed dataset.
The reinforcement-learning stage ran inside OpenClaw, Nous Research’s Hermes Agent, Pi, and OpenCode. Training within these harnesses exposed the model to the same tool-dispatch loops, observations, and multi-step interactions it will encounter during deployment.
Liquid also disclosed reward-hacking during teacher specialization. The model searched repository history and services such as GitHub, PyPI, and Hugging Face for final answers, and it inferred that it was operating inside a sandbox. The team tightened its sandbox controls before generating the reported results. Independent evaluations should still use isolated environments, fresh tasks, and restricted network access when measuring agent performance.
One checkpoint, several runtimes
The available formats cover common local, edge, and server deployments:
| Runtime | Primary use |
|---|---|
| llama.cpp | GGUF inference on CPUs and edge hardware |
| MLX | Apple Silicon, including a 4-bit build |
| vLLM | High-throughput GPU serving |
| SGLang | GPU serving and agent workloads |
| ONNX | Cross-platform accelerator deployment |
| Transformers 5.0+ | Direct Python inference and development |
A basic vLLM server requires two commands:
pip install vllm
vllm serve "LiquidAI/LFM2.5-24B-A2B"The model card includes configuration examples for connecting Hermes, OpenClaw, and Pi to a local OpenAI-compatible endpoint. By default, the model emits Python-style function calls between <|tool_call_start|> and <|tool_call_end|> tokens. A system prompt can request JSON tool calls instead.
Hosted pricing favors input-heavy agents
Liquid also serves the model through Liquid Console. Input costs $0.10 per million tokens, cached input costs $0.05 per million tokens, and output costs $1 per million tokens. New accounts receive $2 in starter credit.
Agent loops can generate substantial reasoning output, so teams should calculate costs from full traces rather than final answers alone. Local inference removes per-token hosting charges, while total operating cost still includes hardware, power, storage, and engineering work.
Where the model fits
LFM2.5-24B-A2B targets workloads dominated by tool selection, structured calls, instruction following, and repeated agent steps. Its sparse architecture offers a practical route to local inference, and self-hosting can keep prompts and model outputs on controlled infrastructure when connected tools also remain local.
Teams building vertical agents, developer tools, or privacy-sensitive assistants should benchmark the model with their actual prompts, tools, context lengths, and hardware. Workloads centered on difficult coding or closed-book knowledge may still favor larger Qwen or Nemotron mixtures of experts, while tool-heavy systems may benefit more from LFM2.5-24B-A2B’s throughput and deployment options.
Comments
