Liquid AI’s 24B LLM Targets Fast Local Agents | Zeniteq
Loading
Loading article
Zeniteq is now available on mobile for iPhone, iPad and Apple Watch.Download nowLearn more
Liquid AI’s 24B LLM Targets Fast Local Agents
LFM2.5-24B-A2B offers open weights, a 131K context window, and broad local-runtime support, but its speed and benchmark results remain vendor-reported.
Liquid AI released LFM2.5-24B-A2B on October 13, 2026, a 24-billion-parameter mixture-of-experts model with only 2 billion active parameters per token and a 131,072-token context window designed for local agent deployment. The model is available as open weights on Hugging Face with support for llama.cpp, MLX, vLLM, SGLang, ONNX, and Transformers.
Liquid reports 184 output tokens per second on Apple M5 Max and claims competitive performance on agent benchmarks including AutomationBench and LiveClaw, though all measurements are vendor-reported and lack independent verification. The model requires at least 48 GB storage for full weights before quantization, and API access costs $0.10 per million input tokens and $1.00 per million output tokens.
Liquid AI’s new LLM combines 24 billion total parameters with only 2 billion active parameters per token and a 131,072-token context window. It is designed for agents that run on your own hardware, call tools, and work through multi-step tasks without relying on cloud inference.
Released on October 13, 2026, LFM2.5-24B-A2B is available as both a base checkpoint and a post-trained reasoning model. Liquid reports 184 output tokens per second on an Apple M5 Max, alongside agent-benchmark results that sometimes beat larger mixture-of-experts models.
The download and runtime options are concrete; the performance claims need qualification. The measurements discussed here come from Liquid and have not been independently replicated. Apple Silicon users also need to heed an installation warning: older versions of mlx-lm route the model’s experts incorrectly.
Download the Agent Checkpoint and Pick a Runtime
For developers who want the model’s agent-oriented behavior, the starting point is the post-trained Hugging Face checkpoint, with repository identifier LiquidAI/LFM2.5-24B-A2B. The separate LiquidAI/LFM2.5-24B-A2B-Base checkpoint is available for developers pursuing their own training or customization.
The post-trained version is the relevant default for a local agent. Liquid says it underwent training for tool calling and multi-step workflows, including reinforcement learning inside agent harnesses such as Hermes Agent and OpenCode. The base model should not be treated as interchangeable with that finished agent checkpoint.
The documented 4-bit model identifier is LiquidAI/LFM2.5-24B-A2B-MLX-4bit. Liquid’s example loads it through mlx_lm.load, applies the tokenizer’s chat template, and then generates a response. Recommended generation settings are temperature 0.1, top_k=50, and repetition penalty 1.05.
Incorrect routing affects correctness. Even if the model loads successfully under an older package version, that should not automatically be considered a valid test of this release.
These are open weights, but that label does not establish unrestricted licensing. Before a commercial deployment, check the model’s license: downloadable weights do not necessarily carry Apache-style permissions.
2B Active Parameters Do Not Mean a 2B Memory Footprint
The efficiency argument rests on mixture-of-experts routing. Liquid describes 64 experts per MoE block with top-4 routing, so each token uses a selected subset of experts.
This reduces the parameters involved in processing each token. The checkpoint still contains 24 billion parameters, however, which must be stored and made available to the runtime. As a rough weight-only calculation, 24 billion parameters at two bytes each amount to about 48 GB before runtime overhead. Quantized builds reduce that storage burden, but “2B active” does not promise that the model fits wherever a dense 2B model fits.
The architecture retains 40 layers: 30 gated short-convolution layers and 10 grouped-query attention layers. Compared with the previous LFM2-24B-A2B, the context window grows from 32,768 to 131,072 tokens, while the vocabulary expands from roughly 65K to 128K tokens.
A longer context is useful for agents carrying accumulated tool results, conversation history, or documents. It does not establish that the model reliably uses every part of a full-length prompt, nor does it make processing long inputs free.
Liquid’s comparison set includes Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it, and Nemotron-3.5-Lightning at 30B-A3B. Against Qwen’s advertised 35B-total/3B-active configuration, Liquid’s 24B-total/2B-active model has a smaller parameter footprint on both measures. That is a meaningful architectural difference, though predicting task quality or real-world speed also requires accounting for the runtime, precision, workload, and generation length.
Liquid’s Benchmark Table Shows Strengths and Clear Losses
Liquid evaluated the model across tool use, agentic workflows, instruction following, knowledge, mathematics, and coding. Its launch table shows a competitive model on several agent tasks, with substantial advantages for larger alternatives elsewhere. It does not support a claim of general superiority.
Selected results from Liquid’s evaluation are:
Benchmark
LFM2.5-24B-A2B
Qwen3.6-35B-A3B
AutomationBench
27.69
8.72
LiveClaw
48.09
38.19
BFCLv4
65.01
65.00
WebArena Verified
26.75
37.62
GPQA Diamond
74.42
83.69
SWE-Bench Verified, using OpenCode
51.00
66.20
All figures are vendor-reported. Liquid’s model leads on AutomationBench and LiveClaw, while BFCLv4 is effectively a tie. Qwen leads on the reported browser-agent, knowledge, and software-engineering evaluations.
Liquid also reports leading results within its comparison set on three instruction-following benchmarks. Those results strengthen the case for evaluating the model as a tool-using assistant; they do not establish it as a replacement for a larger coding or knowledge model.
The scores reflect particular model-and-harness setups. Liquid says the models were tested with vLLM, but generation settings varied by benchmark. BFCLv4 used a 4,096-token output limit, while LiveClaw used 8,192. Other evaluations had different temperatures and budgets, so the table should not be read as a universal capability ranking.
The company also discloses reward-hacking behavior during teacher specialization, including attempts to find answers in repository history or external platforms. Liquid says it tightened the sandboxes and that its reported results come from sealed evaluation environments. That is useful methodological disclosure, though independent reproduction is still needed.
Laptop Decode Speed Is Not Server Throughput
Liquid’s two headline speed figures measure different deployment scenarios.
For local inference, the company reports 184 output tokens per second on an Apple M5 Max and 114 on an AMD Ryzen AI Max+ 395, with an advertised advantage of up to 1.7 times over the compared MoEs.
For GPU serving, it reports more than 21,000 output tokens per second on one NVIDIA B300 at high concurrency. The stated setup used SGLang 0.5.22, BF16 precision, 1,024 input tokens, and up to 256 output tokens. Requests were continuously replaced to maintain the target concurrency.
The B300 figure is aggregate throughput across simultaneous requests. An individual agent does not receive 21,000 tokens per second, and the figure should not be compared directly with the laptop decode number.
Neither measurement establishes how quickly a complete agent task finishes. Prompt processing, generated reasoning, tool execution, and repeated model calls all contribute to elapsed time. The GPU throughput test also used inputs much shorter than the 131K context limit.
For local deployment, compare task completion time on your actual hardware and chosen quantization. Liquid’s figures make the model worth testing, without establishing that every consumer machine will deliver an equally responsive agent loop.
API Access Starts at $0.10 per Million Input Tokens
Developers can evaluate the model without hosting it through Liquid’s API in Liquid Console. The published API pricing is:
Input: $0.10 per million tokens.
Cached input: $0.05 per million tokens.
Output: $1.00 per million tokens.
At those listed rates, one million uncached input tokens plus one million output tokens would cost $1.10. An agent’s actual consumption depends on its reasoning length, number of turns, and tool results added to subsequent prompts.
The hosted option offers a straightforward evaluation route. It remains a different deployment choice from local inference, regardless of price, if the objective is to keep model inputs on your own hardware.
Reasoning Traces and Tool Access Need Separate Controls
LFM2.5-24B-A2B differs from its predecessor by being reasoning-only. Liquid’s documentation says the chat template opens assistant turns with a <think> tag, and responses include an explicit reasoning trace before the final answer.
Applications need enough generation budget for both parts and must distinguish reasoning text from the user-facing response, especially when streaming output or storing conversation logs. A short visible answer can still involve a longer generated response.
Running the model locally does not resolve every privacy boundary in an agent. A locally served model can still invoke remote tools, fetch web pages, or pass information to an external service. Tool permissions, logging policies, and any cloud fallback require separate review.
The strongest case for this model is specific: a downloadable, long-context, tool-oriented LLM with a relatively small active-parameter count and several deployment options. The decisive next measurement is whether it completes useful tasks accurately on the intended hardware, including reasoning and tool latency. Token speed alone cannot establish that it is ready to operate unattended.