LFM2.5-8B-A1B-DSpark vs LFM2.5-2.6B-Base: The Speed Part vs the Raw Material

Sort the LFM2.5 family by what each checkpoint can do on its own and LFM2.5-8B-A1B-DSpark and LFM2.5-2.6B-Base land at opposite ends of the line — and neither end can answer a question. The first is a 327.7M-parameter draft model that exists purely to make Liquid AI's edge mixture-of-experts model generate tokens faster. The second is a 2.69B-parameter raw pre-trained checkpoint that exists purely to be fine-tuned into something else. Both shipped in August 2026 under Liquid's LFM Open License v1.0, both are one download away on Hugging Face, and both are extremely easy to grab by mistake — because their names make them sound like two versions of the same thing.

The names are the trap. "DSpark" reads like the family's sparky new flagship, and "Base" reads like the plain default you can actually run. Neither is true. The DSpark checkpoint cannot answer anything on its own — it only proposes tokens for the LFM2.5-8B-A1B to verify. The Base cannot answer anything either, but for the opposite reason — it is an untuned foundation that predicts text but was never post-trained into a chat or agent model. This is not a rivalry; it is a pipeline. One checkpoint sits at the very end of a serving stack, the other at the very beginning of a training run.

Two checkpoints that share a name, not a job

LFM2.5-8B-A1B-DSpark (released August 20, 2026) is a speculative-decoding draft model: a five-layer attention-only network, a block of nine proposed tokens per step, and a Markov head over the target's 128,000-token vocabulary. You load it beside the LFM2.5-8B-A1B — an 8.3B-total, ~1.5B-active MoE that shipped back on May 28 — the draft guesses the next few tokens, and the target verifies the whole block in one forward pass, keeping whatever it accepts. Because the target checks every token, the output under greedy decoding is identical to running the LFM2.5-8B-A1B alone: "lossless by construction," in Liquid's phrase. The draft is a speed part, not a brain. It was released alongside sibling drafts for LFM2.5-1.2B-Instruct and LFM2.5-2.6B, each in Safetensors and GGUF, with day-one support in SGLang and llama.cpp.

LFM2.5-2.6B-Base (released August 4, 2026) is the other end of the pipeline: a 2.69B-parameter foundation in a hybrid 30-layer stack — 22 double-gated short-convolution blocks plus 8 grouped-query attention blocks — pre-trained on roughly 34 trillion tokens, with a mid-training phase that extends context to 128K. It has no chat template, no instruction tuning, and no published benchmarks, and Liquid's own model card recommends it only for extensive fine-tuning. Its whole purpose is to be the raw material that a four-stage post-training pipeline — two SFT rounds, teacher specialization, on-policy distillation, then agentic reinforcement learning — turns into the tool-calling agent LFM2.5-2.6B. Same family, same license, same download page. Different jobs entirely.

Side by side: seven dimensions, two jobs

Because the two checkpoints serve different jobs, the honest comparison keeps both sides' roles straight:

• What it is — LFM2.5-8B-A1B-DSpark is a 0.3B speculative-decoding draft model; LFM2.5-2.6B-Base is a 2.69B raw pre-trained foundation.

• What it runs with — the DSpark draft pairs with the LFM2.5-8B-A1B MoE (8.3B total, ~1.5B active per token); the Base runs on its own, but only as untuned text prediction.

• Standalone use — DSpark produces nothing by itself; it only accelerates a target. Base produces text but no useful product behavior — no instruction following, no tool calling, no chat template.

• Output quality — DSpark inherits the target's exact greedy output, because every proposed token is verified; Base has zero published benchmarks on any task, by design.

• Speed — DSpark adds a vendor-measured mean of 2.54× on an H100 (up to 3.18× on MATH500) and 1.18× on an M4 Max to its target, unreproduced; Base has no inference-speed claim at all.

• Memory footprint — DSpark adds roughly 0.3GB of draft weights beside the target; Base is the full 2.69B, runnable in under 2.5GB, the smallest serious foundation in the family.

• Formats and availability — DSpark ships in Safetensors and GGUF with day-one SGLang and llama.cpp support; Base ships in Safetensors plus GGUF, ONNX, and MLX and runs on Transformers, vLLM, SGLang, llama.cpp, and MLX. Neither is served by any inference provider today — both are self-host checkpoints.

The only numbers in this matchup came from one lab

Everything quantitative here is a single vendor's measurement, taken the day the draft released and not yet independently reproduced — read it as promising, not verified. Liquid measured the LFM2.5-8B-A1B-DSpark at batch size 1, temperature 0, on a single 80GB H100 in BF16 under SGLang and on an M4 Max MacBook Pro in FP16 GGUF under llama.cpp's experimental Metal kernels. On the H100 the pair averaged 2.54× (418 → 1,074 tokens per second), with a best single result of 3.18× on MATH500 (428 → 1,362 tok/s) and an average acceptance of about 7 of 10 proposed tokens. On the M4 Max the same pair averaged just 1.18× (90 → 106 tok/s) — the on-device edge case that Liquid itself flagged, because verifying a block activates more experts in the current MoE Metal backend and moves more weight traffic across the memory bus.

