On June 27, 2026, DeepSeek, in collaboration with Peking University, released and open-sourced the DSpark inference acceleration framework. The framework employs a semi-autoregressive generation architecture to address the parallel draft suffix decay problem, combined with a confidence-based dynamic scheduling mechanism to optimize verification efficiency. On the DeepSeek-V4-Pro-DSpark and DeepSeek-V4-Flash-DSpark models, single-user generation speed increased by 60% to 85%. Simultaneously open-sourced, the DeepSpec full-stack training toolchain significantly lowers the barrier to inference optimization, enabling small and medium-sized developers to deliver low-cost, high-speed large model inference services.

Author and source: Leiphone

On June 27, 2026, the AI community received a major announcement: DeepSeek, in collaboration with Peking University, officially launched the DSpark inference acceleration framework and simultaneously open-sourced the full-stack speculative decoding framework DeepSpec that supports this version. This marks DeepSeek’s first open-source release following its $50 billion funding round. On the DeepSeek-V4-Pro-DSpark and DeepSeek-V4-Flash-DSpark models, DSpark increases single-user generation speed by 60% to 85%. The paper titled “DSpark: Confidence-Scheduled Speculative Decoding with Semi-Autoregressive Generation,” authored and co-signed by Liang Wenheng in collaboration with Peking University, was also uploaded.

The paper, codebase, and model have all been open-sourced:

Paper:

https://github.com/deepseek-ai/DeepSpec/blob/main/DSpark_paper.pdf

Open-source code repository:

https://github.com/deepseek-ai/DeepSpec

Model download: https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro-DSpark

01 How DSpark Makes Draft Models Fast and Accurate

Let’s clarify a common misconception: DeepSeek-V4-Pro-DSpark is not a model with a completely new architecture; rather, it introduces a speculative decoding module based on DeepSeek-V4-Pro. This update focuses on engineering implementation, not on enhancing the model’s core capabilities.

In simple terms: the model is the same, but the way it’s run has become smarter, so you’ll notice it’s significantly faster.

To understand the value of DSpark, you first need to understand what problem it’s solving.

Large language models generate text autoregressively: each new token requires a full forward pass, causing inference latency to increase linearly with output length. This is one of the primary reasons why current AI dialogue systems respond slowly.

Speculative decoding offers a solution pathway:

First, use a lightweight small model to quickly generate several candidate tokens (draft model).

Step two: Use the full-scale model to perform batch validation of these tokens through a single parallel forward pass.

Step three: Accept the continuous prefixes that match the target distribution.

Since the verification phase can be computed in parallel and the rejection sampling mechanism strictly ensures that the output distribution matches the original model, speculative decoding can enhance speed without compromising generation quality.

This concept was not invented by DSpark; it has been actively pursued by others over the past two years. However, this time, DeepSeek has precisely addressed the two critical bottlenecks encountered in the practical implementation of this technical approach.

Early draft models were autoregressive, meaning they guessed one token at a time, just like large models. While this approach yields high-quality results, smaller models also take time to guess each token—and as the number of guesses increases, the draft process itself becomes slower, making it counterproductive.

For example: If you ask an AI to write a 500-word response, it must perform 500 complete calculations, outputting only one character at a time. Even if each calculation takes just 10 milliseconds, the total time adds up to 5 seconds. What the user experiences is simply “spinning wait.”

Later, someone came up with the idea of parallel drafts, allowing multiple characters to be guessed in a single forward pass, significantly speeding up the draft process. But a new problem arose: since each position was guessed independently, the dependencies between characters were not taken into account.

"Of course" and "no problem" are both reasonable ways to begin a response, but a parallel draft might guess combinations like "of problem"—a hybrid that doesn't make sense. The further the prediction proceeds, the more these errors accumulate, causing a sharp drop in acceptance rates. This phenomenon is called "suffix decay."

The traditional approach was to submit the exact same number of tokens generated by the draft model to the large model for verification—a “full verification” mode. However, since tokens generated later are increasingly unreliable, verifying these low-confidence tokens consumes unnecessary computational resources.

Sending low-confidence tokens for verification may seem like only a minor waste of computational power, but in real-world, high-concurrency production systems, this waste represents catastrophic systemic loss.

To address these two major issues, DSpark employs two core designs: a semi-autoregressive generation architecture and confidence-scheduled verification.

The semi-autoregressive generation architecture is highly innovative, primarily addressing the suffix decay problem in parallel drafts. This two-stage design, combining a parallel backbone with a lightweight sequential head, compensates for token dependencies within blocks without significantly sacrificing generation speed, directly increasing the effective acceptance length per verification round.

The parallel backbone can output the full block's base logits and hidden states in a single forward pass, achieving the same core latency as a purely parallel approach while fully preserving the speed advantages of parallel architectures—larger block sizes and faster generation.

