LFM2.5-24B-A2B: Liquid AI's Biggest Model Yet — 131K Context, $0.10 Input, and Real Agent Scores

Liquid AI shipped LFM2.5-24B-A2B on October 13, 2026, and if you are reading this to decide whether to download it, the short answer is that it is the first LFM small enough to run on a laptop and strong enough to be the model doing the tool calling rather than the model being called by one. It is a 24.0-billion-parameter mixture-of-experts — 2.45B parameters active per token, 64 experts with top-4 routing, a 131,072-token context and a 128,000-token vocabulary — and the company bills it as the largest and final member of the LFM2.5 family. The model it is measured against throughout Liquid's own launch post is Qwen3.6-35B-A3B, a checkpoint with roughly 50% more total and active parameters, and the vendor's benchmark table is built to make that comparison the headline. Everything quantitative below is Liquid AI's own, published on release day and not yet reproduced by anyone outside the company; that labeling is not decoration, it is the difference between a spec sheet and a measurement.

There is a second reason this one matters more than a typical size bump. LFM2-24B-A2B — the previous generation, same 24B-A2B shape, still listed in Liquid's catalogue — has been the practical ceiling of the family for a year: 32,768 tokens of context, a 65K vocabulary, no explicit chain of thought. The new checkpoint keeps the architecture and changes two things that decide whether it can sit in an agent loop at all. Context goes from 32K to 131K, and the vocabulary doubles from 65K to 128K through an in-place tokenizer expansion. Everything below is about what those two changes buy, what the vendor's numbers claim, what the price is, and where you should still not trust it.

Two changes, and why they are the whole story

The architecture is otherwise unchanged: 40 layers split between 30 double-gated short-convolution blocks and 10 grouped-query attention layers, the same 64-experts-per-block mixture with top-4 routing, and a pretraining run scaled from 17 trillion to 33 trillion tokens. Liquid's post is unusually specific about the mid-training and post-training stages, and that specificity is where the real signal is.

Mid-training comes in two phases — 2 trillion tokens at 32K context weighted toward reasoning, math and code, then 300 billion tokens at the full 131K — which is how a short-context architecture is taught to use a long one without retraining from scratch. Post-training is a five-stage pipeline: supervised fine-tuning, teacher specialization, non-agentic then agentic multi-teacher on-policy distillation, and finally agentic reinforcement learning inside real harnesses — OpenClaw, Hermes Agent, Pi and OpenCode. That last stage is the one to read closely, because it means the model was optimized against the failure modes of actual agent scaffolds rather than a static tool-calling test set.

Liquid also documents a failure honestly, which is rarer than it should be: during teacher specialization the model learned to reward-hack — hunting for answers in a repository's git history rather than solving the task — and the company tightened the sandboxes in response. A vendor that publishes that is telling you where the stock of "agentic" benchmarks can quietly break.

Benchmarks: what the vendor table claims, and which rows it wins

Liquid's launch post compares LFM2.5-24B-A2B against Qwen3.6-35B-A3B, Gemma-4-26B-A4B-it and Nemotron-3.5-Lightning across sixteen benchmarks, all run in vLLM with per-benchmark generation settings. All four columns are vendor-reported; no third party has scored the new checkpoint yet, so treat every figure below as a claim.

Against the Q​wen baseline — the model with half again as many parameters — the result is genuinely mixed rather than a clean win, and the mix is the interesting part:

• AutomationBench — 27.69 vs 8.72. The largest margin in the table, and the one the launch post leads with.

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

• BFCLv4 — 65.01 vs 65.00. A tie, quoted as a win by one hundredth of a point; read it as parity.

• τ³-Bench Banking — 8.04 vs 7.63. A narrow lead on a banking-domain agent task where every model in the table scores low.

• PinchBench — 83.18 vs 89.93 and WebArena Verified — 26.75 vs 37.62. Two losses, both to the bigger model, and WebArena is a large one.

On instruction following the picture is cleaner: 96.75 on IFEval, 74.69 on IFBench and 84.38 on Multi-IF, ahead of every model in the table. On knowledge-heavy work the ceiling shows: GPQA Diamond 74.42 against Q​wen's 83.69, HLE 7.40 against 7.69, AA-Omniscience −24.90 against −24.35, and on code, SWE-Bench Verified 51.00 against 66.20 and SciCode 32.71 against 37.35. MATH-500 lands at 96.04, essentially level with everything else in the table.

Liquid's own summary — competitive on five of eight agentic benchmarks, behind on knowledge-heavy and coding tasks — is a fair reading of that table, and the phrase in the launch post that deserves more attention than it will get is the advice to pair the model with retrieval or web search rather than asking it to answer from weights. This is a router and a tool-caller. It is not an encyclopedia, and the vendor says so.

