LFM2.5-24B-A2B vs LFM2.5-8B-A1B-DSpark: One of These Is Not a Model You Can Run

Put LFM2.5-24B-A2B and LFM2.5-8B-A1B-DSpark in a comparison table and the table is a lie before you fill in a single cell. Liquid AI's LFM2.5-24B-A2B, released October 13, 2026, is a language model: 24.0B parameters, 2.45B active per token, 131,072 tokens of context, and it answers prompts. LFM2.5-8B-A1B-DSpark, released August 20, 2026, is a 327.7-million-parameter draft checkpoint that cannot answer anything on its own — it exists to guess the next tokens for a different model, LFM2.5-8B-A1B, and be checked by it. Confusing the two is the single most common way this release gets misread, and it is worth clearing up in the first paragraph because the rest of this page depends on it: one of these has a price per million tokens and a Hugging Face card you can point an agent at, and the other lives inside someone else's inference stack.

What makes the pairing genuinely worth a page, though, is that it is the comparison Liquid AI has set up for itself. The LFM2.5-24B-A2B model card lists a DSpark speculative-decoding draft for the 24B as coming soon. When it lands, the exact question this page answers will be the one people ask about it — does the draft trick that made the 8B model up to 3.18× faster on a data-center GPU actually pay off on a 24B model whose whole reason for existing is a laptop? The 8B numbers already contain the answer's shape, and it is not the shape the headline suggests.

What a draft checkpoint actually is, in three sentences

Speculative decoding puts a cheap model in front of an expensive one: the drafter proposes a block of candidate tokens, the real model verifies the whole block in a single forward pass, and it keeps whatever it agrees with. Because the target checks every proposed token, the output under greedy decoding is bit-identical to running the target alone — Liquid's phrase is "lossless by construction," and it is why a draft is safe to bolt onto a production stack. LFM2.5-8B-A1B-DSpark is a deliberately small drafter: five attention-only layers, a block of nine proposed tokens per step, and a Markov head over the target's 128,000-token vocabulary, trained for 15 epochs on chat, code and function-calling data with checkpoints picked by acceptance rate rather than validation loss.

That last detail is not trivia. Liquid's own write-up notes that for the larger drafts, validation loss "keeps improving after the benchmark acceptance we care about has stopped moving" — which is the kind of sentence that only appears when a team is shipping this into serving rather than publishing a paper.

The two stacks, one line per dimension

• What it is — LFM2.5-24B-A2B is a deployable reasoning model, text in and text out. LFM2.5-8B-A1B-DSpark is a speculative-decoding accelerator and nothing else.

• Size — 24.0B total / 2.45B active per token, 64 experts with top-4 routing across 40 layers, versus 327.7M draft parameters in five attention-only layers.

• Context — 131,072 tokens for the 24B, doubled from the previous generation; the draft has no context of its own, since it operates on the target's stream.

• Reasoning — the 24B always emits an explicit chain of thought inside a <think> block. The draft emits nothing a user ever sees.

• Price — $0.10 per million input tokens ($0.05 cached) and $1.00 per million output on Liquid's Console, with $2 of starting credit, for the 24B. The draft has no price because no inference provider serves it.

• Licence — lfm1.0 for both: free to download, fine-tune and deploy commercially until a company passes $10M in annual revenue, at which point a commercial licence applies.

• Published formats — GGUF from Q4_K_M at 14.5 GB through 48 GB BF16, a QAT QAD-Q4_0 at 13.6 GB, FP8, ONNX and 4/5/6/8-bit MLX for the 24B; Safetensors and GGUF for the draft, with day-one SGLang and llama.cpp support.

The dimension that decides everything is the last one modified by the fifth: one of these has a per-token price, and the other is something you install to make a self-hosted model cheaper per token. They never compete. They stack.

The numbers that matter, and the one that should worry you

Liquid measured the DSpark draft at batch size 1 and temperature 0 across five datasets — on an 80GB H100 in BF16 under SGLang, and on an M4 Max MacBook Pro in FP16 GGUF under llama.cpp with experimental Metal kernels. Every speedup is against the same target model running alone on the same hardware. All of it is vendor-reported and, three months on, still unreproduced.

On the H100, against LFM2.5-8B-A1B:

• MATH500 — 3.18× (428 → 1,362 tokens/s, acceptance 8.27) — the headline number.

• MT-Bench — 3.02× (426 → 1,288 tokens/s, acceptance 8.52).

