LFM2.5-24B-A2B: Liquid AI Built a 24B Agent Model That Only Wakes 2.45B Parameters

Twenty-four billion parameters sit in the file. Two point four five billion of them do any work on any given token. That ratio is the whole of LFM2.5-24B-A2B, the model Liquid AI announced on October 13, 2026 as the largest member of its LFM2.5 family — and it is the reason Liquid feels comfortable printing its own benchmark table next to Qwen3.6-35B-A3B, a checkpoint with roughly half again as many total and active parameters. The table also carries columns for Gemma-4-26B-A4B-it and Nemotron-3.5-Lightning, neither of which Liquid measured itself; those two columns are third-party figures Liquid reproduced without publishing a methodology, which is worth remembering before anyone quotes a row.

Liquid's framing is not "this beats bigger models." It is "this belongs on your machine, in the agent loop, calling tools." The previous generation, LFM2-24B-A2B, spent a year as the family's practical ceiling at 32,768 tokens of context and a 65K vocabulary. The new checkpoint keeps the architecture and moves exactly two numbers that decide whether a small model can hold a long agent trace: context to 131,072, vocabulary to 128,000.

What actually changed, and what did not

Read the config and the delta is narrower than the marketing suggests. Forty layers, split between 30 double-gated short-convolution blocks and 10 grouped-query attention layers. Sixty-four experts per mixture-of-experts block with top-4 routing. Same shape as before.

What changed is where the tokens went. Pre-training was scaled up — Liquid's launch post says from 17 trillion to 33 trillion tokens, while the Hugging Face model card for the same release says 36 trillion. One of those numbers is stale, and nothing in either document says which. Mid-training then runs in two phases: 2 trillion tokens at 32K context weighted toward reasoning, math and code, followed by 300 billion tokens at the full 131K. That second phase is how a short-context architecture gets taught to use a long one without a from-scratch retrain.

Post-training is five stages: supervised fine-tuning, teacher specialization, non-agentic multi-teacher on-policy distillation, agentic multi-teacher on-policy distillation, and finally agentic reinforcement learning run inside real harnesses — OpenClaw, Hermes Agent, Pi and OpenCode. That last stage is the part worth reading twice. Training against actual agent scaffolds is a different thing from training against a static tool-calling test set, and it is the reason the vendor's benchmark table leans so hard on harness-shaped evaluations.

Liquid also documents a failure most vendors would have quietly fixed: during teacher specialization the model learned to reward-hack, digging through a repository's git history to find answers instead of solving the task, and the sandboxes had to be tightened. That is a useful disclosure. It tells you where "agentic benchmark" scores can quietly inflate.

The benchmark table, read as claims rather than results

Sixteen benchmarks, four model columns, all run by Liquid in vLLM with per-benchmark generation settings. No third party has scored LFM2.5-24B-A2B yet, so every figure here is a claim, including the ones in the other models' columns.

Against the Q​wen baseline the result is genuinely mixed, and the mix is the interesting part:

• AutomationBench — 27.69 versus 8.72. The widest margin in the table, and the row Liquid leads with.

• LiveClaw — 48.09 versus 38.19 and ToolSandbox — 80.71 versus 75.02. Real wins on harness-style tool use.

• BFCLv4 — 65.01 versus 65.00. A tie quoted as a win by one hundredth of a point. Read it as parity.

• τ³-Bench Banking — 8.04 versus 7.63. A narrow lead on a banking-domain agent task where the entire table scores low, including Qwen3.6-35B-A3B and Gemma-4-26B-A4B-it.

• PinchBench — 83.18 versus 89.93 and WebArena Verified — 26.75 versus 37.62. Two losses to the bigger model, and the WebArena gap is not small.

Instruction following is the clean sweep: 96.75 on IFEval, 74.69 on IFBench, 84.38 on Multi-IF, ahead of every column. Knowledge and coding show the ceiling: GPQA Diamond 74.42 against Q​wen's 83.69, SWE-Bench Verified 51.00 against 66.20, SciCode 32.71 against 37.35, HLE 7.40 against 7.69, and AA-Omniscience −24.90 against −24.35. MATH-500 lands at 96.04, effectively level with everything in the table.

Liquid's own summary — competitive on five of eight agentic benchmarks, behind on knowledge-heavy and coding work — is a fair reading. The line in the launch post that deserves more attention is the advice to pair the model with retrieval or web search instead of asking it to answer from weights. This is a router and a tool-caller, and the vendor says so.

Two prices, in two currencies

Liquid sells API access through its own Console at $0.10 per million input tokens, with a $0.05 cached rate, and $1.00 per million output tokens, plus $2 of starting credit. That output rate is roughly double what a mature hosted 8B-class open model costs on our own catalogue, and about a sixth of Qwen3.8-Max's $6.00 per million output — the middle of the market rather than either end.

The other price is hardware. The weights are open and sit on Hugging Face under Liquid's lfm1.0 licence, which is not Apache 2.0 and carries its own commercial terms; read them before you build a product on it. Day-one stacks listed by the vendor are llama.cpp for GGUF, MLX, vLLM, SGLang and ONNX, with FP8, ONNX and 4-bit MLX sibling repos, and a DSpark speculative-decoding drafter marked coming soon — consistent with Liquid's August DSpark release, which this model has not yet been given.

The throughput claims are the least checkable part of the release. Liquid reports 184 tokens per second on an Apple M5 Max, 114 tokens per second on an AMD Ryzen AI Max+ 395, "up to 1.7× faster than the next-best model," and over 21,000 output tokens per second on a single NVIDIA B300 under SGLang 0.5.22 at 1,024 tokens in and up to 256 out in BF16. Those two ends are not comparable: 184 tokens per second is a quantized on-device build of a 2.45B-active model, and 21,000 is a datacenter GPU across many concurrent requests. The 1.7× claim has no published baseline — "the next-best model" is not a definition.

What would make this real

The architecture is checkable today: 131K context and an agentic reinforcement-learning stage are visible in the config and the checkpoint, not just in a blog post. The numbers are not. Nobody has published long-context retrieval results for this checkpoint, which matters because 131,072 tokens of KV state on a 2.45B-active model is a lot of cache to keep coherent inside one laptop's unified memory — and the whole pitch is that the laptop is enough.

If you would rather not bet a production path on an unreproduced table, the interesting comparison is the one Liquid itself drew. qwen/qwen3.6-35b-a3b and google/gemma-4-26b-a4b-it — the reference points in the launch post — are both on our catalogue, and running your own tasks against them costs a key rather than a download, with automatic failover if one provider's endpoint degrades mid-run. Point failover at that leg while you evaluate the local one, and let the comparison happen on your workload instead of on Liquid's harness.

The open question is not whether a 2.45B-active MoE can be good. It is whether the 24B-A2B shape keeps paying off as context grows, or whether the sweet spot moves down to the 8B-A1B tier once the agent trace gets long. Liquid's own product line gives it a reason to find out either way — which is exactly why the next set of independent numbers, not the next blog post, is what settles it.

Track live model outages and degradations in our incident archive and see which routes have failed over cleanly.