Skip to main content

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

Liquid AI and Hugging Face have just dropped something exciting for developers: the DSpark draft model checkpoints for the LFM2.5 series. This isn't just another incremental update—it's a clever trick that makes AI inference dramatically faster without sacrificing an ounce of quality. Think of it as giving your large language model a turbocharger.

The Big Win: Speed That Actually Matters

So, what's the real-world impact? On a GPU, you're looking at up to 3.18 times higher throughput. On edge devices, the boost is still impressive at 2.87 times. But here's where it gets really interesting: in edge agent scenarios, the function call latency for LFM2.5-2.6B dropped by an average of 57%. That's not just a number—it means running AI agents locally on something like an M4 Max MacBook Pro can hit 139 tokens per second. That's fast enough to make you forget you're not using a cloud service.

How DSpark Pulls This Off

You might be wondering: how does it manage to be so much faster? The secret lies in a technique called speculative decoding. Traditional models are bottlenecked by memory bandwidth—they spend most of their time shuffling weights from DRAM to SRAM. Speculative decoding flips the script: a lightweight draft model quickly generates candidate tokens, and then the big model validates them all at once. It's like having a junior assistant draft responses that a senior editor approves in one go.

DSpark takes this idea and runs with it, combining three clever components:

  • Parallel Backbone Network: Inspired by DFlash, this generates hidden states for all draft tokens in a single pass, based on the target model's context.
  • Sequential Head (Markov Head): This simulates Markov chains between adjacent tokens, boosting the acceptance rate for later positions.
  • Confidence Scheduling Validator: It predicts each token's survival probability and trims low-confidence suffixes when validation costs outweigh savings.

The draft model itself was trained on a diverse mix of data—SFT, chat, code, and function calls. After rigorous ablation tests, they settled on an attention-only architecture with 5 layers and 9 blocks, totaling around 300 million parameters. That's compact enough to run efficiently while still being effective.

Quality? No Compromises

One of the biggest concerns with any optimization is whether it degrades output quality. Here's the reassuring part: because of how speculative decoding works, the draft tokens are only accepted if they perfectly match the target model's distribution. If they don't, the target model's own token takes over. So, the output sequence is identical to what you'd get with greedy decoding. In benchmark tests, there's zero accuracy loss. That's a win-win.

Ready to Use Today

DSpark isn't just a research paper—it's ready for production. On day one, it supports two major inference frameworks:

  • SGLang: You can run it on accelerators with dedicated integration and startup configs.
  • llama.cpp: Official build support lets you load GGUF weights and draft model files via command line.

So, whether you're building edge AI applications or just want faster inference on your local machine, DSpark is worth a look. It's a practical step toward making AI more accessible and responsive, right where you need it.

Key Points

  • Speed Boost: Up to 3.18x faster inference on GPU, 2.87x on edge devices.
  • Latency Reduction: 57% lower function call latency for LFM2.5-2.6B on edge.
  • Quality Preserved: No accuracy loss in benchmarks due to speculative decoding.
  • Ecosystem Ready: Compatible with SGLang and llama.cpp from day one.
  • Architecture: 300M-parameter draft model with parallel backbone, Markov head, and confidence validator.