The Base side of this matchup has no numbers at all, and that absence is itself the spec. LFM2.5-2.6B-Base was pre-trained, not post-trained; it was never evaluated for chat, tool use, or agent behavior, because nobody intended it to be used that way. Its meaningful figures are architectural: 2.69B parameters, 128K context, a 16-language tokenizer, under 2.5GB to run. You do not benchmark a foundation; you benchmark what you fine-tune it into.

There is one family irony worth naming before you decide anything. The draft this article is about — the one for the 8B-A1B — is precisely the one that gains least on a laptop (1.18×), while the sibling draft for the 2.6B family, which accelerates the post-trained sibling of this very Base, averages 2.27× on an M4 Max with a 57% cut in multi-tool function-calling latency. If the device in question is a phone or a laptop rather than a GPU box, the 2.6B path is where the speed story lives.

So which one do you download?

You never have to choose between these two directly, because they are not alternatives — but you do have to know which job you are in:

If you serve LFM2.5-8B-A1B on GPUs you own and want more tokens per second from the same silicon, the LFM2.5-8B-A1B-DSpark is a reversible add-on: build SGLang or llama.cpp with the August 20 DSpark integrations, name the draft in the launch command, keep greedy decoding, and the block size is read automatically from the draft's config. The upside is roughly 2.5× throughput with zero change to outputs; the downside is 0.3GB of extra weights and a build new enough to contain the PRs. Remove the two speculative flags and you are back to the plain target.

If you want to build your own specialist — a domain model, a custom-language assistant, a fine-tune on proprietary data — the LFM2.5-2.6B-Base is one of the cheapest serious starting points in the open-weights ecosystem: 2.6B, under 2.5GB, 128K context, a multilingual tokenizer. The DSpark checkpoint cannot help you with that at all, because it is not a base.

If you actually want Liquid's on-device agent — tool calling, multi-step tasks — then you want neither of these two. You want the post-trained LFM2.5-2.6B, and you can decide afterward whether to bolt on its own draft. The Base is raw material for people who want to train; the 8B-A1B draft is a speed part for people who already deploy the MoE. The wrong move is downloading the Base because you wanted a faster agent, or the drafter because you wanted a foundation to train.

Where the two connect — and where a router fits

Both checkpoints are self-host stories. The draft is a serving-layer accessory that only exists inside your own SGLang or llama.cpp stack; the Base is a training artifact. Neither appears in any hosted catalog, and neither has a per-token list price. What that means in practice is that either path ends up sitting beside the hosted models you already call — and that mix is exactly the plumbing a routing layer exists to collapse.

On the serving side, the draft's economics are simple and real: 2.5× more tokens per second from the same GPU is 2.5× less time and roughly 2.5× fewer GPUs for the same workload, with no quality change. But that lever only exists if you own the inference. The moment you call the 8B-A1B through an API, the provider keeps the speedup — which is where the API-side comparison becomes the one that matters: what a provider charges, and whether a price cut reaches you the same day it is announced. That is the point of a pass-through router: one API across 200+ models, provider list prices passed through at 0% markup so a vendor cut is live on your side immediately, and automatic failover so a single provider's latency spike does not become your latency. You can also front your own self-hosted LFM stack through the same endpoint, which is how you try a brand-new draft model against real traffic without betting a production path on it.

LFM2.5-8B-A1B-DSpark and LFM2.5-2.6B-Base share a family name and opposite jobs: one is a speed part bolted to the edge MoE, the other is the untuned brain the 2.6B agent grows from. Neither runs on its own. Choose the drafter to accelerate an MoE you already serve on GPUs, choose the Base to fine-tune a 2.6B foundation into something of your own, and skip both if what you wanted was a working agent — because the one thing both checkpoints have in common is that neither one, by itself, does anything you can use.

FAQ

Can I run LFM2.5-8B-A1B-DSpark by itself?

No. It is a draft model with no standalone output — it proposes candidate tokens that the LFM2.5-8B-A1B target then verifies, so it only exists inside a speculative-decoding serving stack built on the August 20 SGLang or llama.cpp integrations. Downloading it alone gives you nothing you can query.

Is LFM2.5-2.6B-Base the checkpoint that runs on-device as an agent?

Not as-is. The Base is the raw pre-trained foundation with no instruction tuning and no chat template. The model that runs as Liquid's on-device agent is the post-trained LFM2.5-2.6B, which is produced from the Base by the four-stage post-training pipeline — and, if you want it faster, paired with the LFM2.5-2.6B-DSpark draft.