• MBPP — 2.64× (426 → 1,122) and HumanEval — 2.58× (426 → 1,100).

• GSM8K — 1.29× (385 → 496, acceptance 4.02) — the weak case, and note it is the one where the target was already faster to begin with.

• Mean — 2.54× (418 → 1,074 tokens/s).

On the M4 Max, the same draft against the same target is a different product: MATH500 1.21× (93 → 112), GSM8K 1.44× (90 → 129), HumanEval 1.12× (91 → 101), MBPP 1.09× (89 → 97), MT-Bench 1.04× (87 → 90), mean 1.18× (90 → 106).

Read those two lists together and the conclusion is unavoidable: the draft checkpoint accelerates the hardware the model was not built for, and barely moves the hardware it was. That is not a bug in Liquid's implementation, it is where the bottleneck sits — speculative decoding pays off when you are compute-idle and memory-starved, and an M4 Max running a quantized 1.5B-active MoE is already close to its memory bandwidth ceiling. Liquid published the bad half of the result themselves, which is why the 3.18× figure has been quoted on its own far more often than the 1.18× that most of their readers would actually experience.

Why the 24B pairing is a genuinely open question

Everything about the coming LFM2.5-24B-A2B draft is unannounced beyond the words "coming soon" on the model card, so what follows is reasoning about the shape of the problem rather than a report.

The draft's value is governed by acceptance rate, and acceptance rate is governed by how predictable the target is. A reasoning model that always produces an explicit chain of thought — LFM2.5-24B-A2B is exactly that, and Liquid ships it with a recommended temperature of 0.1 — emits long, locally predictable stretches of text. That is the ideal soil for a 9-token block. So the ceiling on a 24B draft could be high, and the card's own vocabulary note helps: the 24B uses the same 128,000-token vocabulary the 8B drafter's Markov head was built over, so the draft head does not need to be rebuilt from a different token space.

The counterweight is the hardware. The 24B model's stated edge result is 184 tokens per second on an Apple M5 Max, and a bigger target means a bigger verification pass even when the block is accepted whole. If the 8B pattern holds — big wins where you have spare compute, small wins on the laptop — the 24B draft may turn out to be a datacenter tool attached to an edge model, which is a strange shape for a product. Anyone quoting "3.18×" in anticipation of it is quoting a number measured on a different model, on different hardware, with a different draft.

Cost, and the case for not self-hosting at all

One honest complication: DSpark's whole value proposition is throughput per self-hosted token, so its economic case is per-token cost of your own GPU time. The 24B model, by contrast, has a public price — $0.10 per million input tokens ($0.05 cached) and $1.00 per million output — which is what you pay if you would rather not run a 14.5 GB quantized checkpoint on your own laptop at all.

To be clear about what we do and do not offer: we do not serve LFM2.5-24B-A2B or LFM2.5-8B-A1B-DSpark on OrcaRouter. What we do serve are the open-weight models this decision keeps running into — qwen/qwen3.6-35b-a3b, the model Liquid benchmarks its 24B against at roughly fifty percent more total and active parameters, plus google/gemma-4-26b-a4b-it, obsidian/gemma-4-26B-A4B and google/gemma-4-31b-it in the same sparse-open class. If you are weighing a 14 GB download and a speculative-decoding stack against calling a served model behind one key at 0% markup on the provider's list price, that is a comparison you can run this afternoon on our side and can only estimate on theirs.

What to do with the two of them today

If you want a model to call, the answer is LFM2.5-24B-A2B and the DSpark checkpoint is irrelevant to you — it accelerates one specific 8B model, and there is no third-party platform serving either. If you already self-host LFM2.5-8B-A1B on a GPU, the draft is a free throughput multiplier that changes nothing about your outputs, and 2.54× as a mean is a real serving cost reduction. If you self-host it on a Mac, the mean is 1.18× and the honest reading is that the draft is worth about a tenth of what the launch headline implies.

The thing to watch is not the 24B draft's arrival date, which nobody has published. It is which of the two regimes it lands in. If Liquid publishes a mean above 2× on Apple silicon, speculative decoding has crossed a line and the edge tier becomes genuinely cheaper to run. If it publishes a peak number with no laptop mean, the 8B result will have been the answer all along: this technique pays where you have idle compute, and a machine that runs a 24B mixture of experts on battery does not have any to spare.

Comparisons like this one are also where the failure modes show up: the documented AI incidents and agent failures behind 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.