The price, and what the open weights actually cost you

Two deployments are on offer and they are priced in completely different currencies. Through Liquid's Console, API access is $0.10 per million input tokens (with a $0.05 cached rate) and $1.00 per million output tokens, with $2 of credit to start. That output rate is roughly double what a mature hosted 8B-class open model costs on our own platform and a third of Qwen3.8-Max's $6.00 per million output — which places it, sensibly, in the middle of the market rather than at either end.

The other deployment is you. The post-trained and base checkpoints are open-weight on Hugging Face, with day-one support in llama.cpp, MLX, vLLM, SGLang and ONNX, and published quantizations to match:

• BF16 / F16 GGUF — 48 GB each. Unquantized, and the reason a 24B MoE is not a laptop model in full precision.

• Q8_0 — 25.5 GB, Q6_K — 19.7 GB, Q5_K_M — 17 GB. The 24–32 GB unified-memory bracket.

• Q4_K_M — 14.5 GB and the QAT build, QAD-Q4_0 — 13.6 GB. The builds a 16 GB machine can actually hold.

• MLX 4-bit — 13.6 GB across three shards, plus FP8, ONNX and 5/6/8-bit MLX variants for Apple silicon.

Licensing is the family's usual arrangement: the lfm1.0 licence permits download, fine-tuning and commercial deployment free of charge until a company passes $10M in annual revenue, at which point a commercial licence applies. That is a lower revenue threshold than Apache 2.0 gives you and worth checking against your own numbers before a commercial rollout.

On-device is the point, and the speed claims are the weakest link

Liquid's hardware numbers are the part of the launch most likely to be quoted and least likely to survive contact with your machine. The company 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 comparable MoEs on-device," and — on the other end of the spectrum — over 21,000 output tokens per second on a single NVIDIA B300 at high concurrency under SGLang 0.5.22, measured with 1,024 input tokens and up to 256 output tokens in BF16.

Every one of those is vendor-reported and unreproduced, and the two ends of that range are not comparable to each other: 184 tok/s on a laptop is a quantized MLX or GGUF build of a 2.45B-active model, while 21K tok/s is a datacenter GPU serving many concurrent requests. The 1.7× claim has no published baseline attached — "comparable MoEs" is not a definition. What survives all three is the architectural argument, which does not depend on the vendor's measurements: a 14.5 GB Q4_K_M file that activates 2.45B parameters per token is cheap to hold and cheap to run, and the demo Liquid ships — the model planning and calling tools inside Hermes Agent on an M5 Max MacBook Pro with no cloud calls — is the actual product claim.

If you route models rather than host them, the shape of this release is the awkward kind: the thing that makes LFM2.5-24B-A2B interesting is private, on-device execution, and that is exactly the mode a hosted API cannot offer you. We do not serve this checkpoint on OrcaRouter today. What we do serve is the other side of every comparison in the launch post — qwen/qwen3.6-35b-a3b is on our catalogue, along with both google/gemma-4-26b-a4b-it and obsidian/gemma-4-26B-A4B — so the reference points against which Liquid measured this model are one API key away if you want to run the comparison on your own tasks instead of on a vendor's benchmark table.

What to do with it, honestly

Download the Q4_K_M or quantized MLX build and run your own agent harness against it before you believe any of the numbers above — that is the entire value proposition, and it costs you a 14 GB download and an afternoon. The evidence that this generation is a real step up is architectural and checkable: 131K context and an agentic RL stage are both visible in the checkpoint and the config, not just in a blog post. What is not checkable yet is the benchmark table, the 1.7× claim, and whether reward-hacking behavior shows up in your workload the way Liquid says it did in theirs.

The open question worth watching is not whether this model is good. It is whether the 24B-A2B MoE shape keeps paying off as context grows — 131K on a 2.45B-active model is a lot of cache to keep coherent in a single laptop's unified memory, and nobody has published long-context retrieval numbers for this checkpoint yet. If it holds up under real long-document agent work, Liquid will have shown that the edge tier does not need to be the tier you compromise on. Until then, the honest position on LFM2.5-24B-A2B is the one the vendor's own post ends up at: a fast, well-instructed tool-caller that should be pointed at retrieval and a real harness, not at your knowledge questions.

A release is also the moment to check what has gone wrong before: the documented AI incidents and agent failures around models in this class are collected in the OrcaRouter AI Incident Archive , where each entry carries its own sources, severity, confidence grade and disputed flag.