Skip to main content

LFM2.5 DSpark Draft Model: 3.18x Faster Inference, Same Quality

Liquid AI and Hugging Face just dropped something interesting for anyone running large language models locally. They've released the DSpark draft model checkpoints for the LFM2.5 series—covering the 1.2B, 2.6B, and 8B-A1B variants. The headline number? Inference throughput can jump by up to 3.18 times on GPU, and 2.87 times on edge devices. And here's the kicker: you don't sacrifice an ounce of output quality.

What's the big deal?

If you've ever run a large model on your laptop or a small server, you know the pain: it's slow. Most of the delay comes from memory bandwidth—streaming those massive model weights from DRAM to SRAM takes time. Speculative decoding tackles this by using a lightweight draft model to guess the next tokens, then letting the big model verify them all at once. It's like having a quick assistant draft a reply, and you just approve or tweak it in one go.

DSpark takes this idea and runs with it. In real-world tests, the LFM2.5-2.6B model saw function call latency drop by an average of 57% in edge agent scenarios. On an M4 Max MacBook Pro, it hit 139 tokens per second—fast enough that running AI agents locally feels snappier than some proprietary cloud models. That's a game-changer for developers who want privacy and speed without renting expensive cloud GPUs.

How DSpark works its magic

DSpark isn't a single trick; it's a combination of three clever components:

  • Parallel Backbone Network: Inspired by DFlash, this generates hidden states for all draft tokens in one forward pass, using the target model's context. No more sequential generation for the draft.
  • Sequential Head (Markov Head): This adds dependencies between adjacent tokens, like a Markov chain, which boosts the acceptance rate for later positions. It's like giving the draft model a memory of what it just wrote.
  • Confidence Scheduling Validator: This predicts how likely each token is to survive, and if the validation cost outweighs the savings, it chops off low-confidence suffixes early. Smart budgeting.

Training the draft model wasn't an afterthought. They used a diverse mix of data—SFT, chat, code, and function calls—and after rigorous ablation tests, settled on an attention-only architecture with 5 layers and 9 blocks, totaling around 300 million parameters. Compact but mighty.

Quality? No compromises

One of the biggest worries with any acceleration technique is that you might lose accuracy. But because of how speculative decoding works, the output sequence is identical to what you'd get with greedy decoding. If the draft token doesn't match the target model's distribution, it's replaced. So every benchmark test shows no degradation. You get speed without the usual trade-off.

Ready to use from day one

DSpark isn't just a paper—it's already integrated with major inference frameworks. SGLang supports it on accelerators with dedicated startup configs, and llama.cpp has official build support, letting you load GGUF weights and draft models via command line. That means you can start experimenting right away.

Key Points

  • Speed boost: Up to 3.18x faster inference on GPU, 2.87x on edge devices.
  • Latency cut: 57% average reduction in function call latency for LFM2.5-2.6B on edge.
  • Quality preserved: Output matches greedy decoding exactly, no accuracy loss.
  • Ecosystem ready: Works with SGLang and llama.cpp out of the box.
  • Local AI advantage: On M4 Max, hits 139 tokens/sec, beating some cloud models.

Image