Hugging Face 发布 LFM2.5 系列 DSpark 草稿模型，推理速度最高提升 3.18 倍

Key Highlights

Hugging Face released the DSpark draft-model checkpoints for the LFM2.5 series today, covering three models in total. Using a technique called speculative decoding, these draft models raise high-end GPU throughput by up to 3.18x and on-device throughput by up to 2.87x, all without changing the quality of the output in any way. Even more important is the result in agent scenarios: for LFM2.5-2.6B, the average latency drops by 57% in tool-calling workloads, which are exactly where waiting hurts the user experience the most, and where real-time interaction matters. That combination of higher throughput and lower latency is what makes the release meaningful for production systems rather than only for benchmarks, and for companies that already run agents in production the update is close to plug-and-play. For inference providers, the speedup translates directly into a lower cost per token served, which is a rare case where a free software update beats buying a bigger GPU.

What the release does

A draft model is a small model of about 300M parameters that "writes a draft" first, while the large model verifies it in parallel, so that multiple tokens can be produced at once and the serial waiting of autoregressive generation is reduced. DSpark is a draft-model solution introduced through a collaboration between LiquidAI and Hugging Face, tuned specifically for the LFM2.5 family. It is open-source, and developers can load it directly on llama.cpp and SGLang without changing their existing inference pipeline, which means the original model gets a free speed boost with almost no effort and no need to retrain the main model, so adoption cost stays close to zero. This approach is especially friendly to small and mid-size teams because they do not need their own compute to distill a draft model from scratch. Because the draft model is small, the extra memory footprint it adds is negligible on most servers that already run the main model.

Technical details

The core of speculative decoding is "guess then verify": the draft model produces a candidate token sequence in parallel, and the main model decides at once whether to accept it. Because the draft has only 300M parameters, its computational cost is far lower than that of the main model, so the net gain is clear and measurable. LFM2.5-2.6B benefits the most in tool-calling tasks that involve many turns and long contexts, because each step must wait for the model to emit tokens, and latency has the most direct effect on how the interaction feels to a person, so the speedup is felt most strongly in exactly those agent loops. If the draft model makes a mistake during verification, the main model falls back to autoregressive decoding, which guarantees that the final result is unchanged. The acceptance rate of draft tokens is highest when the task is predictable, which is exactly the pattern in repeated tool-calling sequences.

Comparison with competitors

Compared with approaches that simply throw more compute at the speed problem, DSpark takes the low-cost route of "a small model assisting a large model," and it is fully open-source and framework-agnostic. Other methods such as Medusa and EAGLE also perform speculative decoding, but DSpark is jointly optimized for LFM2.5, so its speedup is more pronounced in on-device and agent scenarios, giving it a better price-to-performance ratio overall and making deployment noticeably easier for teams that already run those runtimes. Within the open-source community, this kind of lightweight acceleration layer is quickly becoming a standard part of how models get deployed in practice. Unlike simply buying a larger GPU, this speedup does not raise the electricity bill or the hardware budget.

Industry impact and use cases

For applications that need to run large models on phones, laptops, and other on-device hardware, a 2.87x throughput means the same silicon can serve far more users at once and do so using less power, which matters when battery and cost are tight. For teams building agents, a 57% drop in latency directly improves how responsive the interaction feels and makes tool calling smoother in practice. Simply put, this is a nearly zero-cost free speedup, and it is available to everyone who wants to use it, which is why it is likely to spread quickly across the open-source ecosystem. For developers who want to squeeze a large model into a consumer app, the release is effectively help at exactly the moment they need it most. Early adopters are expected to fold DSpark into their default serving stacks within weeks rather than months, which should accelerate its spread across the ecosystem.