LFM2.5-24B-A2B vs Granite 4.2 30B: Sparse Laptop Model or Dense Workstation Model

"Open weights" is doing two different jobs in LFM2.5-24B-A2B and Granite 4.2 30B. Liquid AI's model, announced October 13, 2026, is a 24-billion-parameter mixture-of-experts that wakes 2.45B parameters per token and ships under the vendor's own lfm1.0 licence. IBM's Granite 4.2 30B, published on Hugging Face on August 25, 2026, is a dense decoder-only reasoning model — roughly 29 billion parameters in its BF16 safetensors, every one of them active on every token — and ships under Apache 2.0. One of those licences is a standard Apache grant with no strings. The other is not, and that difference survives every benchmark argument you could have about the two.

The second difference is arithmetic that no eval can hide. A 2.45B-active MoE is sized for a machine you already own. A dense 29B model needs a GPU with the memory to hold it, which makes the comparison less "which is smarter" than "which of these can you actually run on the hardware in front of you."

Where the parameters go

LFM2.5-24B-A2B is 40 layers split between 30 double-gated short-convolution blocks and 10 grouped-query attention layers, with 64 experts per block and top-4 routing. Liquid trained it on 33 trillion tokens by the launch post's count — or 36 trillion by the Hugging Face model card's count for the same release, a discrepancy neither document resolves — then mid-trained in two stages and finished with a five-stage post-training pipeline that ends in agentic reinforcement learning inside real agent harnesses. It has 131,072 tokens of context and a 128,000-token vocabulary.

Granite 4.2 30B is a single dense stack with no routing to do, built on the Granite-4.1-30B-Base checkpoint and trained with three selectable reasoning modes: full thinking wrapped in <think> tags, low-effort thinking, and no thinking at all. It carries a 128K native context with a documented long-context extension to 512K, supports twelve tested languages, and its model card recommends temperature 1.0 with top_p 0.95 across tasks.

The practical consequence is throughput shape, not just throughput. Sparse routing means LFM2.5-24B-A2B reads a 24B-weight file to do 2.45B worth of arithmetic per token — good for memory bandwidth, bad for nothing in particular. Dense means Granite 4.2 30B does the full 29B of work for every token it emits. If your workload is a long agent loop with many short turns, that difference compounds.

Vendor numbers, side by side, with the caveat attached

Nobody has run these two against each other. IBM's figures come from the Granite 4.2 model card; Liquid's come from its launch-day vLLM table, where Granite does not appear as a column. The rows below are therefore two separate vendor claims placed next to each other, not a head-to-head, and two of the four benchmarks use overlapping-but-not-identical harnesses.

• Parameters — 24.0B total with 2.45B active versus ~29B dense, all active. The single number that decides your hardware.

• Context — 131,072 tokens versus 128K native and 512K extended. Roughly level at the native window; Granite goes further if you need it.

• Licence — lfm1.0 versus Apache 2.0. Apache 2.0 has no revenue trigger and no field-of-use question. Read Liquid's terms against your own numbers.

• Agentic tool use — BFCLv4 65.01 versus BFCL v4 61.39. Liquid's number from its own harness; IBM's from the 4.2 card. Close enough that the harness matters more than the gap.

• Coding — SWE-Bench Verified 51.00 versus 57.00. Granite's lead, and it tracks the pattern: LFM2.5-24B-A2B is a tool-caller, Granite 4.2 30B is a reasoner that also calls tools.

• Instruction following — IFEval 96.75 and IFBench 74.69 versus IFBench 77.17. Both strong; the two vendors use different pairs of rows, so compare the shared one.

Where Granite's card adds detail Liquid's does not publish, take it as the reasoner's case: AIME 2025 at 89.17, GPQA at 66.41, LiveCodeBench v6 at 75.77, MMLU-Pro at 77.60, SciCode at 38.76, and RULER at 89.96 for 64K and 81.38 for 128K. That last pair is the kind of long-context evidence LFM2.5-24B-A2B simply does not have yet — Liquid published no retrieval figures at any context length for its 131K window.

What each one costs you to hold

Liquid prices API access at $0.10 per million input tokens — $0.05 cached — and $1.00 per million output tokens on its own Console, with $2 of starting credit. But the hosted endpoint is not really the product; the product is the 24B-A2B file itself, and the vendor's throughput claims are all on-device: 184 tokens per second on an Apple M5 Max and 114 tokens per second on an AMD Ryzen AI Max+ 395. Both are vendor-reported and unreproduced, and independently of whether they hold, the architectural argument does: a 2.45B-active MoE runs on unified memory in a way a dense 29B model does not.

IBM publishes no per-token price on the model card — Granite 4.2 30B is positioned as a self-hosted checkpoint, distributed as BF16 plus FP8, NVFP4/MXFP4 and GGUF quantizations. The all-in cost is the GPU you have to buy or rent to hold roughly 29B of dense weights, and a dense 30B in FP8 wants considerably more memory than a quantized 2.45B-active MoE. On a per-token-served basis the sparse model is cheaper to operate; on a cold-start and worst-case-latency basis the dense model has no routing to warm up. Which of those you care about depends entirely on whether the endpoint is always-on.

If you want to test either without committing to either, both routes exist. Granite 4.2 30B is self-hostable under Apache 2.0 with no revenue ceiling, and the served side of every number above — qwen/qwen3.6-35b-a3b and google/gemma-4-26b-a4b-it among them — sits on our catalogue behind one key at 0% markup on each provider's own list price, so a vendor price change reaches the endpoint the same day it is announced rather than at the next billing cycle.

Which one to pick

Pick LFM2.5-24B-A2B if the machine is the constraint and the workload is tool calls. It wins where harness-shaped work is measured, it holds 131K of context in a footprint a laptop can carry, and Liquid trained it against real agent scaffolds rather than a static test set — a detail that matters more for a router than for a reasoner. Accept two things when you do: the lfm1.0 licence is not Apache 2.0, and nobody outside Liquid has scored this checkpoint yet.

Pick Granite 4.2 30B if you have the hardware, need a model that reasons before it acts, or need the licence to be one your legal team already knows. It leads on coding, it is the only one of the two with published long-context retrieval numbers, and its 512K extension is real documentation rather than a market. Its agentic numbers are thinner — 61.39 on BFCL v4 against Liquid's 65.01 — which is exactly backwards from what the parameter counts would suggest, and a reminder that density buys reasoning, not automatically tool discipline.

The honest summary is that these two are not substitutes. LFM2.5-24B-A2B is built to be the model that runs the loop on a device that has no cloud connection. Granite 4.2 30B is built to be the model that thinks hard about a problem and has the licence to prove it can ship. If you have both, the routing question is which one gets the request — and that is a decision a routing layer exists to make, not a benchmark table.

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