The lightweight serial module is key to addressing this limitation. Building on parallel output, DSpark adds a minimal serial unit (defaulting to a Markov head) that introduces prefix-dependent transition biases for each token position, correcting multimodal semantic conflicts caused by parallel independent generation and significantly alleviating the decline in tail token acceptance rates.

From a throughput perspective, this design offers extremely high efficiency: the serial module incurs minimal overhead while increasing the average acceptance length of the Qwen3 series models by 16.3%–18.4% compared to DFlash and by 26.7%–30.9% compared to autoregressive Eagle3.

DSpark with a depth of 2 achieves an effective acceptance length even greater than that of a purely parallel DFlash with a depth of 5, demonstrating that local autoregressive speed-parameter efficiency far exceeds that of simply stacking parallel layers.

This advantage further amplifies with increased block length: as the draft block length increases from 7 to 15, DSpark’s acceptance length advantage over DFlash grows from 15%–18% to 22%–30%. In other words, the speed potential of parallel architectures for long blocks, previously constrained by suffix decay, has been fully unlocked by the semi-autoregressive design.

If semi-autoregressive decoding solves "more efficient generation," then confidence scheduling solves "smarter verification." It eliminates invalid tokens at the source, preventing them from consuming precious verification compute resources and ensuring that every forward pass of the large model delivers maximum value—especially stabilizing generation speed under high-concurrency scenarios.

The first layer is confidence prediction. DSpark adds a lightweight scoring module (Confidence Head) to the draft model, which continuously predicts the conditional acceptance probability of each candidate token as it is generated.

However, AI scoring is inherently prone to overconfidence, often yielding overly optimistic pass rates. To address this, DSpark incorporates a calibration method called "Sequential Temperature Scaling (STS)," reducing the scoring error for drafts from the original 3%-8% to approximately 1%, making probability estimates sufficiently accurate to provide reliable basis for subsequent scheduling adjustments.

Layer two is hardware-aware dynamic scheduling. Based on pre-tested engine throughput curves, this approach transforms the selection of verification length into a global throughput maximization problem, using a greedy algorithm to dynamically allocate verification budgets for each request: during low load, it automatically extends verification blocks to fully utilize idle computing power and maximize single-user generation speed; during high load, it proactively trims low-value tokens to avoid resource contention and maintain overall system throughput and perceived user speed.

02 Verify! Inference speed surges across all scenarios.

The true impact of acceleration technology must be verified through real-world testing.

First is the offline benchmark evaluation. The team selected nine general datasets across three domains—mathematical reasoning, code generation, and everyday dialogue—and conducted a horizontal comparison on four target models: Qwen3-4B/8B/14B and Gemma4-12B. The results show that DSpark’s average acceptance length comprehensively surpasses the current industry SOTA solutions, with its per-token theoretical latency significantly lower than that of Eagle3 and DFlash.

The test data also reveals clear domain differences: structured tasks such as mathematics and coding exhibit significantly higher acceptance lengths, while open-ended dialogue scenarios have relatively lower acceptance lengths. This disparity highlights the inherent limitations of fixed validation lengths—different types of requests inherently require different optimal validation block sizes, and a dynamic scheduling strategy enables each request type to achieve its optimal acceleration benefit.

The performance of real online traffic best reflects users' actual experience. DSpark has now been fully deployed on the DeepSeek-V4 online service, delivering substantial improvements in speed, service capacity, and stability compared to the previous MTP-1 single-token production baseline:

Absolute speed improvement at the same throughput: Under configurations with identical system throughput, V4-Flash increases single-user generation speed by 60%–85%, while V4-Pro increases it by 57%–78%. Users directly experience faster response times and significantly reduced waiting periods for long-form content generation.

Capacity scaling under high SLA: Under stringent interactivity requirements (e.g., Flash requires 120 tokens/s, Pro requires 50 tokens/s), the traditional single-token baseline has approached its performance limit and can only support extremely low concurrency, whereas DSpark continues to maintain substantial service capacity, enabling previously unattainable high-speed response tiers and shifting the performance Pareto frontier of inference services outward.

Stable performance under full load: The dynamic scheduler automatically adjusts verification budgets based on concurrent pressure—maximizing computing power and speed during low concurrency, and smoothly scaling down during high concurrency to prevent performance drops. Unlike traditional static solutions, there are no sudden speed reductions, significantly improving user experience consistency.

In summary, DSpark overcomes the traditional limitation of binary decoding assumptions by using a semi-autoregressive architecture to improve the accuracy of parallel draft tails, and addresses computational waste in full verification through dynamic confidence-based scheduling, achieving end-to-end optimization of draft generation and online verification.

Notably, the team has also open-sourced the DeepSpec full-stack training toolkit, making this lossless inference acceleration solution publicly available. In the past, small and medium-sized developers and lightweight applications struggled to achieve high-speed large model inference at low cost. With DSpark, the barrier to inference optimization has been significantly lowered through high cost-effectiveness, turning the phrase “every small app can use a large model” from a slogan into an emerging industry reality.