Skip to main content

LFM2.5 DSpark Draft Model Boosts Inference Speed by 3.18x

Liquid AI and Hugging Face have just dropped the DSpark draft models for the LFM2.5 series, and they're making some bold claims about speed. The new checkpoints cover LFM2.5-1.2B-Instruct, LFM2.5-2.6B, and LFM2.5-8B-A1B, and they promise to crank up inference throughput without sacrificing an ounce of output quality.

What's the Big Deal?

In real-world tests, DSpark delivered some eye-popping numbers. On GPUs, overall throughput jumped by as much as 3.18 times. Edge devices weren't far behind, with improvements up to 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 a game-changer for running AI agents locally.

Take the M4Max MacBook Pro, for instance. With DSpark, it can churn out up to 139 tokens per second. That's fast enough to make local deployment feel snappy, and it even rivals some proprietary cloud models in user experience. So, if you've been holding back on running AI agents on your own hardware, this might be the push you need.

How Does DSpark Work?

To understand DSpark, you first need to know why large language models are slow. The bottleneck is usually memory bandwidth—streaming model weights from DRAM to SRAM takes time. Speculative decoding tackles this by using a lightweight draft model to generate candidate tokens quickly, then the target model validates them all in one go. This spreads out the cost of loading weights and speeds things up.

DSpark builds on this idea with three core components:

  • Parallel Backbone Network: Inspired by DFlash, this generates hidden states for all draft tokens in a single forward pass, using the target model's context features.
  • Sequential Head (Markov Head): This simulates Markov chains between adjacent tokens to increase dependencies, which boosts the acceptance rate of later tokens.
  • Confidence Scheduling Validator: It predicts each token's survival probability and automatically cuts off low-confidence suffixes when validation costs outweigh the savings.

Training the draft model was no small feat. The team used a diverse mix of data, including SFT, chat, code, and function calls. After rigorous ablation experiments, they settled on an attention-only architecture with 5 layers and 9 blocks, totaling around 300 million parameters.

Quality and Compatibility

One of the coolest things about speculative decoding is that it doesn't mess with output quality. Under greedy decoding, a draft token is only accepted if it perfectly matches the target model's distribution. If it's rejected, the target model's own token takes its place. So, the output sequence stays identical to what you'd get without DSpark. No accuracy loss, no benchmark dips.

And if you're worried about integration, DSpark hit the ground running. On day one, it's compatible with two major inference frameworks:

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

So, whether you're a developer looking to speed up your local AI experiments or just curious about the latest in AI inference tech, DSpark is worth a look. It's a solid step toward making high-performance AI more accessible, right on your own machine.

Key Points

  • DSpark draft models for LFM2.5 series are now available from Liquid AI and Hugging Face.
  • Inference speed boosts: up to 3.18x on GPU, 2.87x on edge devices.
  • Function call latency reduced by 57% on edge, with 139 tokens/sec on M4Max MacBook Pro.
  • Uses speculative decoding with parallel backbone, Markov head, and confidence scheduling.
  • No quality loss; compatible with SGLang and llama.cpp from day one.