LFM2.5-24B-A2B
LFM2.5-24B-A2B is Liquid AI's open-weight, text-only sparse mixture-of-experts reasoning model (24.0B total / 2.45B active parameters) built for fast, private, on-device and edge-hosted agents that call tools. It is a 40-layer hybrid convolution + grouped-query-attention stack with 64 experts and top-4 routing, a native 131,072-token context, and an always-on reasoning pass before every answer — priced at $0.05/$0.70 per 1M input/output tokens on OpenRouter. Its published evaluations target tool-use and instruction-following rather than frontier knowledge or math, where it is deliberately mid-tier.
Empirical Evaluation Results
Architectural Profile & Capabilities
LFM2.5-24B-A2B (liquid/lfm-2.5-24b-a2b) is the largest model in Liquid AI's LFM2.5 family, released under the LFM Open License v1.0 as open weights with GGUF, ONNX, and FP8 blockwise-quantized derivatives. Architecturally it is not a conventional dense Transformer and not an all-attention MoE: it is a hybrid stack of 40 layers in which roughly 30 are double-gated short-convolution blocks and 10 are grouped-query attention (GQA) layers, with MoE feed-forward blocks containing 64 experts and top-4 routing, a 128,000-token vocabulary, and 24.0B total parameters of which only ~2.45B are activated per token (Liquid's documentation rounds this to '2B active'). That hybrid conv/GQA substrate is the source of its efficiency claims: it holds a 131,072-token native context and full BF16 weights in roughly 15-16 GB, permitting laptop-class and single-GPU agent hosting rather than datacenter-class serving. Training is a ~36T-token staged budget: ~33T tokens of pretraining, ~2T tokens of mid-training at up to 32K context, and ~300B tokens at the full 131K context length, followed by post-training inside agent harnesses for reasoning, instruction following, tool calling, and multi-step execution. Two checkpoints ship: LFM2.5-24B-A2B-Base (pretrained) and the post-trained LFM2.5-24B-A2B documented here. The served variant always emits a reasoning trace before its final answer, exposed under a </think>-style contract; there is no separate 'non-thinking' toggle documented for this checkpoint, so every request pays reasoning-token latency and output billing. Liquid's published comparison covers 16 benchmarks and positions the model explicitly against Qwen3.6-35B-A3B. The pattern is consistent and matters for deployment planning: it wins or matches on 5 of 8 tool-use/agentic and instruction-following tests — LiveClaw 48.09 (vs 38.19), AutomationBench 27.69 (vs 8.72), ToolSandbox 80.71 (vs 75.02), IFEval 96.75 (vs 93.06), IFBench 74.69 (vs 64.21) — but loses decisively on agentic software repair, scoring 51.0 on SWE-bench Verified under the OpenCode harness versus 66.2 for Qwen3.6-35B-A3B. Independent aggregation places SciCode at roughly 32.7%, and third-party single-run agentic coding tests on PatchEval report materially weaker results than the vendor harness. Treat it as a tool-orchestration and structured-output engine, not a code-repair specialist. No verified scores exist in the public record for GPQA Diamond, AIME 2026, HLE, ARC-AGI-2, Terminal-Bench, OSWorld, BrowseComp, TAU-2/TAU-3, MRCR v2, or AA Intelligence Index for this exact variant, and none are reported here. Throughput is the headline commercial property. Liquid reports the model as the fastest in its size class, reaching over 21,000 output tokens per second at high concurrency on a single NVIDIA B300 GPU, with on-device generation of 184 tok/s on an Apple M5 Max (4,318 input tok/s prompt processing, ~15 GB resident) and 146 tok/s on a Mac Studio. OpenRouter's own telemetry shows a median of roughly 225 output tokens per second for the served endpoint. At $0.05/1M input and $0.70/1M output it is cheap enough to sit behind fan-out tool loops, provided reasoning-token volume is budgeted rather than assumed away.
24.0B total parameters with ~2.45B active per token (Liquid documents this as '2B active'). 40 total layers split between double-gated short-convolution blocks (~30) and grouped-query attention layers (~10) rather than a uniform attention stack. MoE feed-forward blocks use 64 experts per block with top-4 routing, so only selected experts contribute to each token's compute. Vocabulary 128,000 tokens. Native context 131,072 tokens (128K as served on OpenRouter); mid-training at up to 32K followed by ~300B tokens of long-context training at the full 131K window. Text-only modality; no vision or audio encoder. Post-trained as an always-on reasoning checkpoint that emits a reasoning trace before the final answer, with agentic post-training inside tool-calling harnesses (function schemas, multi-step execution). Weights distributed as BF16, FP8 (blockwise linear weight quantization plus dynamic activation quantization), GGUF, and ONNX; FlashAttention-2 supported on compatible GPUs. Resident footprint ~15-16 GB at BF16-scale precision, enabling single-consumer-GPU and Apple-silicon deployment.
Recommended Workloads & Primary Use Cases
- •Always-on reasoning is a hard latency and cost floor: this checkpoint has no documented no-think mode, so TTFT includes a full reasoning prelude and every trace token bills at the $0.70/1M output rate — budget 3-10x the visible answer length in output tokens per request.
- •Agentic coding is a documented weakness, not a rounding error: 51.0 on SWE-bench Verified under the OpenCode harness versus 66.2 for Qwen3.6-35B-A3B, and independent PatchEval-style runs report worse. Do not route multi-file refactors, failing-test repair, or long-horizon repository work here without an escalation path.
- •Context is 131,072 natively but 128,000 as served on OpenRouter, and effective long-context recall degrades well before the ceiling (only ~300B tokens of the ~36T training budget were spent at full 131K). Chunk and re-retrieve rather than relying on a single 100K+ prompt.
- •Sampling is not free-form: Liquid's own evaluations pin temperature 0.6 and a max output budget of 32,768 tokens (vLLM) for SWE-bench, and behaviour is harness-sensitive. Copying generic temperature 0.7-1.0 defaults or truncating max_tokens below the reasoning-trace length will produce truncated or malformed answers.
- •Knowledge-heavy question answering is explicitly out of scope — Liquid recommends tools or retrieval for knowledge-dependent work, and the model has no verified GPQA/AIME/HLE-class results. Treat parametric recall as unreliable and ground factual claims in tool output.
- •Text-only, tool-centric interface: no vision, and tool schemas must be passed in the documented function-calling format. Non-schema or loosely-described tool descriptions are a common cause of argument hallucination in models post-trained inside harnesses.
Calls to LFM2.5-24B-A2B are routed through strict Zero Data Retention inference channels. Prompts and outputs are never stored, indexed, or monitored by LiquidAI.