Liquid AI launches LFM2.5-24B-A2B with 24B parameters, 2B active parameters and 184 tokens per second on Apple M5 Max
Liquid AI has released LFM2.5-24B-A2B, a 24-billion-parameter Mixture-of-Experts reasoning model designed to run autonomous AI agents on local hardware rather than depending entirely on cloud inference. The model activates approximately 2.45 billion parameters per token, supports a 131,072-token context window and reaches a company-reported decoding speed of 184 tokens per second on an Apple M5 Max.
The release extends Liquid AI's LFM2.5 family into a larger performance category while retaining its emphasis on efficient inference. The company reports a score of 48.09 on LiveClaw, compared with 38.19 for Qwen3.6-35B-A3B, and claims that its hybrid architecture delivers up to 1.7 times faster on-device generation than the next-fastest comparable Mixture-of-Experts model in its tests.
LFM2.5-24B-A2B is a text-only reasoning model, not a native multimodal system. Its primary capabilities include tool calling, coding, mathematical reasoning, instruction following and multi-step agent execution. Liquid AI has published the model weights, a base checkpoint and optimized variants for local and server deployment.
The economic proposition is particularly relevant to developers building persistent agents. These systems may generate substantial numbers of intermediate reasoning tokens, make repeated tool calls and remain active for extended periods. Running inference locally can reduce dependence on per-token cloud billing and give organizations greater control over data processing, although hardware acquisition, memory consumption, electricity and maintenance remain real costs.
The headline performance figures are promising, but they are vendor-reported measurements under specified conditions. The 184-token-per-second result does not represent guaranteed speed on every Apple computer, and the LiveClaw result should not be interpreted as proof that the model outperforms larger competitors across all reasoning and software-engineering tasks.
··········
THE 24B MIXTURE-OF-EXPERTS ARCHITECTURE ACTIVATES ONLY A FRACTION OF ITS PARAMETERS PER TOKEN.
LFM2.5-24B-A2B separates total model capacity from the amount of computation required to process an individual token.
A conventional dense language model generally uses its complete parameter set during each forward pass. A Mixture-of-Experts model instead contains multiple specialized computational components and activates a selected subset for each token.
LFM2.5-24B-A2B contains approximately 24 billion parameters overall, but Liquid AI specifies 2.45 billion active parameters per token. The A2B designation is therefore a rounded description of its active computation, not a claim that exactly two billion parameters are used.
The architecture includes 40 layers, combining 30 double-gated short-convolution blocks with 10 grouped-query attention layers. Its Mixture-of-Experts components contain 64 experts per block, with top-four routing selecting the experts used for a given token.
This combination distinguishes the model from conventional Transformer-only architectures. Short-convolution blocks are intended to process sequential information efficiently, while attention layers retain mechanisms for modeling relationships across the context.
The architecture aims to reduce the computational work associated with token generation while preserving a larger total parameter budget for learned representations.
........
Specification | LFM2.5-24B-A2B |
Total parameters | 24 billion |
Active parameters per token | Approximately 2.45 billion |
Architecture | Hybrid convolution, attention and MoE |
Total layers | 40 |
Short-convolution layers | 30 |
Grouped-query attention layers | 10 |
Experts per MoE block | 64 |
Selected experts per token | 4 |
Context window | 131,072 tokens |
Vocabulary | 128,000 tokens |
Modality | Text only |
........
The distinction between total and active parameters is essential when assessing hardware requirements.
Low active-parameter counts reduce computation, but do not mean that only the active parameters must be stored in memory. The full model weights, or an appropriate offloading arrangement, must still be available so the routing mechanism can access different experts as needed.
Consequently, a 24B MoE model can require substantially more memory than a dense 2.45B model, even when the two have more comparable computational requirements per generated token.
This is one reason quantization remains important for local deployment.
··········
LIQUID AI EXPANDS CONTEXT TO 131K TOKENS AND SCALES TRAINING TO APPROXIMATELY 36 TRILLION TOKENS.
The new model retains the broad architecture of LFM2-24B-A2B while expanding its context capacity, vocabulary and training process.
The earlier model supported approximately 32,000 context tokens. LFM2.5-24B-A2B increases that capacity to 131,072 tokens, allowing substantially longer documents, conversation histories, code excerpts and agent trajectories to be processed within a supported interaction.
Liquid AI also doubles the vocabulary from approximately 65,000 to 128,000 tokens. This expansion is intended to improve tokenization efficiency, particularly for languages using non-Latin writing systems.
The model supports 16 languages, including English, Italian, Spanish, French, German, Arabic, Chinese, Japanese, Korean and Portuguese.
The company's technical documentation describes approximately 33 trillion tokens of pretraining, followed by additional training phases bringing the overall training budget to roughly 36 trillion tokens.
Mid-training includes two trillion tokens of curated material emphasizing reasoning, mathematics, code, instruction following and multilingual text. A further 300 billion tokens target long-context behavior at the expanded 131K-token length.
Tool calls and multi-turn agent trajectories are included in the training process, preparing the model to interact with external software rather than simply produce standalone answers.
........
Characteristic | Previous LFM2-24B-A2B | New LFM2.5-24B-A2B |
Total parameters | 24B | 24B |
Active parameters | Approximately 2B | Approximately 2.45B |
Context window | 32K | 131K |
Vocabulary | Approximately 65K | 128K |
Pretraining tokens | Approximately 17T | Approximately 33T |
Training emphasis | Efficient language and agent tasks | Expanded reasoning, agents and long context |
........
A larger context window can reduce the need to divide information into separate requests, but it does not guarantee perfect retrieval or reasoning across the entire sequence.
Long-context applications should still test whether the model correctly identifies relevant information buried in large inputs, maintains consistency between distant passages and avoids introducing unsupported conclusions.
For agent developers, the more important improvement may be the combination of extended context with training specifically designed around tool use and multi-turn execution.
··········
LIVECLAW RESULTS SUGGEST STRONG AGENT PERFORMANCE AGAINST LARGER MIXTURE-OF-EXPERTS MODELS.
Liquid AI reports that LFM2.5-24B-A2B outperforms Qwen3.6-35B-A3B on LiveClaw despite using fewer total and active parameters.
LiveClaw evaluates models performing agent-oriented tasks through an execution environment rather than answering isolated questions.
Liquid AI reports a score of 48.09 for LFM2.5-24B-A2B, compared with 38.19 for Qwen3.6-35B-A3B.
The absolute difference is 9.90 points. Relative to the reported Qwen score, Liquid AI's result is approximately 25.9% higher.
That percentage is a derived comparison of benchmark scores, not a claim that the model completes 25.9% more real-world tasks or produces equivalent improvements in every application.
........
LiveClaw evaluation | Reported score |
LFM2.5-24B-A2B | 48.09 |
Qwen3.6-35B-A3B | 38.19 |
Absolute difference | +9.90 points |
Relative score difference | +25.9% |
........
The comparison is notable because the Qwen model has approximately 50% more total and active parameters, according to Liquid AI's published description.
However, benchmark performance depends on the evaluation environment, tool configuration, prompts, sampling parameters and the distribution of tasks.
Liquid AI's model card documents specific settings for LiveClaw and other evaluations, including BFCLv4, ToolSandbox, τ³-Bench Banking and WebArena Verified.
The company also describes reinforcement learning conducted inside established agent environments, including OpenClaw, Hermes Agent, Pi and OpenCode.
Training within these environments may improve familiarity with tool formats, execution patterns and common agent tasks. It also means that benchmark results should be interpreted with attention to the relationship between training environments and evaluation workloads.
For practical deployment, developers should test the model using the exact agent framework and tools they intend to operate.
An agent that performs well on one benchmark may still struggle with authentication errors, changing interfaces, ambiguous instructions or tasks requiring extensive domain-specific knowledge.
The strongest interpretation of the LiveClaw result is that Liquid AI has demonstrated competitive agent-oriented performance at a relatively low active-parameter budget under its published evaluation conditions.
It does not establish universal superiority over larger reasoning models.
··········
APPLE M5 MAX REACHES 184 TOKENS PER SECOND IN LIQUID AI'S LOCAL INFERENCE TESTS.
The most commercially interesting performance claim concerns fast inference on consumer-accessible hardware rather than large data-center accelerators.
Liquid AI reports that LFM2.5-24B-A2B generates 184 output tokens per second on an Apple M5 Max and 114 tokens per second on an AMD Ryzen AI Max+ 395.
These figures come from tests conducted using Liquid AI's Pipette benchmarking infrastructure with llama.cpp, Q4_K_M quantization and a 4,000-token input context.
The company reports up to 1.7 times faster generation than the next-fastest comparable Mixture-of-Experts model in its selected comparison.
........
Hardware | Reported decoding speed | Test configuration |
Apple M5 Max | 184 tokens/s | llama.cpp, Q4_K_M, 4K input |
AMD Ryzen AI Max+ 395 | 114 tokens/s | llama.cpp, Q4_K_M, 4K input |
NVIDIA B300 | Over 21,000 output tokens/s | High-concurrency server throughput |
........
The Apple and AMD results describe decoding throughput under specific conditions. They should not be confused with prompt-processing speed, complete response latency or guaranteed performance on longer contexts.
The NVIDIA B300 figure measures something different.
Liquid AI reports more than 21,000 output tokens per second on a single B300 using SGLang 0.5.22, BF16 weights and high concurrency.
That figure represents aggregate server throughput across concurrent requests, not the speed experienced by one individual user.
The distinction matters because an application serving thousands of requests has different performance priorities from a personal agent operating on one computer.
For a local agent, single-user latency, memory pressure and sustained performance may be more important than total data-center throughput.
At 184 tokens per second, generating 1,000 output tokens would theoretically require approximately 5.4 seconds of decoding time, excluding prompt processing, reasoning overhead, tool execution and other delays.
At 114 tokens per second, the corresponding decoding time would be approximately 8.8 seconds.
These calculations illustrate the significance of the reported speeds without predicting complete task-completion times.
Real agent workloads may spend much of their execution time waiting for browsers, filesystems, network requests or external tools.
A faster model can reduce inference delays, but the overall benefit depends on the proportion of time spent generating tokens.
··········
QUANTIZATION MAKES LOCAL DEPLOYMENT POSSIBLE WITHOUT ELIMINATING MEMORY REQUIREMENTS.
LFM2.5-24B-A2B is designed for local deployment, but its 24 billion total parameters still create a substantial memory footprint.
At BF16 precision, storing 24 billion parameters requires approximately 48 billion bytes for model weights alone.
This is approximately 44.7 GiB before accounting for runtime buffers, context caches and other memory requirements.
Lower-precision formats can reduce that footprint significantly.
Liquid AI publishes optimized variants, including FP8, ONNX and MLX checkpoints, while community and supported ecosystem quantizations provide additional deployment options.
The official ONNX repository lists a Q4 variant of approximately 15.3 GB for CPU deployment, a Q4F16 variant of approximately 13.7 GB for CUDA environments and a Q8 variant of approximately 27.1 GB.
An official five-bit MLX checkpoint is approximately 16.5 GB.
........
Model format | Approximate model size | Deployment consideration |
BF16 weights, theoretical | 48 GB | High-memory GPU or workstation |
ONNX Q8 | 27.1 GB | Higher-precision local inference |
MLX 5-bit | 16.5 GB | Apple Silicon |
ONNX Q4 | 15.3 GB | CPU-oriented deployment |
ONNX Q4F16 | 13.7 GB | CUDA deployment |
........
These figures describe model storage or weight size, not the complete amount of system memory required during execution.
Actual requirements depend on runtime implementation, batch size, context length, key-value caching and operating-system overhead.
A machine with 16 GB of unified memory should therefore not automatically be assumed capable of running a 16.5 GB checkpoint reliably.
For long-context agents, additional memory can become particularly important because the runtime must maintain information associated with the active sequence.
Quantization also introduces potential quality trade-offs. Reducing numerical precision can affect output behavior, especially in demanding reasoning or tool-use tasks.
The magnitude of any degradation should be measured on the intended workload rather than inferred from the quantization format alone.
The practical advantage of LFM2.5-24B-A2B is its combination of relatively modest active computation and deployable quantized weights, not an absence of hardware requirements.
··········
DEVELOPERS CAN DEPLOY THE MODEL WITH TRANSFORMERS, VLLM, SGLANG AND LOCAL INFERENCE TOOLS.
Liquid AI has released model checkpoints that can be integrated into existing development environments rather than requiring a proprietary hosted API.
The primary post-trained checkpoint is published as LiquidAI/LFM2.5-24B-A2B.
A separate base checkpoint is available for organizations that require substantial domain-specific fine-tuning or want to experiment with their own post-training methods.
Liquid AI provides examples for Hugging Face Transformers, vLLM and SGLang, together with optimized formats intended for local deployment.
Developers can use Transformers to load the model and generate responses directly. For server applications, vLLM and SGLang support inference endpoints suitable for integration with existing software.
The model also supports tool calling, making it suitable for agent frameworks that can interpret structured tool requests and return execution results.
Liquid AI's recommended generation settings include a temperature of 0.1, top-k sampling of 50 and a repetition penalty of 1.05.
These defaults are intended to provide stable behavior, but individual agent frameworks and benchmarks may require different configurations.
Open-weight availability does not necessarily mean unrestricted open-source licensing.
The model is distributed under the LFM Open License v1.0, rather than Apache 2.0 or another standard permissive software license.
Organizations planning commercial redistribution, hosted services or model modifications should review the actual license terms before deployment.
For enterprise applications, additional considerations include the security of downloaded checkpoints, dependency management, logging, model updates and restrictions on access to sensitive information.
Running a model locally can reduce the need to transmit prompts to an external inference provider, but it does not automatically guarantee privacy.
An agent may still communicate with cloud services through its tools, external APIs, browser sessions or telemetry systems.
Data protection therefore depends on the entire application architecture, not merely the location of the model weights.
··········
LOCAL AGENTS CAN REDUCE CLOUD TOKEN EXPENDITURE, BUT HARDWARE UTILIZATION DETERMINES THE ECONOMICS.
The economic case for LFM2.5-24B-A2B is strongest when an organization can keep its inference hardware sufficiently utilized while maintaining acceptable task quality.
Cloud inference generally charges according to token consumption, with additional costs possible for tools, storage and other services.
A local model replaces much of that variable expenditure with hardware acquisition, electricity, maintenance and engineering costs.
For a simple illustration, consider a workstation costing $4,000 and used over three years.
Straight-line allocation of its purchase price produces an approximate hardware cost of $111 per month.
If the machine consumes an average of 150 watts during eight hours of operation per day, 22 days per month, its monthly electricity use would be approximately 26.4 kWh.
At an illustrative electricity price of $0.25 per kWh, the resulting energy cost would be approximately $6.60 per month.
The combined illustrative monthly cost would therefore be around $118 before maintenance, administration, cooling and other expenses.
........
Illustrative cost component | Monthly amount |
$4,000 workstation over 36 months | $111.11 |
Electricity at assumed utilization | $6.60 |
Combined hardware and electricity | $117.71 |
Maintenance and engineering | Excluded |
Network and external tool services | Excluded |
........
This is a derived scenario, not a published Liquid AI deployment estimate.
It also assumes that the workstation is dedicated to the relevant workload and that its purchase cost can reasonably be allocated over three years.
The comparison with a cloud model depends on the amount of inference performed.
If a hosted model costs $2 per million input tokens and $10 per million output tokens, a workload consuming 100 million input tokens and 20 million output tokens monthly would cost approximately $400 in direct API charges.
At that consumption level, the illustrative local hardware cost appears lower.
However, this comparison is incomplete unless the local model can perform the same tasks at an acceptable level of quality.
If the local system requires additional attempts, produces more errors or needs greater human supervision, those costs can outweigh the savings in inference charges.
Conversely, a high-volume application with predictable tasks may benefit substantially from local deployment.
The most useful metric is total cost per successfully completed task, incorporating hardware, electricity, software maintenance, inference performance and human intervention.
··········
THE MODEL TARGETS PERSISTENT AGENTS, CODING ASSISTANTS AND PRIVATE ENTERPRISE WORKFLOWS.
LFM2.5-24B-A2B is particularly relevant to applications that require repeated reasoning and tool use but do not necessarily need the largest available frontier model.
A local coding assistant can inspect repository files, propose changes, run tests and interpret failures without sending every prompt to a third-party inference endpoint.
An enterprise document agent can retrieve information from internal files, apply company-specific procedures and generate structured outputs within a controlled environment.
A personal assistant can maintain local application state, invoke approved tools and carry out recurring administrative tasks.
These applications share an important characteristic: they may require many relatively small model interactions rather than one large response.
Efficient decoding can therefore reduce cumulative inference time, especially when the agent generates intermediate reasoning steps and tool instructions.
Liquid AI explicitly trains the model for agent frameworks such as OpenClaw, Hermes Agent, Pi and OpenCode.
That specialization may provide advantages when the production environment resembles the training and evaluation workflows.
However, agent reliability also depends on permissions, error recovery, tool schemas and the quality of external information.
A local model should not receive unrestricted access to financial accounts, production systems or sensitive documents merely because its inference runs on privately controlled hardware.
Applications still need authorization boundaries, confirmation procedures and records of consequential operations.
For business use, the model's 16-language support and extended context window may also be valuable when processing multilingual documents and substantial reference material.
Its text-only design remains a limitation for applications requiring native interpretation of images, audio or video.
Those workflows would need separate perception models or preprocessing systems, adding complexity and potentially reducing the efficiency advantage of a single-model architecture.
··········
LFM2.5-24B-A2B OFFERS A DIFFERENT COMPETITIVE STRATEGY FROM CLOUD FRONTIER MODELS.
Liquid AI is prioritizing efficient local agent execution rather than attempting to match the largest proprietary models across every benchmark category.
Recent frontier-model releases have emphasized extremely large context windows, advanced reasoning, autonomous coding and professional-domain performance.
These capabilities can be valuable, but their deployment often depends on hosted infrastructure and usage-based pricing.
LFM2.5-24B-A2B approaches the market from a different direction.
Its 24-billion-parameter MoE architecture aims to provide substantial reasoning and tool-use capability while limiting active computation to approximately 2.45 billion parameters per token.
The resulting efficiency allows Liquid AI to report high decoding speeds on local hardware and substantial aggregate throughput on server accelerators.
The LiveClaw comparison suggests that specialized agent training can deliver competitive results without requiring a larger active parameter budget.
At the same time, the model's text-only capabilities, hardware requirements and limited independent benchmark evidence constrain broader conclusions.
It should not automatically be considered a replacement for leading proprietary models on scientific reasoning, complex legal analysis or the most demanding software-engineering problems.
A more realistic deployment strategy may combine local and cloud inference.
Routine classification, document processing, tool orchestration and lower-risk agent tasks can run locally, while difficult cases are escalated to a larger hosted model.
Such architectures can potentially reduce cloud consumption while preserving access to higher-capability systems when necessary.
Their effectiveness depends on reliable routing decisions, consistent data handling and careful evaluation of the tasks assigned to each model.
Liquid AI's LFM2.5-24B-A2B demonstrates how architecture, training specialization and optimized inference can make capable reasoning agents practical on local hardware. Its strongest claim is not that 24 billion parameters outperform every larger model, but that approximately 2.45 billion active parameters can deliver useful agent performance at speeds and deployment costs that may be attractive outside conventional cloud infrastructure.
The next test is independent evaluation across realistic workloads, particularly those involving long contexts, complex tool sequences and repeated autonomous execution.
··········
FOLLOW US FOR MORE.
DATA STUDIOS
datastudios.org
