LFM2.5-24B-A2B

LFM2.5-24B-A2B from Liquid AI is an open-weight, text-only reasoning model designed for high-throughput autonomous agents and local tool execution. Built around an asymmetric Mixture of Experts (MoE) architecture, it packs 24 billion total parameters while activating just 2.45 billion parameters per token. This design gives engineers the deep contextual reasoning and broad factual retention of a mid-sized network at the operational latency and compute cost of a lightweight sub-3B model.

Unlike conventional dense models in the 20B to 35B parameter bracket, LFM2.5-24B-A2B enforces an explicit chain of thought before generating its final output. Liquid AI trained the foundation model across 36 trillion tokens and post-trained it directly inside agent harnesses to optimize tool routing, API handling, and recovery from runtime errors. As a local AI model with 24B parameters, it occupies an unusual and practical niche: strong reasoning and agentic benchmark performance paired with decode speeds that make real-time multi-step tool calls viable on personal hardware.

For developers seeking to run LFM2.5-24B-A2B locally, this release resolves the standard tradeoff between reasoning capability and generation speed. The model avoids the high latency of dense 30B+ architectures while outperforming bulkier models on complex orchestration benchmarks.

LFM2.5-24B-A2B departs from standard transformer designs by using a hybrid structural backbone across its 40 layers. Rather than relying solely on global attention, the architecture combines 30 double-gated short convolution blocks with 10 Grouped Query Attention (GQA) layers. The convolution layers handle efficient local sequence mixing with minimal memory overhead, while the interleaved GQA layers maintain global sequence coherence across extended contexts.

The MoE routing mechanism is structured around 64 fine-grained experts per block, with top-4 routing per token. Distributing computation across 64 smaller experts rather than 8 or 16 large ones gives the router granular control over token specialization. Because only 4 of the 64 experts fire for any given forward pass, the active parameter load remains fixed at 2.45B.

Understanding this split is critical for local deployment:

• Storage and VRAM residency: You must have enough VRAM or system RAM to hold the full 24B parameter weights in memory.
• Compute latency: During the token generation phase, the GPU only executes matrix multiplications for 2.45B parameters.

This design maximizes LFM2.5-24B-A2B MoE efficiency, delivering exceptionally high inference throughput on memory-bandwidth-constrained consumer chips.

The model context window extends to 131,072 tokens, backed by an expanded vocabulary of 128,000 tokens. This 131K window allows developers to feed entire multi-file codebases, comprehensive OpenAPI documentation, or sprawling conversational histories into the prompt without triggering truncation or requiring brittle RAG chunking strategies.

Liquid AI tuned this model specifically for autonomous execution, structured reasoning, and precise instruction following. Its key capabilities include:

• Multi-Step Agentic Workflows: Post-trained inside agent execution environments, the model handles tool use, environment feedback loops, and multi-turn action chaining without getting caught in repetitive failures. On the LiveClaw agent evaluation, it achieves a score of 48.09, outperforming larger competitive baselines.
• Structured Reasoning and Logic: The model defaults to thinking through problems before producing an answer. Because active parameter compute is cheap, extended chain-of-thought tokens generate quickly, making it practical for deep logical analysis, symbolic planning, and mathematical problem-solving.
• Local Coding and Tool Calling: LFM2.5-24B-A2B for coding tasks handles refactoring, writing integration glue code, parsing nested JSON schemas, and generating shell commands. Its low active parameter count enables rapid generation of syntactically accurate patches and boilerplate.
• Broad Multilingual Coverage: The expanded 128K vocabulary provides native tokenization for 16 languages: English, Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese, Spanish, Vietnamese, Thai, Indonesian, Hindi, Russian, and Polish.

Running this model locally requires understanding the difference between memory capacity requirements and compute throughput. While the model acts like a 2.5B parameter network during generation, you must load the complete 24B parameter set into memory.

The total memory footprint depends heavily on the chosen quantization format:

• BF16 / FP16 (Native): ~48 GB to 52 GB VRAM. Requires dual 24GB GPUs (such as 2x RTX 3090 or 2x RTX 4090) or an Apple Silicon Mac with 64GB+ unified memory.
• FP8 (Block-wise): ~26 GB to 28 GB VRAM. Fits onto professional 32GB or 48GB cards (such as the RTX 5000 Ada or A6000), or a dual-GPU consumer rig.
• Q5_K_M (5-bit GGUF): ~18 GB to 20 GB VRAM. Recommended for users who have a 24GB GPU and want near-lossless reasoning fidelity with moderate context depths.
• Q4_K_M (4-bit GGUF): ~14 GB to 16 GB VRAM. The best quantization for LFM2.5-24B-A2B on consumer hardware. Leaving 8 GB of headroom on a 24GB card allows you to scale the KV cache toward the full 131K context window.

When considering how to run a 24B model on consumer GPU hardware, the NVIDIA GeForce RTX 3090 and RTX 4090 (24GB VRAM) represent the best GPU for LFM2.5-24B-A2B setups. A single RTX 4090 running the Q4_K_M quantization can comfortably process prompts and sustain generation speeds between 80 and 120 tokens per second, thanks to the 2.45B active compute footprint.

On Apple Silicon, unified memory architectures provide an ideal environment for long-context runs. Systems equipped with 32GB, 48GB, or 64GB of unified memory (such as M3/M4 Pro and Max configurations) run the quantized GGUF or MLX checkpoints seamlessly. On high-end silicon like the Apple M5 Max, generation benchmarks reach up to 184 tokens per second.

The quickest way to get started is via Ollama or llama.cpp. Once the GGUF weights are registered in your local environment, you can run the model directly from the command line:

1ollama run lfm2.5:24b

For production agent harnesses using vLLM or SGLang on NVIDIA hardware, serve the native FP8 checkpoint to maximize batched throughput:

1vllm serve LiquidAI/LFM2.5-24B-A2B-FP8 --max-model-len 32768

Recommended sampling parameters across all runtimes are temperature: 0.1, top_k: 50, and repetition_penalty: 1.05.

Evaluating LFM2.5-24B-A2B against alternatives highlights the distinct tradeoffs between dense networks and sparse MoEs.

Qwen3.6-35B-A3B features roughly 50% more total parameters and active parameters per token. While Qwen retains strong broad knowledge, LFM2.5-24B-A2B edges it out on dedicated agent benchmarks: scoring 48.09 versus 38.19 on LiveClaw, and 27.69 versus 8.72 on AutomationBench. Furthermore, the lower active parameter footprint of LFM2.5 translates directly to faster decode speeds and lower power consumption on local workstations.

Standard dense models in the 24B to 32B range activate every parameter for every token. On a single RTX 4090, a 4-bit dense 32B model typically generates between 30 and 45 tokens per second. LFM2.5-24B-A2B runs two to three times faster during generation phases.

The primary tradeoff lies in raw memorization. Dense 32B models have more total parameter capacity dedicated to general knowledge retrieval, whereas LFM2.5-24B-A2B prioritizes tool orchestration, structured reasoning paths, and low execution latency. If your workflow requires high-speed, multi-step autonomous tool use on a 24GB GPU, LFM2.5-24B-A2B is the more efficient architectural choice.