DEER: Draft with Diffusion, Verify with Autoregressive Models

🎯 Pitch

Diffusion language models as drafters can achieve acceptance lengths of up to 32 tokens and 5.54× speedups—dwarfing the ~10 tokens and 2.41× of leading AR-based drafters. By generating entire draft blocks in parallel, they bypass the sequential uncertainty accumulation that causes autoregressive drafters to drift away from the target model’s distribution.

1. Executive Summary

This paper introduces DEER, a speculative decoding framework that replaces standard autoregressive drafters with a discrete-space diffusion large language model (dLLM) to generate draft-token blocks in a single parallel step, thereby eliminating the left-to-right uncertainty accumulation—termed gradual collapse of trust—that limits acceptance lengths in prior methods. To adapt dLLMs from global denoising to prefix-conditioned continuation, the authors propose a Diffusion-to-AR (D2A) Alignment two-stage training pipeline (AR-style continuation distillation followed by a weighted scribe refinement stage that emphasizes token-level accuracy near the prefix boundary). Across code-generation benchmarks (HumanEval, MBPP, LiveCodeBench, CodeAlpacaPy) with Qwen3 models ranging from 4B to 30B parameters, DEER achieves draft acceptance lengths of up to 32 tokens—far exceeding the 7–8 tokens typical of EAGLE-3—and delivers up to 5.54× speedup on HumanEval with Qwen3-30B-A3B compared to 2.41× for EAGLE-3, establishing that diffusion-based block drafting can substantially outperform autoregressive drafters specifically when verified by a stronger target model whose output determinism enables the dLLM to fit token patterns more effectively at larger scales.

2. Context and Motivation

The Fundamental Tension in LLM Decoding: Quality vs. Speed

The paper addresses a tension that has become increasingly acute as large language models (LLMs) are deployed for complex, multi-turn reasoning and agentic tasks: autoregressive (AR) decoding is inherently sequential, making it the dominant bottleneck in inference latency. Each token must be generated conditioned on all previously generated tokens, and while a single forward pass through a modern transformer is fast, generating hundreds or thousands of tokens sequentially imposes a hard lower bound on response time that cannot be overcome by hardware improvements alone. This latency is not merely an inconvenience—it fundamentally constrains which applications are viable. Real-time coding assistants, interactive agents that must make decisions within tight time windows, and high-throughput production systems all hit practical limits when the model generates tokens one at a time.

What makes this problem particularly pressing is the asymmetric scaling of model capability and inference cost. As model sizes grow and context windows extend to handle increasingly complex reasoning traces, the per-token computational cost increases, yet the fundamental sequential dependency remains. A model that is twice as smart but also takes twice as long to decode may provide no net benefit in latency-sensitive applications. This is the core economic challenge the paper tackles: how to reduce the wall-clock time of AR decoding without sacrificing output quality or requiring expensive model retraining.

Speculative Decoding: The Promise and the Structural Bottleneck

The established solution to this problem is speculative decoding (Leviathan et al., 2023; Chen et al., 2023). The idea is elegant in its simplicity: use a lightweight, fast drafter model to propose multiple candidate tokens in parallel, then let the larger, more accurate target (verifier) model check them in a single forward pass, accepting those that match its own distribution and rejecting the rest. Because the verifier's forward pass processes all proposed tokens in parallel (it computes attention over the full prefix-plus-draft sequence), the cost per accepted token drops substantially—provided the drafter is aligned well enough with the target that most proposals are accepted.

This draft–verify framework is provably lossless: under appropriate acceptance criteria (rejection sampling with the correct residual distribution), the output distribution is mathematically identical to what the target model would produce on its own (Leviathan et al., 2023; see also Appendix E of the present paper for the formal proof). This means speculative decoding offers a rare guarantee in LLM optimization—you get acceleration without any degradation in quality. The only question is how much acceleration, which depends entirely on the acceptance length (the number of draft tokens the verifier approves per cycle) and the relative cost of the drafter compared to the target.

The paper identifies a fundamental structural limitation that has prevented existing speculative decoding methods from realizing the full theoretical potential of this framework. Understanding this limitation requires a closer look at how drafters operate in current methods.

The Two Structural Problems with Autoregressive Drafters

Existing speculative decoding methods overwhelmingly use autoregressive drafters—smaller AR models (Leviathan et al., 2023), or lightweight prediction heads attached to the target model's hidden states that generate draft tokens left-to-right (Medusa, Cai et al. 2024; Hydra, Ankner et al. 2024; the EAGLE series, Li et al. 2024a,b, 2025b). The paper argues that AR drafters impose two structural limitations that together create a hard ceiling on achievable speedups.

Problem 1: Gradual Collapse of Trust. This is the paper's central concept and the phenomenon it is explicitly designed to overcome. In classical speculative decoding, each draft token is conditioned on previously drafted tokens that have not yet been verified by the target model. The drafter's distribution at position $i$ is:

$q_{\text{AR}}(\hat{y}_i \mid x_{1:j}, \hat{y}_{1:i-1})$

where $x_{1:j}$ is the verified prefix and $\hat{y}_{1:i-1}$ are the previous (unverified) draft tokens. Even if the drafter is well-aligned with the target model when conditioned on ground-truth prefixes, the distribution shifts once it conditions on its own outputs. Any discrepancy between the drafter and target at early positions—however small—is recursively amplified through the chain of conditional dependencies. As the draft depth increases, the drafter's trajectory progressively drifts outside the acceptance region of the target model, causing verification failures to compound.

The paper visualizes this concept in Figure 2 (left panel), contrasting the AR drafter's dependence-based generation (where each token feeds into the next) with the proposed independence-based approach (where all tokens are generated jointly from the verified prefix). The practical consequence is severe: even sophisticated AR drafters like EAGLE-3 see acceptance lengths plateau at roughly 7–8 tokens (Table 4), and acceptance rates drop sharply with draft depth. The authors argue this is not a training issue—it is an architectural inevitability of left-to-right decoding. No amount of AR drafter fine-tuning can eliminate the fundamental fact that early errors cascade forward.

Problem 2: Inherently Sequential Decoding. Even setting aside the uncertainty accumulation issue, AR drafters themselves must decode sequentially—the drafter generates tokens one at a time, waiting for each to complete before starting the next. This means the drafter itself cannot exploit parallel generation. While the drafter is typically much smaller than the target (hundreds of millions vs. billions of parameters), its sequential nature still imposes a non-trivial latency floor, especially for longer proposed blocks. The cost of generating a $k$ -token draft with an AR drafter scales linearly with $k$ , and this cost must be paid before verification begins. In contrast, a drafter that could generate all $k$ tokens in parallel would decouple draft generation time from draft length, enabling much more aggressive drafting.

Together, these two problems create a compound bottleneck: the AR drafter (1) cannot propose long drafts because acceptance collapses with depth, and (2) even if it could, the sequential cost of generating those drafts would eat into the speedup. The paper's key insight is that both problems share the same root cause—left-to-right dependency in the draft generation process—and can therefore be solved by the same architectural intervention: replacing AR drafters with a model that generates tokens jointly.

Where Existing Methods Fall Short

The paper situates DEER within a rich landscape of prior work, identifying specific failure modes that motivate the shift to diffusion-based drafting.

AR-based drafters (Medusa, Hydra, EAGLE series). These methods achieve impressive speedups by attaching lightweight prediction heads to intermediate representations of the target model or by training small auxiliary AR models. Their core limitation, as discussed, is sequential token generation with cascading uncertainty. Even the most advanced variant, EAGLE-3 (which uses training-time test-time augmentation to improve alignment), tops out at acceptance lengths of 7–8 tokens (Table 4) and speedups of approximately 2.4× on Qwen3-30B-A3B (Table 2, temperature=0). The paper does not argue that these methods are poorly executed—rather, they are fundamentally bounded by the AR draft paradigm itself.

N-gram and heuristic drafting (Lookahead, DiffuSpec). Methods like Lookahead (Fu et al., 2024) and DiffuSpec (Li et al., 2025a) avoid training a separate model entirely by constructing drafts through n-gram matching or retrieval from previously generated tokens. While computationally cheap, these approaches lack global context awareness—they cannot model long-range dependencies in the target distribution, leading to low acceptance rates on complex sequences where local token patterns are insufficient to predict the continuation. The paper argues that this local-only modeling limits their applicability to tasks requiring coherent generation over extended spans, such as code generation with nested control flow or mathematical reasoning with multi-step derivations.

Continuous-space diffusion drafting (Speculative Diffusion Decoding, SDD). Christopher et al. (2025) first proposed using dLLMs as drafters, making SDD the closest prior work to DEER. However, SDD operates in continuous embedding space with multi-step denoising, which introduces two critical limitations that DEER explicitly addresses. First, continuous-space diffusion loses precise control over the sampling temperature—the denoising process operates on continuous vectors that are discretized only at the final step, making it difficult to match the target AR model's discrete token distribution at arbitrary temperature settings. Second, the multi-step denoising process introduces its own form of sequential drift: each denoising step moves the latent representation, and accumulated discretization errors across steps can pull the draft away from the target distribution. The paper positions DEER as a more principled alternative by operating in discrete token space with a single-step generation process, ensuring that the draft proposal distribution can be matched exactly to the target's discrete distribution through the D2A alignment training.

Hybrid AR-diffusion architectures (TiDAR). Liu et al. (2025) proposed retraining the target AR model itself to perform diffusion-style generation jointly with AR decoding. While this unifies drafting and verification into a single model (avoiding the need for a separate drafter), the paper identifies significant drawbacks. Training with dual objectives (AR next-token prediction + diffusion denoising) is computationally expensive and introduces optimization conflicts that can degrade the target model's core capabilities. The paper's modular approach—a dedicated, lightweight dLLM drafter aligned to the frozen target—avoids these conflicts entirely while preserving the target model's original performance.

Intermediate-state self-drafting (SSDD, SSMD). Gao et al. (2025) and Campbell et al. (2025) explored using the model's own intermediate noisy states or self-generated diffusion logits to form drafts, removing the need for a separate drafter model. However, these intermediate representations are inherently noisy and not directly optimized for alignment with the final AR distribution. The paper argues that DEER's approach—using a fully denoised, alignment-tuned output distribution—produces cleaner and more stable proposals than working with intermediate states that were never intended to serve as the final prediction target.

The Diffusion Model Opportunity

The paper's central motivating insight is that diffusion language models (dLLMs) naturally overcome both structural limitations of AR drafters. Unlike AR models, which sample tokens conditionally from left to right, diffusion models generate the entire sequence jointly through an iterative denoising process. In the discrete-space formulation that DEER adopts (building on D3PM, Austin et al. 2021a; Diffusion-LM, Li et al. 2022; and scaled variants like LLADA, Nie et al. 2025 and Dream, Ye et al. 2025), tokens are not generated in a sequential order—instead, a fully masked sequence is progressively unmasked, with the model attending to the complete sequence context at each step.

Crucially, after alignment training, DEER uses single-step decoding: the dLLM observes a prefix with a masked suffix and predicts all masked tokens in one forward pass. This means:

Uncertainty accumulation is eliminated: The proposal at token position $i$ is conditioned only on the verified prefix, not on previously drafted (potentially erroneous) tokens. The drafter's distribution is $q_\theta(\hat{y}_i \mid x_{1:j})$ , independent of other draft tokens. Even if the drafter's marginal prediction at position $i$ is imperfect, that imperfection does not contaminate predictions at positions $i+1, i+2, \ldots$ as it would in an AR drafter. Each draft token's error is localized to that position rather than propagating forward.
Generation is trivially parallelizable: All $k$ draft tokens are generated in a single forward pass of the dLLM, regardless of $k$ . The cost of drafting does not scale with draft length, removing the second structural bottleneck. The verifier then checks all $k$ tokens in its own parallel forward pass—the entire draft–verify cycle processes a block of arbitrary length with constant drafting cost (plus the verifier's one forward pass).

However, this opportunity comes with a significant challenge that the paper must solve: standard dLLMs are not trained for prefix-conditioned continuation. A typical dLLM is trained with full-sentence denoising, where it observes partially masked versions of complete sequences and learns to recover the original tokens. In this setting, the model can implicitly rely on future tokens that happen to be unmasked in the current noise configuration—it learns a joint reconstruction objective, not a causal continuation one. If you simply give a pre-trained dLLM a prefix and ask it to generate a suffix, its denoising process still relies on an internal prior that assumes bidirectional context, causing a distribution mismatch between the draft proposals and the target AR model's causal predictions. The paper's D2A alignment pipeline (Section 3.1) is entirely motivated by the need to bridge this gap, transforming the dLLM from a joint denoiser into a prefix-conditioned continuation model that produces drafts aligned with the AR target's distribution.

How This Paper Positions Itself

The paper frames DEER as the first speculative decoding framework that uses a discrete-space dLLM as the sole drafter, without requiring auxiliary AR models, hybrid architectures, or multi-step denoising. The contribution is not merely replacing one drafter architecture with another—it is changing the generative mechanism of drafting itself from sequential dependence to parallel independence, thereby addressing the fundamental root cause (left-to-right error propagation) of the acceptance-length ceiling that limits all prior methods.

The paper explicitly connects this architectural shift to a practical insight that emerges from the experiments: larger target models benefit more from DEER because their output distributions are more deterministic, enabling the dLLM to fit token patterns more precisely. Figure 8 (Appendix B.2) shows that moving from Qwen3-8B to Qwen3-30B-A3B increases average acceptance length by 14–33% across block sizes, and the paper attributes this to "stronger output determinism in larger base models." This is a non-obvious prediction of the approach: AR drafters see diminishing returns with larger targets because their sequential error accumulation is independent of the target's determinism, while diffusion drafters directly convert the target's higher predictability into longer accepted blocks.

The paper also positions itself as modular and non-invasive: the target AR model is never modified or retrained—it is treated as a frozen verifier (Section 2.2). The dLLM drafter is trained separately with a lightweight two-stage procedure (240 GPU hours on Qwen3-8B, compared to 696–1800 GPU hours for competing methods; Table 8, Appendix D). This modularity means DEER can be applied to any existing AR model without risking degradation of its capabilities, which is a practical advantage over hybrid training approaches like TiDAR that modify the target model itself.

Finally, the paper introduces a novel capability it terms reliable block regeneration (Section 4.5, Figure 5): the dLLM-trained-with-DEER can incrementally extend partial code blocks from local prefixes in a diffusion-style manner, accepting partially masked suffixes and regenerating them coherently across multiple iterations. This emergent behavior is presented as evidence that the alignment pipeline does more than simply make the dLLM a good drafter—it endows it with a genuinely new generation mode that operates at the block level rather than the token level, suggesting applications beyond speculative decoding (though these are not explored in this paper).

3. Technical Approach

3.1 Reader orientation (approachable technical breakdown)

DEER is a speculative decoding system that uses a small, fast diffusion language model to guess multiple future tokens at once, then has the main large language model check those guesses—accepting correct ones and rejecting incorrect ones—all without changing the large model or sacrificing output quality. The system solves the problem that existing guessers (called drafters) generate tokens one at a time from left to right, which causes early small errors to snowball into large mismatches with the main model, sharply limiting how many tokens can be guessed correctly in each cycle. The "shape" of the solution is elegantly simple: replace the sequential drafter with a parallel one that generates all guessed tokens simultaneously from the verified prefix alone, so that a mistake at position 3 does not contaminate the guesses at positions 4, 5, and beyond—each position's guess quality depends only on the ground-truth prefix, not on other guesses.

3.2 Big-picture architecture (diagram in words)

The system has four major components connected in a loop:

Frozen AR target model (the verifier): The large language model whose outputs we want to preserve exactly. It is never modified or retrained. It receives a prefix (verified tokens so far) concatenated with draft tokens, runs one parallel forward pass to score them all, and decides token-by-token which drafts to accept or reject. This is the "correctness oracle" in the pipeline.
Diffusion language model drafter: A small (0.5B parameters) discrete-space diffusion model that has been specially trained to do something it was never designed for: given a verified prefix, generate a plausible suffix in one shot. It observes the prefix with a [SEP] marker, then in a single forward pass predicts all tokens of a masked suffix block simultaneously. This is the "proposal generator" in the pipeline.
Two-stage training pipeline (D2A Alignment): This is the offline preparation that transforms a generic dLLM into a prefix-conditioned drafter. Stage I clones the AR target's continuation behavior on truncated passages. Stage II sharpens token-level accuracy specifically near the prefix boundary where the verifier's acceptance decisions are most sensitive. The output of this pipeline is the aligned drafter model—a frozen artifact at inference time.
Block-wise speculative decoding loop (the inference algorithm): At runtime, the system alternates between two steps: (a) the dLLM proposes a block of $k$ tokens in parallel, and (b) the AR target verifies each token sequentially, accepting matches and replacing mismatches with its own samples. The loop continues until an end-of-sequence token is generated or a length limit is reached. The output distribution is mathematically identical to what the AR target would produce on its own (provably lossless).

3.3 Roadmap for the deep dive

To build understanding from first principles, I will explain the components in the following order:

First, the formal speculative decoding acceptance/rejection mechanism (Equations 5–6) that defines what "lossless" means and why the drafter's independence property matters. This establishes the mathematical playground.
Second, the Diffusion-to-AR (D2A) Alignment training pipeline that converts a pre-trained dLLM into a prefix-conditioned drafter. This is the enabler that makes everything else work.
- Stage I: AR-style continuation distillation (Equation 1–2), which teaches the dLLM to generate from prefixes rather than reconstruct complete sequences.
- Stage II: Scribe refinement (Equations 3–4), which sharpens accuracy at the prefix-suffix boundary.
Third, the inference algorithm (Algorithm 1) that orchestrates draft generation and verification, including the block-wise conditioning that eliminates uncertainty accumulation.
Fourth, the design choices: why discrete space over continuous, why single-step over multi-step, why modular drafter over hybrid training.

3.4 Detailed, sentence-based technical breakdown

This is primarily a systems + methods paper whose core idea is that replacing an autoregressive drafter with a discrete diffusion drafter removes the left-to-right dependency that causes error accumulation, thereby enabling substantially longer accepted draft blocks, and that a two-stage alignment pipeline is necessary and sufficient to adapt diffusion models—which are trained for joint sequence reconstruction—to the prefix-conditioned continuation task that speculative decoding demands.

Formulation of Lossless Speculative Decoding and the Acceptance Mechanism

At each decoding position, speculative decoding must guarantee that the final output distribution matches what the target AR model would produce if it decoded alone. This is the losslessness property. The formal mechanism is a token-level rejection sampling procedure adapted from Leviathan et al. (2023).

The target AR model defines a conditional distribution at position $j + i$ given the verified prefix $x_{1:j+i-1}$ :

$p_{\text{AR}}(\hat{y}_{j+i} \mid x_{1:j+i-1})$

where $x_{1:j+i-1}$ is the sequence of already-verified tokens (either accepted drafts or corrected tokens from previous steps) and $\hat{y}_{j+i}$ is the token being considered at the current position. This distribution represents what the large model would generate if left to its own devices—it is the gold standard that must be preserved.

The DEER drafter proposes a distribution conditioned only on the original verified prefix, not on previously drafted tokens:

$q_\theta(\hat{y}_{j+i} \mid x_{1:j})$

Here, $x_{1:j}$ is the prefix that was known before the current drafting block began—it contains no unverified draft tokens, only tokens that the verifier has already approved. The subscript $\theta$ denotes the parameters of the aligned dLLM.

Critical difference from AR drafters: In a standard AR drafter, the proposal distribution at depth $i$ would be $q(\hat{y}_{j+i} \mid x_{1:j}, \hat{y}_{j+1:j+i-1})$ , conditioning on previous unverified drafts. This is precisely where error propagation originates—if $\hat{y}_{j+1}$ is wrong, it pushes $\hat{y}_{j+2}$ further off course, and so on. DEER breaks this chain: $q_\theta$ sees only $x_{1:j}$ , so the quality of the guess at position $j+i$ is independent of guesses at positions $j+1, \dots, j+i-1$ . Each token's error is local, not cumulative.

Token-level acceptance probability. At verification time, the AR target examines the $i$ -th draft token $\hat{y}_{j+i}$ and computes:

$\alpha_i = \min\left(1, \frac{p_{\text{AR}}(\hat{y}_{j+i} \mid x_{1:j+i-1})}{q_\theta(\hat{y}_{j+i} \mid x_{1:j})}\right)$

where $\alpha_i \in [0, 1]$ is the probability of accepting the draft token, $p_{\text{AR}}(\hat{y}_{j+i} \mid x_{1:j+i-1})$ is the target's conditional probability for that specific token given the full verified prefix up to that point, and $q_\theta(\hat{y}_{j+i} \mid x_{1:j})$ is the drafter's probability for that same token given only the original prefix.

What it computes: the ratio of how much the target model likes the token to how much the drafter likes it, capped at 1. If the target assigns higher probability than the drafter ( $p_{\text{AR}} > q_\theta$ ), the ratio exceeds 1, so the token is always accepted ( $\alpha_i = 1$ ). If the target assigns lower probability ( $p_{\text{AR}} < q_\theta$ ), the ratio is less than 1, and the token is accepted with probability equal to that ratio—the drafter proposed the token more confidently than the target would, so it must be probabilistically rejected to preserve the target's marginal distribution.

Why this form: this is the standard Metropolis-Hastings acceptance ratio for importance sampling from the target distribution using the proposal as an instrumental distribution. The min(1, ·) ensures a valid probability. Crucially, because DEER's proposal $q_\theta(\cdot \mid x_{1:j})$ is independent of draft depth, the denominator does not degrade with $i$ due to error accumulation—the only source of mismatch is how well the drafter's initial prediction at position $j+i$ matches the target's conditional $p_{\text{AR}}(\cdot \mid x_{1:j+i-1})$ given the true extended prefix. In an AR drafter, the denominator would be $q(\hat{y}_{j+i} \mid x_{1:j}, \hat{y}_{j+1:j+i-1})$ , which drifts from $p_{\text{AR}}$ as $i$ grows because $\hat{y}_{j+1:j+i-1}$ accumulates errors.

Rejection and residual sampling. When a draft token is rejected (which happens with probability $1 - \alpha_i$ ), the system must replace it with a token that, together with the acceptance mechanism, preserves the target distribution. The replacement is sampled from the residual distribution:

$\hat{y}_{j+i} \propto \max\left(0, p_{\text{AR}}(\cdot \mid x_{1:j+i-1}) - q_\theta(\cdot \mid x_{1:j})\right)$

where $p_{\text{AR}}(\cdot \mid x_{1:j+i-1})$ is the target's full probability vector over the vocabulary, $q_\theta(\cdot \mid x_{1:j})$ is the drafter's full probability vector, and the max(0, ·) clips negative values to zero. The result is a new distribution formed by subtracting the drafter's probability mass from the target's (pointwise), then renormalizing.

What it computes: the conditional distribution of tokens that the target considers likely but the drafter under-proposed relative to the target. Sampling from this residual ensures that tokens the drafter failed to suggest can still be generated, recovering the full diversity of the target distribution. This is the mathematical guarantee of losslessness: every token has exactly the probability under the combined procedure that it would have under direct AR sampling from $p_{\text{AR}}$ .

Why this form: simple rejection sampling (just discarding rejected drafts without replacement) would bias the distribution toward tokens the drafter over-proposes. The residual correction adjusts for this by explicitly sampling from the under-proposed region. The max(0, ·) is necessary because the subtraction $p_{\text{AR}} - q_\theta$ can be negative for tokens the drafter over-proposes—those tokens already have their correct probability mass through the acceptance path ( $\alpha_i$ already handles the min(1, ·) cap), so the residual path should not double-count them.

Sequence-level losslessness (Theorem E.2, Appendix E). By induction on token positions, the paper proves that this per-token mechanism yields exactly the same joint distribution over complete sequences as direct AR decoding from $p_{\text{AR}}$ . The proof is standard for speculative decoding but is included explicitly (Appendix E) to confirm that the non-standard proposal distribution $q_\theta(\cdot \mid x_{1:j})$ satisfies the required support condition (the drafter never assigns zero probability to tokens the target could generate). This formal guarantee is critical for practical adoption—users need not worry about subtle quality degradation in exchange for speed.

Diffusion Language Models and the Need for Alignment

Before describing the training pipeline, we must understand what a dLLM is and why it cannot be used directly as a drafter.

Discrete diffusion language models. A dLLM is a generative model trained to reverse a noise process applied to discrete token sequences. The training procedure (following D3PM, Austin et al. 2021a) works as follows:

Take a complete token sequence $x_0 = (x_0^1, x_0^2, \ldots, x_0^L)$ from the training corpus.
At a randomly sampled timestep $t$ , corrupt a random subset of tokens by replacing them with a special [MASK] token. The masking probability depends on $t$ —higher $t$ means more tokens are masked.
Feed the corrupted sequence $x_t$ to the model.
Train the model to predict the identity of each masked token (i.e., denoise back to $x_0^i$ ), using a cross-entropy loss over the vocabulary at each masked position.

After training, generation proceeds by starting with a fully masked sequence and iteratively denoising: at each step, the model predicts the original tokens for some subset of masks, those positions are filled in, and the process repeats until no masks remain. Critically, the model attends bidirectionally—every token prediction can condition on every other token in the sequence, both past and future. This is fundamentally different from AR models, which can only condition on past tokens.

The prefix-conditioning mismatch. If you take a pre-trained dLLM and ask it to generate a suffix given a prefix, you encounter a problem. The model was trained to expect bidirectional context—during training, when predicting a masked token at position $i$ , it could attend to tokens at positions $i+1, i+2, \ldots$ that happened to be unmasked in that training example. But during prefix-conditioned generation, the suffix tokens are all masked—there is no future context to attend to. The model's predictions in this impoverished information regime do not match the AR target's causal predictions, because the dLLM's training objective was joint reconstruction, not conditional generation.

The consequence is a severe distribution mismatch: $q_{\text{pretrained dLLM}}(\hat{y_i} \mid x_{1:j}) \neq p_{\text{AR}}(\hat{y_i} \mid x_{1:j})$ . The proposals are not aligned with what the verifier expects, leading to low acceptance rates and poor speedup. The entire D2A alignment pipeline exists to fix this mismatch.

Stage I: AR-Style Continuation Distillation

The first training stage teaches the dLLM to behave like an AR model when generating from a prefix. It does this through supervised imitation of the target AR model's continuations.

Training data construction. For each training example (which consists of a question/prompt and a teacher-generated answer $A = \{a_{l_q+1:L}\}$ of length $L - l_q$ tokens, where $l_q$ is the prefix length), the procedure is:

Randomly truncate the answer: select a truncation point uniformly from the answer sequence, keeping only the first $r$ tokens of the answer where $r \sim \text{Uniform}(1, L - l_q)$ .
Construct the input sequence: [prefix] + [kept answer tokens] + [SEP] + [MASK]^{L - l_q - r}. The [SEP] token is a special marker that tells the model "everything before me is the verified context, everything after me needs to be generated." The suffix consisting entirely of [MASK] tokens represents the unknown continuation.
Apply noise: as in standard diffusion training, some fraction of the already-known tokens (the prefix and kept answer tokens) are independently masked at the current noise level $t$ , creating a noisy observation $x_t$ . However, the suffix [MASK] tokens are always treated as masked—they are the prediction target.
Compute the loss only on the suffix masks: the model is penalized for incorrect predictions at positions $i > l_q + r$ where the input token is [MASK].

Formal objective.

$\mathcal{L}_{\text{Distill}} = -\mathbb{E}_{t, x_0, x_t} \left[ \frac{1}{t} \sum_{i=l_q+1}^{L-1} \mathbb{1}[x_t^i = M] \cdot r_i \right]$

where $t$ is the timestep (higher $t$ means more noise), $x_0$ is the clean full sequence including the complete teacher answer, $x_t$ is the corrupted version of $x_0$ at noise level $t$ (some tokens replaced with [MASK]), $l_q$ is the length of the un-truncated prefix, $L$ is the total sequence length, $\mathbb{1}[x_t^i = M]$ is an indicator that is 1 when the token at position $i$ in the noisy sequence is a mask token (meaning the model must predict it), and $r_i$ is the log-probability that the dLLM assigns to the ground-truth token at that position:

$r_i = \log p_\theta(x_0^i \mid x_t)$

where $p_\theta(x_0^i \mid x_t)$ is the model's predicted probability for the true token $x_0^i$ given the noisy observation $x_t$ .

The $1/t$ scaling factor requires explanation. It weights the loss inversely by the noise level, meaning that predictions at higher noise levels (when more tokens are masked and information is scarce) contribute less to the gradient than predictions at lower noise levels (when the model has more context and should be more accurate). This is a standard diffusion training technique: low-noise predictions are more informative about fine-grained token preferences, while high-noise predictions primarily learn coarse semantic structure.

What it computes: the expected negative log-likelihood (averaged over random noise levels and random truncations) of the ground-truth continuation tokens at positions that are masked in the noisy input. Only suffix positions are counted—the model is not penalized for the prefix or the kept answer tokens, which serve only as conditioning information.

Why this form: the truncated-answer construction with [SEP] forces the model to learn that the region after [SEP] must be generated from the prefix alone, without peeking at future tokens (because they are all masked). The random truncation point ensures the model sees continuations of varying lengths during training, from very short (single token after [SEP]) to the full remaining answer. The diffusion-style noise on the conditioning tokens teaches robustness: the model must learn to generate coherent continuations even when some words in the prefix are masked, which mirrors the noisy information regime at inference time (the prefix is always fully known at inference, but training with noise prevents overfitting to perfect conditioning). This stage produces a dLLM that can stably produce prefix-conditioned continuations, aligning its behavior with the AR teacher's causal distribution.

Training configuration (Appendix A). For code generation, the model is Open-dLLM (Peng et al., 2025), a 0.5B-parameter discrete diffusion model. Stage I uses AdamW optimizer, learning rate $1 \times 10^{-4}$ , trained for 1 epoch on the OpenCodeInstruct dataset. For math reasoning, the base model is Qwen2.5-0.5B-Instruct converted to diffusion, trained on UltraChat for 40 epochs, then Stage I applies AdamW with learning rate $1 \times 10^{-4}$ for 5 epochs.

While Stage I teaches the dLLM to generate continuations at all positions after the prefix, speculative decoding has a specific sensitivity: the first few tokens after the prefix are the most critical for acceptance. This is because the verifier's acceptance decision at position $j+1$ depends on $q_\theta(\hat{y}_{j+1} \mid x_{1:j})$ —if this marginal is mismatched, the first token is likely rejected, and the subsequent tokens never even get verified (the draft block is truncated at the first rejection). High accuracy on early positions is disproportionately valuable because it unlocks verification of the entire remaining block.

Stage II addresses this by focusing the training loss on the tokens closest to the prefix, using an exponentially decaying weighting scheme and a different masking strategy.

Training data construction. Unlike Stage I, which masks the entire suffix, Stage II masks only a short contiguous segment at the end of the answer:

Sample a refinement length $R \sim \text{Uniform}(1, 96)$ tokens.
Mask only the last $R$ tokens of the teacher answer, leaving the prefix and all earlier answer tokens fully intact (subject to standard diffusion noise).
The model must reconstruct these final $R$ tokens.

Exponential weighting. Tokens within the masked segment are not treated equally. A position-dependent weight gives exponentially more importance to tokens closer to the prefix:

$w_i = \alpha^{R - i}, \quad i = 1, \ldots, R$

where $\alpha > 1$ is a scaling hyperparameter (set to 1.01 in experiments), $R$ is the total number of masked tokens, and $i$ indexes from the start of the masked segment (token 1 is closest to the prefix, token $R$ is farthest). The exponent $R - i$ means that when $i = 1$ (the token right after the prefix), the weight is $\alpha^{R-1}$ , which is maximal; when $i = R$ (the token farthest from the prefix), the weight is $\alpha^0 = 1$ , which is minimal. The weight decays exponentially as we move away from the prefix.

Formal objective.

$\mathcal{L}_{\text{Refine}} = -\mathbb{E}_{t, x_0, x_t} \left[ \frac{1}{t} \sum_{i=l_q+1}^{L-1} w_i \cdot \mathbb{1}[x_t^i = M] \cdot r_i \right]$

where all symbols have the same meaning as in Stage I, and $w_i$ is the exponential weight defined above for positions in the masked refinement segment (and 1 for positions outside it, though in practice only the refinement segment is masked).

What it computes: a weighted cross-entropy loss over the masked refinement segment, where tokens immediately after the prefix receive exponentially more gradient signal than tokens further away. The $1/t$ scaling from Stage I is retained.

Why this form: this creates a curriculum that concentrates the model's representational capacity on the prefix-suffix boundary. During Stage I, the model learned to generate entire continuations, treating all positions roughly equally (modulo the $1/t$ diffusion weighting). Stage II refines this by saying: "the first few tokens you generate after the prefix are the most important—get those exactly right, even if it means slightly less accuracy on tokens deeper in the block." This is directly motivated by the speculative decoding acceptance mechanism: accurate early tokens survive verification and unlock the block, while late tokens are a bonus only if the early ones pass.

The exponential decay rather than a step function (e.g., "only look at the first 5 tokens") is chosen for stability: it provides smooth gradient signal across the entire refinement segment, preventing optimization discontinuities at arbitrary boundaries. The hyperparameter $\alpha$ controls the steepness of this decay— $\alpha = 1.01$ (as used in experiments; Figure 6) provides a gentle decay that emphasizes early tokens without entirely ignoring late ones.

Hyperparameter sensitivity (Figure 6). The paper reports that $\alpha$ has a narrow stability window. At $\alpha = 1.01$ , the loss decreases smoothly throughout training. At $\alpha = 1.02$ , training curves are noisier with slight upward drift, suggesting marginal stability. At $\alpha = 1.05$ , the loss diverges early—the aggressive weighting amplifies gradients near the prefix boundary to the point where optimization becomes unstable. This sensitivity comes from the exponentiation: even a small increase in $\alpha$ produces a large increase in the weight ratio between the first and last tokens (since the ratio is $\alpha^{R-1}$ , which for $R = 96$ is $1.01^{95} \approx 2.57$ vs. $1.05^{95} \approx 103$ ). The paper's chosen $\alpha = 1.01$ keeps the maximum/minimum weight ratio under 3× even for the maximum refinement length of 96 tokens.

Training configuration (Appendix A). For code generation, Stage II uses AdamW, learning rate $5 \times 10^{-5}$ , trained for 1 epoch on a 100k-example subset. The learning rate is halved from Stage I ( $1 \times 10^{-4} \to 5 \times 10^{-5}$ ), following the standard fine-tuning practice of using a lower learning rate for the refinement phase. For math, Stage II uses AdamW, learning rate $1 \times 10^{-4}$ , for 1 additional epoch.

Impact on acceptance length (Table 3). On Qwen3-30B-A3B, enabling Stage II increases average acceptance length $\tau$ from 5.38 to 6.58 on HumanEval, from 4.74 to 4.87 on MBPP, from 3.47 to 4.04 on CodeAlpacaPy, and from 3.87 to 5.03 on LiveCodeBench. The gains are largest on the benchmarks with the most complex structure (HumanEval and LiveCodeBench, with gains of 1.20 and 1.16 tokens respectively), supporting the paper's claim that refinement improves alignment specifically in settings where the AR teacher's distribution has sharp, deterministic preferences near the prefix—which is characteristic of code generation with rigid syntactic constraints.

Inference Algorithm: Block-Wise Speculative Decoding

At inference time, the trained dLLM drafter and the frozen AR verifier operate in an alternating loop. Algorithm 1 in the paper describes the procedure formally; I will walk through the mechanics and design rationale.

Initialization. Decoding starts with a prefix $x_{1:j}$ (initially the prompt, which grows as tokens are verified). A block size $k$ is fixed—this is the number of tokens the dLLM attempts to propose in each cycle. The paper sweeps $k$ from 4 to 32, finding that larger blocks increase average acceptance length with diminishing returns (Figure 8, Appendix B.2).

Draft generation (line 3 of Algorithm 1). Given the current prefix $x_{1:j}$ , the dLLM generates a draft block of $k$ tokens in a single forward pass:

$\hat{y}_{j+1:j+k} \sim q_\theta(\cdot \mid x_{1:j})$

Under the hood, this works as follows:

Construct an input sequence: $x_{1:j}$ (the verified prefix) + [SEP] + [MASK]^k ( $k$ mask tokens representing the unknown continuation).
Feed this sequence through the dLLM.
At each of the $k$ mask positions, the model outputs a probability distribution over the vocabulary, conditioned bidirectionally on the prefix and on other mask positions (which can attend to each other).
Sample one token from each position's distribution, producing $\hat{y}_{j+1}, \hat{y}_{j+2}, \ldots, \hat{y}_{j+k}$ .

The key here is that all $k$ tokens are sampled simultaneously—the model's prediction at position $j+3$ is not conditioned on the sampled token at $j+2$ , but rather on the distribution of what $j+2$ could be (through the attention mechanism over the mask tokens, which maintains uncertainty rather than collapsing to a single sample). This is the independence property that prevents error accumulation.

Token-wise verification (lines 4–15). The AR verifier now processes the concatenated sequence $[x_{1:j}, \hat{y}_{j+1:j+k}]$ in one forward pass, computing logits at each position. However, acceptance decisions are made sequentially from left to right:

For $i = 1$ to $k$ :

Compute the acceptance probability $\alpha_i$ using Equation 5 (the min-ratio formula).
Sample a uniform random variable $u \sim \text{Uniform}(0, 1)$ .
If $u \leq \alpha_i$ : accept $\hat{y}_{j+i}$ and append it to the verified prefix. Continue to the next position.
If $u > \alpha_i$ : reject $\hat{y}_{j+i}$ . Sample a replacement token from the residual distribution (Equation 6), append it to the verified prefix, and stop verifying the rest of the block—all remaining draft tokens ( $\hat{y}_{j+i+1:j+k}$ ) are discarded.

Why sequential verification? Even though the verifier's forward pass computes logits for all $k$ positions in parallel, acceptance must be sequential because the residual sampling step at position $j+i$ changes the prefix for position $j+i+1$ . If token $j+i$ is rejected, the verifier's prediction at position $j+i+1$ was conditioned on $\hat{y}_{j+i}$ , but the actual token placed at $j+i$ is different—the verifier's pre-computed logits for $j+i+1$ are now stale. The paper follows the standard practice in speculative decoding: truncate the draft at the first rejection and re-draft from the corrected prefix. This is the practical consequence of the left-to-right nature of AR verification—the drafter can be parallel, but the verifier's causal structure forces sequential acceptance decisions.

KV cache interaction. In the experiments in Tables 1 and 2, KV caching is enabled—the verifier's key-value pairs from the verified prefix are cached, so each verification forward pass only processes the new draft tokens. This is standard in production LLM inference and is critical for achieving the reported speedups. Without KV cache, the verifier would recompute attention over the entire growing prefix each time, eating into the gains from parallel drafting. Appendix F notes that dLLMs currently lack mature KV cache support in mainstream frameworks (vLLM, SGLang), though recent work like Fast-dLLM (Wu et al., 2025) and dInfer (Ma et al., 2025) is addressing this gap. The batch inference experiments in Section 4.4 are run without KV cache for both AR and DEER to ensure a fair comparison.

Block size and acceptance length scaling (Figure 8, Appendix B.2). The paper evaluates how the block size $k$ affects the average acceptance length for three model scales on HumanEval:

Block size	Qwen3-8B $\tau$	Qwen3-14B $\tau$	Qwen3-30B-A3B $\tau$
4	~3.5	~4.0	~4.0
8	~4.0	~4.5	~5.0
16	~4.2	~4.9	~5.8
32	~4.3	~5.2	~6.6

Two patterns emerge. First, acceptance length increases monotonically with block size, but with diminishing returns—doubling $k$ from 16 to 32 yields a smaller gain than doubling from 4 to 8. Second, the scaling is more favorable for larger target models: the gap between $k=4$ and $k=32$ is approximately 0.8 tokens for Qwen3-8B but 2.6 tokens for Qwen3-30B-A3B. The paper attributes this to the fact that larger models have more deterministic output distributions (their top-1 probability is higher), so the dLLM can fit their token patterns more precisely, and this precision translates into more tokens accepted per block when the block allows longer drafts.

Maximum acceptance length of 32 tokens (Table 4). DEER achieves maximum acceptance lengths of 32 tokens across all model scales, compared to 7–8 tokens for EAGLE-3. This is a directly observed consequence of the independence property: because the dLLM's proposals at positions 9–32 are not contaminated by errors at positions 1–8, some fraction of these long proposals survive verification. The paper further observes a long-block resurgence effect in the acceptance length distribution (Figure 7, Appendix B.1): the probability of accepting a draft typically follows an exponential decay with length, but for DEER the probability mass increases again as acceptance length approaches the maximum (30+ tokens). The authors interpret this as evidence that when a draft survives to extreme lengths, the independent-generation property means later tokens are actually more likely to be accepted than mid-length ones—the dLLM's global modeling of the continuation produces coherent long-range structure that aligns with the verifier.

Design Choices and Their Justifications

The paper makes several non-obvious design choices that distinguish DEER from alternatives. Understanding these choices and their motivations clarifies why the approach works and where its boundaries lie.

Choice 1: Discrete-space diffusion over continuous-space diffusion. DEER operates entirely in discrete token space—the dLLM predicts token identities directly, and acceptance probabilities are computed as ratios of discrete probabilities. SDD (Christopher et al., 2025) used continuous-space diffusion where the model predicts continuous embeddings that are discretized only at the final step.

Why discrete: speculative decoding requires exact probability ratios for the acceptance formula (Equation 5). In continuous space, the drafter's "probability" of a specific token is ill-defined—it is a density over an embedding that happens to be nearest to that token's embedding after rounding. This prevents precise temperature control (the effective temperature is determined by the variance of the continuous denoising process, not an explicit parameter) and introduces a sampling mismatch that the AR verifier's acceptance formula was not designed to handle. In discrete space, $q_\theta(\text{token} \mid \text{prefix})$ is a well-defined categorical distribution, and the acceptance ratio has the exact theoretical guarantees of losslessness.

Choice 2: Single-step generation over multi-step denoising. During inference, DEER generates the entire draft block in one forward pass, rather than iteratively denoising (as in standard diffusion generation where multiple rounds of mask prediction are applied).

Why single-step: Multi-step denoising would re-introduce a form of sequential dependency. Each denoising step re-masks some tokens based on the model's confidence and re-predicts them in the next step. While less severe than AR decoding, this still creates a coupling between draft tokens—a token predicted at step 1 influences which tokens get re-masked at step 2, which influences the final prediction. The paper's goal is strict independence of draft tokens from each other, and single-step generation achieves this maximally: the model sees only mask tokens (representing total uncertainty) for the entire suffix, so predictions at all positions are conditionally independent given the prefix. The alignment training (Stages I and II) ensures that this single-step prediction is high-quality enough to serve as a useful draft, which is not guaranteed for a generic dLLM.

Choice 3: Modular drafter over hybrid training. DEER uses a separate, frozen dLLM drafter alongside the frozen AR verifier. TiDAR (Liu et al., 2025) instead retrains the AR model itself to perform diffusion-style generation, unifying drafting and verification.

Why modular: There are three practical advantages. First, the target AR model's capabilities are preserved without any risk of objective conflict—the AR model is never modified, so its quality on downstream tasks is unaffected. Second, training a smaller dedicated drafter (0.5B parameters) is significantly cheaper than retraining the full target (8B–30B parameters), both in GPU hours (Table 8: DEER takes 240 GPU hours vs. 696+ for EAGLE-3 on Qwen3-8B) and in data requirements. Third, the drafter can be trained once and used with multiple target models of different sizes (the paper uses the same 0.5B dLLM for Qwen3-8B, Qwen3-14B, and Qwen3-30B-A3B), while hybrid approaches require retraining for each target. The downside—that the drafter and verifier are separate models with separate forward passes—is manageable because the dLLM is small and its forward pass is comparable in cost to the AR drafter heads used by EAGLE-3 (Table 7: DEER drafter is 470M parameters vs. 400M for EAGLE-3 on the 8B target).

Choice 4: Two-stage training with refinement rather than end-to-end training. Instead of training the dLLM on speculative decoding performance directly (which would require running the verifier during training), the paper uses a two-stage supervised procedure that trains the dLLM to mimic the AR teacher's continuations.

Why two-stage: Direct optimization of acceptance length would require differentiable access to the verification process, which is both computationally expensive (the verifier is a large AR model) and technically challenging (the acceptance/rejection step produces discrete decisions). The two-stage approach decomposes the problem into (1) making the dLLM's continuations match the target's distribution, and (2) sharpening alignment at the most acceptance-critical positions. Stage I is relatively easy to train (it's just supervised denoising on truncated completions) and produces a drafter that is broadly aligned. Stage II adds a precise correction at the prefix boundary, where the marginal benefit per unit of alignment improvement is highest. Empirically (Table 3), this decomposition works: Stage I alone already enables useful drafting, and Stage II provides an additional boost of 0.5–1.2 tokens in acceptance length.

Choice 5: Exponential weighting with $\alpha = 1.01$ for refinement. The refinement stage uses an exponential decay $w_i = \alpha^{R-i}$ with $\alpha = 1.01$ to emphasize early tokens. Alternative weighting schemes (uniform, linear decay, step function) were not ablated in the paper, but the choice of exponential decay reflects several considerations.

Why exponential: the acceptance probability at position $j+i$ depends on the drafter's accuracy at that specific position relative to the verifier's conditional distribution $p_{\text{AR}}(\cdot \mid x_{1:j+i-1})$ . As $i$ increases, the verifier's conditional distribution changes (because the verified prefix grows by one token per accepted position), creating a small but compounding mismatch between $q_\theta(\cdot \mid x_{1:j})$ (which is fixed for the entire block) and $p_{\text{AR}}(\cdot \mid x_{1:j+i-1})$ (which shifts with each accepted token). This compounding mismatch is roughly exponential in $i$ (it's the product of per-step divergence factors), so the value of improving $q_\theta$ at position $i$ is highest for small $i$ and decays roughly exponentially. The exponential weight $\alpha^{R-i}$ directly mirrors this value decay, concentrating training signal where it provides the greatest increase in expected acceptance length.

Why $\alpha = 1.01$ : the narrow stability window (Figure 6) reflects a fundamental tension in diffusion training. Higher $\alpha$ amplifies gradients at early positions, but the diffusion objective already has an implicit weighting from the $1/t$ factor and from the fact that early positions have more context (fewer adjacent masks) and thus naturally produce smaller losses. The $\alpha = 1.01$ setting keeps the maximum weight ratio (between position 1 and position 96) around 2.57, which is enough to meaningfully shift emphasis without destabilizing the denoising objective. At $\alpha = 1.05$ , the ratio is ~103×, which effectively ignores late positions entirely—the model overfits to early-position accuracy at the cost of losing the global coherence learned in Stage I.

Choice 6: 0.5B-parameter dLLM across all target sizes. The same 0.5B drafter serves targets from 4B to 30B parameters (Table 7). This is possible because the drafter's job—predicting the target's next tokens given a prefix—is fundamentally an imitation task that benefits from the target's determinism. Larger targets have more peaked output distributions, which are easier for the drafter to fit, not harder. The paper's scaling results (Figure 8, Appendix B.2) confirm this: the same drafter produces longer acceptance lengths on larger targets because the target's predictions are more predictable. This is the opposite of AR drafters, which struggle more with larger targets because the gap between the small drafter's sequential errors and the large target's precise expectations widens.

Emergent capability: reliable block regeneration (Section 4.5, Figure 5). The paper reports an unexpected behavior that emerges from the D2A training: the dLLM can perform iterative block extension, where it generates a partial block of code, then re-masks parts of it and regenerates them coherently in subsequent denoising steps. Figure 5 illustrates this for a quicksort implementation: tokens are colored by the iteration in which they were produced, showing that the model can refine and extend a code block across multiple diffusion steps without losing coherence.

The authors present this as evidence that the alignment pipeline teaches the dLLM a more general capability than just single-step drafting. During Stage I training, the model saw the same continuation at multiple noise levels, learning to reconstruct partial answers from varying amounts of context. This apparently generalizes to a generative capability: given a partial block (some tokens known, some masked), the model can fill in the rest. At inference time, this manifests as the ability to iterate—generate an initial block, identify which parts are high-confidence (could be verified) and which are uncertain (should be regenerated), and run the dLLM again with the uncertain parts re-masked. The paper does not exploit this capability for the core speculative decoding results (which use single-step generation), but it hints at future extensions where the drafter could refine its own proposals before sending them to the verifier, potentially further increasing acceptance lengths.

4. Key Insights and Innovations

Innovation 1: The Gradual Collapse of Trust — A New Diagnostic Concept That Names the Central Bottleneck in Speculative Decoding

The paper's most conceptually impactful contribution is not the method itself but the diagnostic framing it introduces to explain why existing speculative decoding methods plateau. The term "gradual collapse of trust" names a phenomenon that was previously understood only implicitly—everyone knew AR drafters got worse at longer draft lengths, but the field lacked a crisp causal account of why and how this degradation compounds. DEER supplies that account: each drafted token conditions on previously drafted tokens that have not been verified, so any small divergence between the drafter and target at position j+1 becomes part of the conditioning context for the drafter's prediction at j+2, which amplifies the mismatch, which becomes context for j+3, and so on. The resulting cascade is not merely additive—it is recursive, meaning the draft trajectory exponentially departs from the verifier's acceptance region as depth increases.

This framing is significant beyond performance because it changes the optimization target. Prior work on improving speculative decoding focused overwhelmingly on making the drafter more accurate—better training data, larger draft models, more sophisticated prediction heads (Medusa, Hydra, EAGLE-3). These approaches treat low acceptance length as a symptom of insufficient drafter quality. The "gradual collapse of trust" reframing argues that even a perfectly accurate AR drafter—one whose per-token predictions exactly match the target when conditioned on ground-truth prefixes—would still suffer acceptance collapse because it conditions on its own outputs at inference time, entering a self-reinforcing distributional drift. The problem is not (only) drafter inaccuracy; it is architectural: the left-to-right dependency structure of AR generation makes error propagation inevitable regardless of drafter quality.

This is the kind of conceptual move that redirects research effort. If the bottleneck were drafter accuracy, the natural response would be to invest in larger drafters, better alignment techniques, or more training data—an incremental improvement trajectory. If the bottleneck is the dependency structure itself, the natural response is to eliminate the dependency—a fundamentally different class of solutions. The paper provides evidence for the structural interpretation in Table 4: EAGLE-3, a state-of-the-art AR drafter with sophisticated training (training-time test-time augmentation), plateaus at 7–8 maximum accepted tokens regardless of model scale. DEER, with a similar-sized drafter (470M vs. 400M parameters; Table 7), reaches 32 tokens—not because it is more "accurate" in some absolute sense, but because its independent-generation mechanism prevents the cascade.

The concept also explains a subtle empirical pattern that AR drafter improvements cannot: why larger target models benefit more from DEER than from AR drafters (Figure 8). Larger models have more deterministic output distributions, which makes their token patterns more predictable—good for any drafter. But in an AR drafter, this benefit is partially offset by the fact that larger models are also more sensitive to the distributional drift in the conditioning context, since their sharp predictions change more dramatically when the prefix drifts off-distribution. The collapse mechanism means AR drafters cannot fully capitalize on the larger model's predictability. DEER, by conditioning only on the verified prefix, captures the full benefit of target determinism without suffering the sensitivity penalty. This interaction between model scale, output determinism, and draft architecture is non-obvious and would not have been predicted by a framework that treats acceptance length as purely a function of drafter accuracy.

This is a fundamental conceptual contribution rather than an incremental refinement: it names a previously unarticulated failure mode, provides a mechanistic explanation for it, and uses that explanation to motivate a qualitatively different solution direction.

Innovation 2: Drafting via Joint Independence Rather Than Sequential Conditioning — A Paradigm Shift in the Generative Mechanism of Speculative Decoding

The paper's second major contribution is the architectural insight that the draft generation process itself can be parallelized without sacrificing alignment, by replacing sequential conditional generation (q(ŷᵢ | prefix, ŷ₁:ᵢ₋₁)) with joint independent generation (q(ŷᵢ | prefix) for all i simultaneously). This is not simply "using a diffusion model instead of an AR model"—it is a fundamentally different theory of what makes a good drafter that inverts the field's implicit assumptions about how drafting must work.

Prior to this work, the dominant paradigm—implicitly assumed across all major speculative decoding methods—was that draft tokens must be generated in causal order because the verifier's acceptance decision at position j+i conditions on tokens j+1 through j+i-1. The drafter's job was to predict what the verifier would predict, and since the verifier is causal, the drafter should be causal too. This seemed like a natural constraint: the drafter should mirror the target's generation process to maximize alignment.

DEER shows that this mirroring assumption is not necessary for losslessness and is actively harmful for efficiency. The acceptance formula (Equation 5) only requires that the drafter's proposal distribution be evaluated at q_θ(ŷ_{j+i} | x_{1:j})—it places no requirement on how the drafter arrived at that distribution. As long as the ratio p_AR(ŷ_{j+i} | x_{1:j+i-1}) / q_θ(ŷ_{j+i} | x_{1:j}) is well-defined (the support condition holds), the acceptance mechanism works regardless of whether the drafter conditioned on previous drafts or not. The verifier's causal structure constrains the verification step (acceptance must be sequential because the residual resampling changes the prefix), but it does not constrain the drafting step. Drafting can be entirely parallel, entirely independent, and the theoretical guarantee of losslessness remains intact.

This is a paradigm shift because it decouples the drafter's generative mechanism from the target's causal structure. The field had implicitly conflated the two—if the target generates left-to-right, the drafter should too. DEER demonstrates that a non-causal drafter with prefix-only conditioning can be aligned to a causal target through appropriate training (the D2A pipeline), and that this decoupling provides the specific benefit of eliminating error propagation. The drafter no longer needs to "think like the target"—it only needs to match the target's marginal continuations from fixed prefixes, a strictly easier learning problem that does not require modeling the cumulative effects of its own sampling decisions.

The shift is comparable to the transition from autoregressive models to masked language models in representation learning: BERT showed that bidirectional conditioning could produce better representations for downstream tasks than left-to-right conditioning, even though natural language is inherently sequential. DEER shows something analogous for generation efficiency: non-causal block proposals can produce better speculative decoding throughput than causal sequential proposals, even though the verifier is causal. In both cases, the key move is recognizing that the evaluation criterion (acceptance by a causal verifier) does not mandate a generation process that mirrors causality.

This is a fundamental rather than incremental contribution because it redefines the design space for speculative decoding drafters. Rather than searching for better AR architectures or training procedures within the causal paradigm, future work can explore any generative model—diffusion, masked language models, discrete energy-based models, even retrieval-based methods—that can produce prefix-conditioned token distributions with the independence property. The D2A pipeline provides one recipe for adapting such models to the task, but the conceptual framework generalizes beyond diffusion specifically.

Evidence: The maximum acceptance length of 32 tokens (Table 4) and the long-block resurgence effect (Appendix B.1, Figure 7) directly validate the independence hypothesis. If error accumulation were the dominant failure mode, acceptance probability should drop monotonically with draft length—and it does, for AR drafters. For DEER, the probability mass increases at the extreme range (30+ tokens), which is exactly what independence predicts: when a draft survives to extreme lengths, the later tokens were generated independently of the early ones, so their quality does not degrade with position.

Innovation 3: The Discovery That Diffusion Models Trained for Joint Reconstruction Can Be Converted to Prefix-Conditioned Continuation Models Through Targeted Fine-Tuning — A Bridging of Two Previously Separate Paradigms

The paper's third contribution is empirical and methodological rather than purely conceptual: it demonstrates that diffusion language models—which were designed and trained for global sequence generation, not causal continuation—can be repurposed as efficient drafters for autoregressive models through a specific two-stage training procedure whose design is directly motivated by the structure of speculative decoding. This is significant because it bridges a gap that previously made the diffusion + speculative decoding combination impractical.

Prior to DEER, the relationship between diffusion LMs and AR LMs was largely one of competition: diffusion models were proposed as alternatives to AR models for text generation, with debates centered on which paradigm would ultimately prove superior for quality, diversity, and controllability. The two model classes were trained on fundamentally different objectives (joint reconstruction vs. causal next-token prediction), operated with different generation procedures (iterative denoising vs. left-to-right sampling), and produced different types of errors. There was no established recipe for making a diffusion model behave like an AR model in a specific, targeted way—to generate as if it were sampling from p_AR(y | x) without actually being an AR model.

The SDD work (Christopher et al., 2025) had attempted this combination before, but in continuous space with multi-step denoising, which introduced its own alignment drift through discretization error. DEER's contribution is not simply "use discrete space" but rather the insight that the alignment can be achieved through supervised imitation on appropriately constructed data, without requiring the dLLM to internalize the causal mechanism itself. The D2A pipeline does not teach the dLLM to be an AR model—it teaches the dLLM to produce the tokens that an AR model would produce, by training on truncated teacher answers with a [SEP] marker that signals the continuation boundary. This is a subtle but important distinction: the dLLM remains a non-causal model that attends bidirectionally; it simply learns to map "prefix + masked suffix" to "likely AR continuations" through supervised training on teacher outputs.

The methodological innovation lies in the two-stage decomposition, which maps cleanly onto the structure of the speculative decoding problem:

Stage I (AR-style continuation distillation) addresses the macro-level mismatch: the dLLM must learn that the region after [SEP] should be generated from the prefix alone, without relying on future context that a joint denoising objective would provide. The random truncation of teacher answers forces this learning across all possible continuation lengths.
Stage II (scribe refinement) addresses the micro-level sensitivity of speculative decoding: the first few tokens after the prefix are disproportionately important for acceptance because they gate the entire remaining block. The exponential weighting concentrates the model's representational capacity where the marginal return in acceptance length is highest.

Neither stage alone is novel from a pure ML perspective—truncated-answer training and position-dependent loss weighting are both standard techniques. The novelty is in recognizing that this specific combination addresses the specific failure modes that make dLLM drafting impractical, and in the empirical demonstration that the combination works across model scales and domains (code generation and math reasoning, Sections 4.2 and 4.6) despite the dLLM being far from converged in the math experiments (trained for only 40 epochs on UltraChat, yielding a model whose standalone generations are "not yet semantically reliable" per Section 4.6).

This is an incremental-methodological contribution with fundamental implications. The specific two-stage recipe may be superseded by better alignment techniques, but the core finding—that diffusion models can be repurposed as AR-aligned drafters through supervised training on appropriately structured data, without modifying the target model—opens a new class of speculative decoding systems. It also suggests a more general principle: the generative mechanism of the drafter (how it produces its proposals) can be decoupled from the generative mechanism of the verifier (how it evaluates those proposals), as long as an alignment bridge exists between their output distributions. This principle could extend beyond diffusion models to other non-causal generative architectures.

Evidence: The ablation in Table 3 quantifies the contribution of Stage II (+0.5 to +1.2 tokens in acceptance length across benchmarks), while the math reasoning results in Table 6 demonstrate that the approach works even when the underlying dLLM is severely undertrained—DEER achieves 1.89× → 2.12× speedup improvement on Math500 despite the drafter being only partially converged. This suggests the alignment pipeline is robust to drafter quality: it can extract useful drafting behavior from a dLLM that would be unacceptable as a standalone generator, which is precisely the regime that makes speculative decoding practical (the drafter doesn't need to be good at generation; it just needs to be good at mimicking the target's continuations).

Innovation 4: The Empirical Finding That Test-Time Compute Scaling via Speculative Decoding Shows Inverse Scaling with Target Model Size for Diffusion Drafters — Larger Target Models Make Diffusion Drafting Easier, Not Harder

The paper's fourth contribution is an empirical finding with practical implications for how organizations should think about deploying speculative decoding across model scales. The dominant assumption in the speculative decoding literature—implicit in the design of methods like Medusa and EAGLE, which attach draft heads to the target's hidden states—is that drafting becomes harder as the target model gets larger and more capable, because the gap between a small drafter's predictions and a large target's sophisticated distribution widens. This assumption leads to the natural conclusion that speculative decoding is most beneficial for mid-sized models and becomes less attractive for frontier-scale models.

DEER's results invert this expectation. Figure 8 (Appendix B.2) and the per-model-scale comparisons in Tables 1 and 2 show that the same 0.5B-parameter dLLM drafter achieves monotonically increasing acceptance lengths as the target model scales from 8B to 14B to 30B parameters. On HumanEval with block size 32, average acceptance length grows from ~4.3 (Qwen3-8B) to ~5.2 (Qwen3-14B) to ~6.6 (Qwen3-30B-A3B)—a more than 50% increase. The speedup similarly scales: 2.97× → 3.59× → 5.54× (Table 2).

The paper's explanation for this effect is subtle and directly tied to the independence property. Larger AR models tend to have more peaked output distributions—their top-1 token probability is higher because they are more confident in their predictions. This "output determinism" means that the target's continuation from a given prefix is more predictable: there's less entropy in the distribution that the dLLM needs to match. For a diffusion drafter, which predicts all tokens from the prefix simultaneously, this lower entropy directly translates into higher per-token accuracy, because the dLLM only needs to capture the target's high-probability modes rather than the full distributional spread.

For an AR drafter, this benefit is attenuated by the collapse mechanism. A larger AR target is indeed more predictable given the correct prefix, but an AR drafter conditions on its own erroneous drafts, which push the conditioning context into regions where the target's sharp distribution makes the mismatch more severe. The target's determinism is a double-edged sword: it makes the correct continuation more predictable, but it also makes the rejection more likely when the draft is wrong, because the target's peaked distribution assigns near-zero probability to tokens outside its narrow expected path. AR drafters experience this as a ceiling on acceptance length regardless of model scale (EAGLE-3 maxes out at 7–8 tokens even for Qwen3-30B-A3B; Table 4).

This finding has direct practical significance for deployment economics. If speculative decoding benefits increased with target model size (as the AR drafter paradigm implicitly assumes they don't), then the economic case for adopting speculative decoding is strongest precisely where it matters most—for the largest, most expensive models whose inference costs dominate production budgets. A 5.54× speedup on a 30B-parameter model (DEER on Qwen3-30B-A3B, HumanEval, temperature=0) is worth far more in absolute GPU-hours saved than the same speedup on an 8B model. The paper's scaling trend suggests that the strongest use case for DEER is with frontier-scale models, not mid-scale ones—a reversal of the intuitive expectation that speculative decoding is a small-model optimization.

This is an empirical contribution with fundamental implications for resource allocation. It reframes the speculative decoding design space: rather than treating the drafter's capacity as the primary bottleneck (which would suggest scaling the drafter with the target), the results suggest that target determinism is the primary lever, and architectures that can exploit it without suffering from error propagation will see compounding benefits at scale. This predicts that diffusion drafting will become more attractive, not less, as frontier models continue to grow—a non-obvious trajectory that shapes what problems the field should prioritize.

Evidence: Tables 1 and 2 provide the raw speedup and acceptance length numbers across model scales, showing the monotonic improvement with target size. Figure 8 confirms the trend specifically for acceptance length as a function of block size, with the gap between Qwen3-8B and Qwen3-30B-A3B widening at larger block sizes (where the independence property's benefit is most pronounced). The finding that EAGLE-3's acceptance length does not scale with target size (it actually drops slightly from 3.31 to 3.05 moving from 8B to 30B in Table 2) provides the contrast condition that isolates the diffusion-specific benefit.

5. Experimental Analysis

Evaluation Methodology

Datasets. For code generation, the paper trains on OpenCodeInstruct (Ahmad et al., 2025) and evaluates on four benchmarks: HumanEval (Chen et al., 2021), MBPP (Austin et al., 2021b), LiveCodeBench (Jain et al., 2024), and the Python subset of CodeAlpaca (Lhoest et al., 2021). For mathematical reasoning, training uses UltraChat (Ding et al., 2023) and ShareGPT (shareAI, 2023), with evaluation on GSM8K (Cobbe et al., 2021), Math500 (Lightman et al., 2023), and Minerva Math (Lewkowycz et al., 2022). The specific training dataset sizes are not reported in the main text, though Appendix A mentions that Stage II code training uses a 100k-example subset.
Base models. Code generation experiments use target AR models from the Qwen3 family at four scales: Qwen3-4B, Qwen3-8B, Qwen3-14B, and Qwen3-30B-A3B, plus Qwen2-7B as an additional baseline (Tables 1–2). The dLLM drafter is consistently a 0.5B-parameter discrete diffusion model based on Open-dLLM (Peng et al., 2025) for code tasks, or Qwen2.5-0.5B-Instruct converted to diffusion for math tasks (Appendix A). The paper states the Qwen3 models are "representative of the capabilities of many contemporary LLMs" (Section 4, implied) and span a wide scale range (4B to 30B) to test generalizability.
Metrics. The paper reports two primary efficiency metrics, both standard in speculative decoding literature: Speedup Ratio — the empirical end-to-end wall-clock speedup compared to standard autoregressive decoding (higher is better), and Average Acceptance Length ( $\tau$ ) — the mean number of draft tokens accepted by the verifier per drafting–verification cycle (higher means fewer cycles needed). The paper explicitly notes that accuracy-based metrics are not reported because DEER's rejection sampling mechanism is provably lossless (Appendix E), so output quality is mathematically identical to direct AR decoding from the target model. Speedup measurements include KV cache overhead where noted (Tables 1–2 use KV cache; Table 5 batch experiments do not).
Baselines. Three state-of-the-art speculative decoding methods are compared: Medusa (Cai et al., 2024) — multiple decoding heads predict tree-structured continuations from the target's hidden states; Hydra (Ankner et al., 2024) — sequentially-dependent draft heads extending Medusa; and EAGLE-3 (Li et al., 2025b) — the most recent and strongest in the EAGLE series, using training-time test-time augmentation to improve draft quality. The paper states it uses "official training code" where publicly available. Baselines are run with the same target models and the same datasets for fair comparison. Note that Medusa and Hydra could not be trained on Qwen3-14B due to out-of-memory errors under their default configurations (Table 8, Appendix D), so Tables 1–2 exclude them at 14B scale.
Generation budget / compute accounting. The primary unit of compute accounting is the draft block size $k$ — the number of tokens the dLLM proposes per cycle. The paper sweeps $k \in \{4, 8, 16, 32\}$ across experiments (Figure 8, Appendix B.2). Fair comparison is achieved through matched evaluations: all methods run on the same hardware (eight NVIDIA A100 80GB GPUs), with the same target models, on the same datasets, and at the same temperatures (0 and 0.6). KV cache is enabled for the main results (Tables 1–2) and disabled for batch experiments (Table 5) to ensure comparability, since dLLMs currently lack mature KV cache support in mainstream frameworks (Appendix F). Training cost is also compared: DEER requires 240 GPU hours on Qwen3-8B vs. 696 hours for EAGLE-3, 768 hours for Medusa, and 1,800 hours for Hydra (Table 8, Appendix D).
Cross-validation / statistical protocol. The paper does not report a formal cross-validation or statistical significance protocol. Results appear to be single-run evaluation on the standard test splits of each benchmark. No confidence intervals, standard deviations, or multiple random seeds are reported for the speedup or acceptance length measurements. This is consistent with standard practice in speculative decoding papers (where measurements are typically deterministic given a fixed temperature and seed), but it means the reported numerical differences—especially the smaller gaps like 0.5 tokens in acceptance length between ablated and full models (Table 3)—should be interpreted as point estimates without quantified uncertainty.

Main Quantitative Results

Overall Efficiency on Code Generation (RQ1): DEER Consistently Doubles Acceptance Length and Speedup Over EAGLE-3

The headline results are presented in Tables 1 and 2, which report speedup and average acceptance length across all four code benchmarks and five model scales, at two temperature settings (0.6 and 0). I will focus on the temperature=0 results (Table 2) as the speedups are generally higher and represent the setting where deterministic target behavior most favors diffusion drafting; the temperature=0.6 results (Table 1) show the same ranking but with slightly reduced absolute speedups.

At Qwen3-30B-A3B (temperature=0), DEER achieves an average acceptance length of 5.03 tokens across all benchmarks, compared to 3.05 for EAGLE-3 — a 65% increase. The per-benchmark breakdown from Table 2:

Benchmark	DEER $\tau$	EAGLE-3 $\tau$	DEER Speedup	EAGLE-3 Speedup
MBPP	4.87	3.07	4.00×	2.22×
CodeAlpacaPy	4.04	2.89	3.08×	2.06×
HumanEval	6.58	3.21	5.54×	2.41×
LiveCodeBench	4.62	3.01	3.52×	2.14×
Mean	5.03	3.05	4.04×	2.21×

The HumanEval result is the standout: a 5.54× speedup, more than doubling EAGLE-3's 2.41×. This is the number highlighted in the abstract and Figure 1. The 6.58-token average acceptance length on HumanEval means that in each draft–verify cycle, the dLLM proposes a block of tokens and the verifier accepts over six of them on average before rejecting one — substantially more than the ~3 tokens EAGLE-3 manages.

Across all model scales (temperature=0), the pattern holds consistently. From Table 2, mean speedup across benchmarks:

Model	DEER Mean Speedup	EAGLE-3 Mean Speedup	DEER Mean $\tau$	EAGLE-3 Mean $\tau$
Qwen3-4B	2.77×	2.40×	4.61	3.31
Qwen3-8B	2.83×	2.48×	4.61	3.45
Qwen2-7B	2.70×	2.43×	4.11	3.22
Qwen3-14B	2.98×	2.39×	4.82	3.54
Qwen3-30B-A3B	4.04×	2.21×	5.03	3.05

Several patterns are notable. First, DEER's speedup advantage grows with target model scale: the gap over EAGLE-3 is 0.37× at 4B, 0.35× at 8B, 0.59× at 14B, and 1.83× at 30B. This matches the paper's claim that larger targets make diffusion drafting easier (Innovation 4 in the prior sections). Second, EAGLE-3's performance plateaus or slightly degrades with scale — its mean speedup drops from 2.40× (4B) to 2.21× (30B) — while DEER's increases from 2.77× to 4.04×. Third, DEER's acceptance length at 4B (4.61) is already higher than EAGLE-3's at any scale, and it further increases to 5.03 at 30B, while EAGLE-3's acceptance length actually decreases from 3.31 (4B) to 3.05 (30B).

At temperature=0.6 (Table 1), the absolute speedups are lower due to the stochasticity introduced by higher temperature (which makes both drafting and verification noisier), but the ranking and relative advantage of DEER persist. Mean speedups at 0.6: 2.52× (DEER) vs. 1.91× (EAGLE-3) at 4B, scaling to 3.62× vs. 2.01× at 30B. The gap is still large at the top end (1.61× difference) but compressed relative to temperature=0.

Comparison with weaker baselines. At temperature=0 (Table 2, Qwen3-4B and Qwen3-8B where Medusa and Hydra are available), the ranking is consistently: DEER > EAGLE-3 > Hydra > Medusa. On Qwen3-8B, the mean speedups are 2.83× (DEER), 2.48× (EAGLE-3), 2.25× (Hydra), and 1.32× (Medusa). The gap between DEER and Hydra is substantial (0.58×), and Medusa barely exceeds 1.3×, suggesting that simpler draft head approaches are severely limited on these models.

The role of temperature. Comparing Tables 1 and 2, temperature has a larger effect on EAGLE-3 than on DEER. Moving from temperature=0 to 0.6:

DEER: speedup drops from 2.77× to 2.52× at 4B (9% decrease), and from 4.04× to 3.62× at 30B (10% decrease)
EAGLE-3: speedup drops from 2.40× to 1.91× at 4B (20% decrease), and from 2.21× to 2.01× at 30B (9% decrease)

The larger drop for EAGLE-3 at smaller scales is consistent with the collapse mechanism being exacerbated by stochastic sampling — when the draft tokens are sampled at higher temperature, early errors are larger and propagate more aggressively through the chain. DEER's independence property makes it more robust to temperature because draft quality at each position depends only on the prefix, not on other draft tokens' stochasticity.

Acceptance Length Distribution Analysis: DEER Reshapes the Distribution Toward Long Accepted Blocks

The paper goes beyond averages to examine the distribution of accepted token lengths (Figures 4 and 7, Appendix B.1), which reveals how DEER achieves its gains — not by slightly improving every cycle, but by enabling a significant fraction of cycles to accept very long blocks that are essentially impossible for AR drafters.

Figure 4 (main text) shows the proportion of cycles where the accepted length is short (<8 tokens) vs. long (≥8 tokens) across three model scales at temperature=0:

Model	DEER: <8 tokens	DEER: ≥8 tokens	EAGLE-3: ≥8 tokens (implied from Table 4)
Qwen3-4B	84.2%	15.8%	~0% (max is 8)
Qwen3-8B	84.1%	15.9%	~0%
Qwen3-14B	83.5%	16.5%	~0%

The consistent 15–16% of cycles accepting ≥8 tokens is remarkable because EAGLE-3's maximum acceptance length is 7–8 tokens (Table 4) — it cannot produce any cycles with ≥8 accepted tokens. DEER essentially adds a long-tail of high-productivity cycles on top of the baseline short-cycle performance. This explains the speedup advantage: even if most cycles are similar in length, the 15% of long cycles contribute disproportionately to throughput because they replace multiple short cycles with a single draft–verify step.

Table 4 (main text) reports the maximum acceptance length observed:

Model	EAGLE-3 Max	DEER Max
Qwen3-4B	8	32
Qwen3-8B	8	32
Qwen3-14B	8	32
Qwen3-30B-A3B	7	32

DEER's maximum of 32 tokens is a hard cap set by the block size — the dLLM proposes at most 32 tokens per cycle, so it cannot exceed this. The fact that it reaches this cap on all models (and presumably could go higher with larger block sizes) while EAGLE-3 plateaus at 7–8 regardless of model scale is strong evidence for the structural interpretation: AR drafters face a fundamental ceiling that diffusion drafting overcomes.

Figure 7 (Appendix B.1) provides the full empirical distribution of acceptance lengths (log-scale frequency vs. length) for Qwen3-8B, Qwen3-14B, and Qwen3-30B-A3B across all four benchmarks. The paper highlights a phenomenon it terms the long-block resurgence effect: for acceptance lengths below approximately 30, the distribution follows an approximately exponential decay (common to most speculative decoding methods), but as the length approaches the maximum (30+), the probability mass increases again. The paper interprets this as evidence that when a draft survives to extreme lengths, the later tokens — which were generated independently of the early ones — are actually more likely to survive verification than mid-length tokens, because the dLLM's global modeling of the continuation captures long-range coherence that aligns with the verifier's expectations.

This resurgence is visible in all three subfigures (7a–c) and is most pronounced for Qwen3-30B-A3B (7c), where the probability mass at length 30 is noticeably higher than at lengths 15–25. This directly supports the independence hypothesis: if error accumulation were occurring, the probability should decrease monotonically (or at least smoothly approach zero at the maximum), not bounce back up.

Scaling of Acceptance Length with Block Size: Larger Blocks Enable Longer Accepted Sequences, Especially for Larger Target Models

Figure 8 (Appendix B.2) examines how the average acceptance length changes as the block size $k$ increases from 4 to 32, evaluated on HumanEval. The results (approximate values read from the figure):

Block size $k$	Qwen3-8B $\tau$	Qwen3-14B $\tau$	Qwen3-30B-A3B $\tau$
4	~3.5	~4.0	~4.0
8	~4.0	~4.5	~5.0
16	~4.2	~4.9	~5.8
32	~4.3	~5.2	~6.6

Three findings emerge. First, acceptance length increases monotonically with block size at all scales — larger blocks give the verifier more tokens to potentially accept, and the dLLM's proposals are good enough that some fraction of the additional tokens survive verification. Second, the growth rate shows diminishing returns: the gain from 16→32 is smaller than from 4→8 in absolute terms (though still substantial at 30B). Third, the scaling is more favorable for larger target models: the total improvement from $k=4$ to $k=32$ is approximately 0.8 tokens for Qwen3-8B, 1.2 tokens for Qwen3-14B, and 2.6 tokens for Qwen3-30B-A3B. This interaction — block size benefit compounds with target scale — is attributed to the paper's finding that larger models have more deterministic outputs, which the dLLM can fit more precisely when given enough draft slots to capture longer-range patterns.

The practical implication: for smaller targets, a block size of 8–16 captures most of the achievable gains, while for larger targets, pushing to 32 (or potentially beyond) yields meaningful additional improvement. The paper does not explore block sizes beyond 32, so the saturation point is not characterized.

Batch Inference Scalability (RQ3): DEER's Throughput Advantage Grows with Batch Size

Table 5 reports batch inference performance on HumanEval across batch sizes 2, 4, 8, and 16, measured in tokens per second without KV cache:

Batch Size	AR Baseline (tokens/s)	DEER (tokens/s)	Speedup
2	34.03	82.97	2.44×
4	32.50	103.95	3.20×
8	38.35	159.87	4.17×
16	49.76	175.66	3.53×

The absolute throughput of both methods increases with batch size (GPU utilization improves), but DEER's improvement is steeper: from 82.97 tokens/s at batch 2 to 175.66 at batch 16, versus 34.03 to 49.76 for the AR baseline. The speedup ratio peaks at batch 8 (4.17×) and slightly declines at batch 16 (3.53×), though the absolute throughput continues to increase.

The paper attributes this scaling behavior to DEER's ability to better exploit GPU parallelism: "one-step draft generation combined with parallel verification allows DEER to better exploit GPU parallelism, especially at larger batch sizes" (Section 4.4). The modest efficiency gap at batch 2 (2.44×, lower than the single-sequence speedups in Tables 1–2) is attributed to "fixed speculative-decoding overheads" that become proportional to batch size — at small batches, the dLLM's forward pass overhead dominates, while at larger batches, the verification parallelism amortizes it.

A limitation: these batch experiments do not use KV cache for either method, which the paper acknowledges is due to the lack of mature dLLM KV cache support in existing frameworks (Appendix F). The single-sequence results in Tables 1–2 do use KV cache, so the batch results are not directly comparable to the main speedup numbers. The paper expects that once dLLM KV cache is available, batch performance will improve further, since the dLLM would not need to recompute attention over the growing prefix.

Performance on Mathematical Reasoning (RQ5): DEER Generalizes Beyond Code Even with a Weakly Trained dLLM

Table 6 reports results on math benchmarks using Qwen3-30B-A3B as the target (temperature=0.6). The drafter is a Qwen2.5-0.5B-Instruct model converted to diffusion and trained for only 40 epochs on UltraChat, producing a dLLM whose "standalone generations are not yet semantically reliable" (Section 4.6):

Benchmark	Metric	EAGLE-3	DEER	DEER Improvement
Math500	Speedup	1.89×	2.12×	+12.2%
	$\tau$	2.04	2.45	+20.1%
GSM8K	Speedup	1.92×	2.23×	+16.1%
	$\tau$	2.43	2.70	+11.1%
Minerva Math	Speedup	1.91×	2.02×	+5.8%
	$\tau$	2.07	2.31	+11.6%
Mean	Speedup	1.91×	2.12×	+11.0%
	$\tau$	2.18	2.47	+13.3%

The speedups are notably lower than on code benchmarks (2.12× mean vs. 3.62× for code at temperature=0.6 on Qwen3-30B-A3B in Table 1), which is expected: the dLLM is severely undertrained (40 epochs vs. the fully trained code drafter), math problems require more precise symbolic manipulation than code generation where syntactic patterns are easier to capture, and the target model's output distribution on math is likely less deterministic than on code (giving the dLLM a harder target to fit).

Despite these disadvantages, DEER consistently outperforms EAGLE-3, improving speedup by 5.8–16.1% depending on the benchmark and acceptance length by 11.1–20.1%. This is significant because it demonstrates that the diffusion drafting mechanism is robust to dLLM quality: even a drafter that cannot reliably generate correct answers on its own still provides useful proposals that the verifier accepts at higher rates than an AR drafter. The paper frames this as evidence that "the one-step drafting mechanism produces stable, high-quality proposals for the verifier" even when the underlying dLLM is far from converged.

The math results serve as an out-of-domain generalization test. The code drafter was trained on OpenCodeInstruct, a code-specific dataset, while the math drafter was trained on UltraChat, a general instruction-following dataset, then evaluated on math benchmarks that require different reasoning patterns. The fact that DEER still outperforms EAGLE-3 in this setting (despite the dLLM being under-trained) suggests the independence property provides a baseline advantage that does not depend on the dLLM being highly specialized to the target domain.

Maximum Acceptance Length and the Long-Block Resurgence Effect: Direct Evidence for the Independence Hypothesis

The paper's central theoretical claim — that diffusion drafting eliminates uncertainty accumulation — makes a specific empirical prediction: the quality of draft tokens should not degrade with position in the block. If this prediction holds, we should observe (1) maximum acceptance lengths far exceeding what AR drafters achieve, and (2) a non-monotonic acceptance distribution where extreme-length blocks are more likely than mid-length blocks (because the dLLM's global modeling produces coherent long-range structure that the verifier accepts wholesale).

Prediction 1: Maximum acceptance length. Table 4 shows DEER reaches 32 tokens (the block size cap) on all models, while EAGLE-3 is limited to 7–8. This is a binary result — DEER can propose and have accepted blocks that are 4× longer than the AR drafter's absolute ceiling. The fact that the maximum equals the block size (not lower) on all models suggests the cap is the block size itself, not some intrinsic quality limit of the dLLM's proposals. The paper does not test larger block sizes, so the true maximum (where acceptance probability drops to zero) is unknown, but it is at least well beyond 32.

Prediction 2: Long-block resurgence. Figure 7 (Appendix B.1) shows exactly this pattern. Across all model scales and all four code benchmarks, the empirical distribution of acceptance lengths follows an initial exponential decay (common to all speculative decoding methods, reflecting the compounding probability of surviving verification at each position), but then increases as the acceptance length approaches 30–32 tokens. This is most visible in the Qwen3-30B-A3B panel (Figure 7c), where the log-scale frequency at length ~30 is noticeably higher than at lengths ~15–25.

The paper's explanation for this effect (Section 4.2.2 and Appendix B.1) is that the dLLM's global, non-causal modeling can capture long-range dependencies in the continuation that manifest as block-level coherence. When the verifier encounters a draft that has survived to position 25, the next tokens are not degraded by errors at positions 1–24 (since they were generated independently); instead, they reflect the dLLM's holistic understanding of what the continuation should look like, which — for some fraction of prompts — aligns well with the verifier's expectations. The verifier then accepts a long run of tokens, creating the resurgence at the distribution's tail.

This is direct evidence against the uncertainty accumulation hypothesis in the DEER setting. If draft error propagated with position, the distribution would be monotonically decreasing (possibly with a sharp drop-off where errors compound past a threshold). The non-monotonic shape is only possible if draft quality is approximately position-independent, with some prompts happening to align well globally and producing long accepted runs.

Ablation Studies and Robustness Checks

Impact of Stage II refinement (Table 3): Enabling Stage II consistently increases average acceptance length across all four code benchmarks on Qwen3-30B-A3B: MBPP (+0.13 tokens, 4.74→4.87), CodeAlpacaPy (+0.57, 3.47→4.04), HumanEval (+1.20, 5.38→6.58), and LiveCodeBench (+1.16, 3.87→5.03). The gain is largest on the most structurally complex benchmarks (HumanEval and LiveCodeBench), supporting the claim that refinement sharpens alignment at the prefix boundary where syntactic constraints are tightest. The gain on MBPP (+0.13) is notably small — the paper does not discuss why, but MBPP may contain simpler, more formulaic continuations where Stage I alignment is already sufficient.
Sensitivity to exponential weighting factor $\alpha$ (Figure 6): The Stage II hyperparameter $\alpha$ controls how aggressively the loss emphasizes tokens near the prefix. At $\alpha = 1.01$ , training is stable and loss decreases smoothly. At $\alpha = 1.02$ , the loss curve becomes noisier with slight upward drift — marginal stability. At $\alpha = 1.05$ , the loss diverges early, indicating that aggressive exponential weighting destabilizes optimization. This is attributed to gradient amplification: the weight ratio between the first and last masked token is $\alpha^{R-1}$ , which for $R=96$ and $\alpha=1.05$ is $1.05^{95} \approx 103\times$ — effectively ignoring late tokens entirely. The paper's chosen $\alpha=1.01$ keeps this ratio around 2.57×. This ablation demonstrates that the refinement stage operates in a narrow stability window, and that practitioners cannot simply increase $\alpha$ to achieve stronger refinement — the optimization diverges if the emphasis becomes too skewed.
Block size scaling (Figure 8): The average acceptance length increases monotonically with block size $k$ across all model scales, confirming that the dLLM can productively use larger draft windows. The interaction with model scale (larger targets benefit more from larger blocks) is discussed in the main results above. The paper does not ablate the maximum block size (32) to find the saturation point — it's possible that even larger blocks would yield further acceptance length improvements for Qwen3-30B-A3B, since the curve at $k=32$ does not appear to have fully flattened in Figure 8c.
Robustness to target model family (Qwen2-7B vs. Qwen3 models): Table 2 includes Qwen2-7B alongside Qwen3 models. DEER achieves 2.70× mean speedup with $\tau=4.11$ on Qwen2-7B, compared to 2.43× and 3.22 for EAGLE-3. This demonstrates that the approach generalizes across model generations (not just Qwen3), though the improvement over EAGLE-3 is smaller (0.27×) than on Qwen3 models at similar scale (0.35× on Qwen3-8B). The paper does not explore why, but Qwen2's output distribution may be less deterministic than Qwen3's, reducing the diffusion drafter's advantage.
Robustness to domain (math vs. code): The math results (Table 6) demonstrate generalization to a different domain with a different dLLM base model, different training data, and a different target distribution (mathematical reasoning vs. code). The speedup advantage over EAGLE-3 (1.91× → 2.12×, +11%) is smaller than for code (2.01× → 3.62×, +80% on the same Qwen3-30B-A3B target at temperature=0.6), but the direction is consistent. The paper attributes the reduced gain to the severely undertrained dLLM (40 epochs on general instruction data), not to a fundamental domain limitation.
Drafter size comparison (Table 7, Appendix C): To rule out the concern that DEER's gains come simply from using a larger drafter, the paper compares parameter counts. On Qwen3-8B, DEER's drafter (470M) is slightly larger than EAGLE-3's (400M). On Qwen3-14B, EAGLE-3's drafter (610M) is larger than DEER's (470M). On Qwen3-30B-A3B, DEER (470M) is larger than EAGLE-3 (140M). Despite these cross-overs, DEER consistently outperforms EAGLE-3 at all scales, including the 14B case where DEER's drafter is smaller. This suggests the mechanism (parallel independent drafting) rather than raw drafter capacity drives the gains.
Training cost (Table 8, Appendix D): DEER requires 240 GPU hours to train on Qwen3-8B, compared to 696 hours for EAGLE-3, 768 hours for Medusa, and 1,800 hours for Hydra. This makes DEER the cheapest to train among the AR drafter methods (by a factor of ~3× vs. EAGLE-3), while achieving the highest speedups. The paper attributes this efficiency to the simplicity of the supervised diffusion objective compared to training AR draft heads that must mimic the target's hidden state dynamics. On Qwen3-14B, Medusa and Hydra could not be trained due to out-of-memory errors under their default configurations, while DEER and EAGLE-3 both succeeded, with DEER again being substantially cheaper (240 vs. 1,440 GPU hours).
Losslessness proof (Appendix E): While not an empirical ablation, the paper provides a formal proof (Theorem E.2) that DEER's decoding procedure produces exactly the same output distribution as direct AR sampling. The proof adapts the standard speculative decoding analysis (Leviathan et al., 2023) to the case where the proposal distribution $q_\theta(\cdot \mid x_{1:j})$ is conditioned only on the original prefix, not on intermediate drafts. The support condition (the drafter never assigns zero probability where the target has positive probability) is argued to hold by construction of the D2A training, though this is not empirically verified. No quality degradation experiments are reported (output accuracy would be identical by construction, so there is nothing to measure).
Negative result: ReST $^{EM}$ training for revision models (not applicable): The paper does not train revision models or use ReST $^{EM}$ , so the negative revision result from the reference example paper is not relevant here. However, a relevant negative result is implicitly present: the math dLLM trained for 40 epochs produces "standalone generations [that] are not yet semantically reliable" (Section 4.6), yet still serves as a useful drafter. This is actually a positive result for the framework (robustness to drafter quality), but it also implies that fully training a dLLM from scratch for a new domain is expensive and may not be necessary — a partially trained model suffices for drafting purposes. The paper does not ablate the number of training epochs to find the minimum required for useful drafting, which would help practitioners decide how much to invest in drafter training for new domains.

Critical Assessment

The paper makes four central claims that structure the experimental narrative. I assess each against the reported evidence.

Claim 1: "DEER eliminates the gradual collapse of trust, enabling substantially longer accepted drafts than AR drafters."

The evidence directly supports a strong version of this claim, with two important qualifications.

What was demonstrated: DEER achieves maximum acceptance lengths of 32 tokens while EAGLE-3 reaches only 7–8 (Table 4) — a 4× improvement in the ceiling. The average acceptance length is 65–100% higher depending on model scale and benchmark (Tables 1–2). The long-block resurgence effect (Figure 7) provides mechanistic evidence that acceptance probability does not degrade monotonically with position, which is the empirical signature of eliminated uncertainty accumulation.

Conditions and caveats:

The maximum of 32 is a hard cap set by the block size, not a measured ceiling. The true maximum acceptance length for DEER is unknown and could be higher with larger block sizes. This means the 4× figure (32 vs. 8) is a lower bound on the improvement — the real ceiling for DEER might be substantially above 32, while EAGLE-3's ceiling of 7–8 appears to be a genuine limit (it doesn't increase with model scale or block size).
The paper does not provide a direct mechanistic measurement of uncertainty accumulation. For example, it does not plot acceptance probability as a function of position in the draft block for DEER vs. EAGLE-3 on the same prompts. Such a plot would directly visualize the collapse effect and its elimination. The distribution in Figure 7 provides indirect evidence (the resurgence), but a per-position breakdown would be more informative.
The "gradual collapse of trust" is framed as an architectural inevitability of AR drafters, but the paper only compares against EAGLE-3 (the strongest AR drafter). It does not compare against other AR drafter designs that might partially mitigate collapse, such as drafters that use nucleus sampling to stay within the target's high-probability region, or drafters that recompute conditioning on verified tokens mid-block. The claim that collapse is inherent to any AR drafter architecture is not tested — only that it occurs in the specific AR drafters evaluated.

What would strengthen the claim: A direct comparison of per-position acceptance probability for DEER vs. EAGLE-3 on the same set of prompts, ideally with a control experiment where the AR drafter is given access to the verified prefix at each step (breaking the dependency chain) to isolate the contribution of error accumulation vs. inherent drafter accuracy limits.

Claim 2: "The two-stage D2A alignment pipeline transforms a dLLM into an effective prefix-conditioned drafter."

The evidence supports this claim but does not fully isolate which components of the two-stage pipeline are necessary.

What was demonstrated: Stage II provides a measurable improvement in acceptance length (+0.13 to +1.20 tokens depending on benchmark, Table 3). The math results show that even a severely undertrained dLLM can serve as a useful drafter after D2A alignment (Table 6). The training cost analysis (Table 8) shows the pipeline is practical.

Conditions and caveats:

The paper only ablates Stage II (Table 3), not the data construction choices within Stage I (random truncation, SEP token placement, masking strategy). It is unclear whether the specific data format (random truncation + SEP) is necessary, or whether simpler alternatives (e.g., always truncating at a fixed point, or using a different boundary marker) would work equally well.
The paper does not compare D2A alignment against alternative approaches for adapting dLLMs to prefix-conditioned continuation, such as: (a) fine-tuning on non-truncated completions with causal masking, (b) using the dLLM in a multi-step denoising mode where each step refines the continuation (as in standard diffusion generation), or (c) training the dLLM from scratch on prefix-conditioned data rather than fine-tuning a pre-trained joint model. Without these comparisons, we know D2A works, but not whether it is the best approach or just an approach.
The hyperparameter sensitivity of Stage II (Figure 6) is a practical concern: the stability window for $\alpha$ is narrow, and practitioners training on new domains may need to tune this carefully to avoid divergence. The paper does not provide guidance on how to select $\alpha$ for a new setting beyond showing that 1.01 works for code.
The paper claims Stage I teaches the dLLM that "the future must be predicted" from the prefix alone (Section 3.1.1). But the Stage I training data includes the kept portion of the answer before the SEP token — the dLLM can see some of the continuation during training (just not the masked suffix). This means the model still learns to condition on some future context, which is different from pure prefix-conditioned generation. The paper does not ablate whether including the kept answer portion helps (by providing additional context) or hurts (by allowing the model to rely on future tokens that won't be available at inference time).

What would strengthen the claim: Ablation of the key design choices in Stage I data construction (truncation strategy, inclusion of kept answer tokens, SEP marker vs. alternatives), comparison against at least one alternative alignment approach, and guidance on $\alpha$ selection for new domains.

Claim 3: "DEER achieves 5.54× speedup on HumanEval with Qwen3-30B-A3B, far exceeding EAGLE-3's 2.41×."

This is the headline number and is directly supported by Table 2 (temperature=0). However, the framing deserves scrutiny.

What was demonstrated: On HumanEval with Qwen3-30B-A3B at temperature=0, DEER achieves 5.54× speedup vs. 2.41× for EAGLE-3. This is the highest single-datapoint speedup in the paper and is highlighted in the abstract and Figure 1.

Conditions and caveats:

Temperature dependence: At temperature=0.6 (Table 1), the speedup drops to 4.32× for DEER and 2.14× for EAGLE-3 — still a large gap (2.0×), but the absolute DEER number is 22% lower. The 5.54× figure represents the best-case scenario (greedy decoding), which may not be representative of typical usage where sampling is employed for diversity.
Benchmark variability: The 5.54× is the highest speedup across all benchmarks. The mean across all four code benchmarks at Qwen3-30B-A3B is 4.04× (Table 2), and on the weakest benchmark (CodeAlpacaPy) it is 3.08×. The paper's abstract highlights the maximum, not the mean — this is standard practice but can be misleading if readers miss the variability.
KV cache availability: The main results (Tables 1–2) use KV cache for the AR verifier, which is standard. However, the dLLM drafter currently lacks KV cache support (Appendix F). This means the dLLM recomputes attention over the entire growing prefix for each draft cycle, which is an inefficiency that AR drafters like EAGLE-3 do not suffer from (they can cache the target's hidden states and their own draft head states). The speedup numbers already account for this disadvantage — DEER's speedups are measured end-to-end including the dLLM's repeated forward passes. If and when dLLM KV cache becomes available, DEER's speedups will likely improve further. This means the reported 5.54× is actually a lower bound on what the approach can achieve with optimized infrastructure, which is unusual (most methods report upper-bound speedups in idealized conditions).
Hardware and framework: All experiments use eight NVIDIA A100 80GB GPUs, but the paper does not specify whether the speedup measurements are single-GPU or multi-GPU, or whether model parallelism is used for the larger targets. This matters because multi-GPU communication overhead can reduce speedups. The paper also does not describe whether the inference is implemented in a custom framework or using standard libraries (vLLM, SGLang), which affects reproducibility of the exact speedup numbers.
Single datapoint: The 5.54× is a single number on a single benchmark with a single model. The paper does not provide confidence intervals or report variance across multiple runs. On a 500-problem test set (HumanEval), the variation in per-problem speedup could be substantial (some problems accept long blocks, some accept short ones). The average is reported, but the distribution of per-problem speedups is not — it would be informative to know whether the 5.54× is driven by a few outlier prompts with very long accepted blocks (the 15% of ≥8-token cycles in Figure 4) or is representative of typical decoding.

What would strengthen the claim: A histogram or distribution of per-prompt speedups to characterize variability, benchmarks at additional temperature settings to map the temperature-speedup tradeoff curve, and specification of the hardware configuration (GPUs, parallelism strategy, framework) used for timing measurements.

Claim 4: "The efficient parallel decoding strategy of dLLM drafters naturally overcomes the limitations of sequential AR drafters."

The evidence supports this claim at a high level, but the paper conflates two separate mechanisms — independence (no error propagation) and parallelism (single forward pass) — that should be distinguished.

What was demonstrated: The independence mechanism is directly evidenced by the long-block resurgence effect (Figure 7) and the 32-token maximum acceptance length (Table 4). The parallelism mechanism is evidenced by the speedup numbers (Tables 1–2) and the batch scaling results (Table 5). However, the paper does not isolate how much of the speedup comes from independence (longer accepted blocks → fewer verification cycles) versus pure parallelism (faster draft generation per token).

Conditions and caveats:

The two mechanisms are conceptually distinct: a hypothetical AR drafter that generated tokens in parallel (e.g., using Jacobi iteration or parallel decoding) would get the parallelism benefit but still suffer uncertainty accumulation. Conversely, a non-parallel non-AR drafter that generated tokens sequentially but independently (e.g., generating each position from the prefix alone, one at a time) would eliminate uncertainty accumulation but lose the parallelism benefit. DEER gets both, but the paper does not provide an experiment that separates their contributions. The comparison with EAGLE-3 captures the combined advantage, but we cannot tell whether most of the gain comes from longer acceptance lengths (independence) or faster draft generation (parallelism), or whether both are necessary.
The draft generation time is not reported separately from the verification time. We do not know what fraction of the total latency is spent in the dLLM forward pass vs. the AR verifier forward pass. If the dLLM is very fast (it is 0.5B parameters vs. 8–30B for the target), the parallelism benefit may be small relative to the independence benefit. Conversely, if the dLLM is slower than expected (e.g., due to lack of KV cache optimization), the longer accepted blocks from independence may be the main driver, and parallelism is partially offset by the dLLM's repeated forward passes.
The paper's framing — "diffusion models... generate an entire sequence of tokens in a single denoising process" (Section 1) — could be read as claiming that diffusion generation is inherently faster than AR generation. This is not necessarily true: a single forward pass of a diffusion model that generates 32 tokens may be more expensive than 32 forward passes of a small AR model, depending on the model sizes and architectures. The speedup comes not from diffusion being inherently faster per se, but from the combination of parallelism (fewer forward passes) and independence (more accepted tokens per pass). The paper does not provide a FLOPs or latency breakdown that would clarify this.

What would strengthen the claim: An experiment that separately measures draft generation time and verification time, an ablation that uses the same dLLM in multi-step mode (breaking parallelism while preserving independence) to isolate the parallelism contribution, and a FLOPs-matched comparison between DEER and EAGLE-3 at equal computational budgets (not just equal wall-clock time on the same hardware).

Overall assessment:

The paper's empirical design is thorough for a systems paper — it covers multiple model scales (4B to 30B), multiple benchmarks (4 code + 3 math), multiple temperatures (0 and 0.6), and multiple baselines (Medusa, Hydra, EAGLE-3). The core finding — that diffusion drafting produces longer accepted blocks and higher speedups than AR drafting — is consistently replicated across all conditions tested. The ablation of Stage II (Table 3) and the hyperparameter sensitivity analysis (Figure 6) provide some insight into which design choices matter.

The main weaknesses are: (1) the lack of a direct mechanistic measurement of uncertainty accumulation (per-position acceptance probability), which would directly validate the paper's central conceptual contribution; (2) the absence of a separation between the independence and parallelism mechanisms, making it unclear which architectural property drives the gains; (3) the reporting of single-datapoint speedup numbers without variance estimates, which is standard in speculative decoding papers but limits the statistical interpretability of the results; (4) the narrow ablation — only Stage II, $\alpha$ , and block size are varied, while many other design choices (Stage I data construction, SEP token, single-step vs. multi-step inference, dLLM architecture) are untested.

A notable strength is the honest reporting of infrastructure limitations: the paper explicitly notes that dLLM KV cache is not available (Appendix F), that the math dLLM is severely undertrained (Section 4.6), and that Medusa and Hydra could not be trained at 14B scale (Table 8). This transparency about what didn't work or couldn't be done strengthens credibility.

The batch inference results (Table 5) and the training cost comparison (Table 8) add practical value beyond the headline speedup numbers, addressing deployment and adoption concerns that practitioners care about.

A final observation: the paper does not report any quality metrics (e.g., pass@1 on HumanEval). This is justified by the losslessness proof (Appendix E) — DEER's output is mathematically identical to the target AR model, so there is nothing to measure. However, verifying this empirically (e.g., by running both DEER and AR decoding on the same prompts with the same random seed and confirming identical outputs) would be a useful sanity check, and would catch any implementation bugs in the acceptance/rejection mechanism. The paper trusts the proof but does not empirically validate that the implementation matches it.

6. Limitations and Trade-offs

Latency vs. Throughput: Sequential Verification Creates a Serial Bottleneck That Parallel Drafting Cannot Eliminate

The paper frames DEER as overcoming the "inherently sequential decoding" of AR drafters (Section 1, Problem 2), but this is only half the story. The verification step remains inherently sequential in speculative decoding: even though the dLLM proposes all k tokens in parallel, the AR verifier must accept or reject them one at a time from left to right because each acceptance decision changes the prefix for subsequent positions (the residual sampling at position j+i alters the conditioning context for position j+i+1). The paper acknowledges this explicitly in the inference description (Section 3.2): "the AR model then decides, token by token, whether to accept each proposal," and Algorithm 1 (lines 4–15) shows the sequential for i = 1 ... k loop with early termination on rejection.

The consequence is that DEER trades AR drafter latency for AR verifier latency, but does not eliminate serial execution from the critical path. In the worst case — a draft where only the first token is accepted — DEER pays the cost of a full dLLM forward pass plus a full AR verifier forward pass to get a single verified token, which is strictly worse than direct AR decoding (which would have produced that token in one forward pass). The paper's speedup numbers are averages that include these worst-case cycles; they are offset by cycles where many tokens are accepted (the 15–16% of cycles with ≥8 accepted tokens in Figure 4). However, for latency-sensitive applications — interactive chat, real-time code completion, voice assistants — the distribution of per-cycle latency matters, not just the mean throughput. A system that produces tokens in bursts (one 32-token block in 50ms, then a 45ms gap while the next draft is generated and verified) may feel less responsive than one that produces tokens at a steady rate, even if the overall tokens-per-second is higher. The paper reports only mean speedup and mean acceptance length, not latency distributions, 95th-percentile inter-token times, or time-to-first-token metrics that practitioners need for latency-critical deployment decisions.

The paper's batch inference results (Table 5, Section 4.4) partially address this: larger batch sizes hide the serial verification bottleneck because the GPU is kept busy with parallel work across batch elements. At batch size 8, DEER achieves 4.17× throughput over AR decoding. But this is a throughput optimization — each individual sequence still experiences serial verification. The paper does not report per-sequence latency at different batch sizes, making it impossible to assess whether DEER is suitable for applications where a single user's request must be served with minimal wall-clock time.

Mitigation status: Not addressed. The paper does not discuss latency-vs-throughput tradeoffs, does not report latency distributions, and does not compare DEER against latency-optimized baselines (e.g., lookahead decoding, which commits to drafts without verification, trading losslessness for lower latency). The theoretical framework (Section 3.2) demonstrates that longer accepted blocks reduce the number of verification cycles, which reduces amortized latency, but this is a mean improvement — the worst-case latency (a cycle where only one token is accepted) remains unchanged and is actually worse than direct AR decoding due to the dLLM's forward pass overhead. This is a fundamental tradeoff that the paper's speedup-centric framing does not surface.

The Difficulty Estimation Problem Is Replaced by a Block-Size Selection Problem That Remains Unsolved

The paper (and the prior sections of this analysis) frames difficulty-conditioned allocation as a key insight from related work on test-time compute. DEER does not attempt difficulty estimation — the block size k is a fixed hyperparameter (swept across {4, 8, 16, 32} in experiments; Figure 8). But the optimal block size almost certainly depends on the prompt. For prompts where the dLLM's continuation aligns well with the verifier (e.g., boilerplate code with predictable structure), a large block size (32+) captures long runs of accepted tokens and maximizes throughput. For prompts where the alignment is poor (e.g., creative writing with high entropy, or math problems where the dLLM is weakly trained), a large block wastes computation — the dLLM generates 32 tokens, the verifier rejects 31 of them, and the forward passes for both models are mostly wasted.

The paper's Figure 8 provides aggregate evidence for this dependency: the benefit of increasing k from 16 to 32 is larger for Qwen3-30B-A3B (+0.8 tokens in acceptance length) than for Qwen3-8B (+0.1 tokens). This means that on the same set of prompts, the optimal block size for a 30B target is different from the optimal for an 8B target. Since the prompts are the same, the block-size sensitivity must come from the interaction between prompt difficulty and target model determinism — a prompt that is "easy" for the 30B model (high determinism, dLLM fits well, long accepted blocks) may be "harder" for the 8B model (lower determinism, shorter blocks, smaller k is more efficient). The paper does not analyze this interaction or propose a method for per-prompt block-size adaptation.

The consequence is that practitioners must select a single block size for all prompts, which inevitably leaves efficiency on the table. On easy prompts, a fixed k=32 under-exploits the dLLM's capability (it could propose and have accepted even longer blocks). On hard prompts, k=32 over-generates — the dLLM spends compute on tokens that the verifier will almost certainly reject, increasing latency without improving throughput. The paper's reported speedups use the best k for each model-benchmark combination (swept post-hoc), which is an oracle selection that practitioners cannot replicate without the same sweep on their own target distribution.

Mitigation status: Not addressed. The paper does not discuss adaptive block-size selection, does not analyze per-prompt optimal block sizes, and does not propose a method for dynamically adjusting k based on recent acceptance history (e.g., increasing k when the last few cycles had high acceptance, decreasing it after rejections). This is a clear opportunity for future work and is directly analogous to the difficulty-conditioned strategy selection that the reference example paper highlighted as its core contribution. The paper's silence on this point is a significant gap for practitioners who need to deploy DEER on prompt distributions with heterogeneous difficulty.

dLLM Infrastructure Immaturity: KV Cache and Framework Support Are Missing, Making the Headline Speedups a Lower Bound That Cannot Yet Be Realized in Production

The paper is unusually transparent about this limitation in Appendix F:

"At present, the community lacks mature support for diffusion language models (DLLMs) with KV caching in mainstream inference frameworks. Consequently, for batch size B > 1 our implementation cannot yet be integrated with popular systems such as vLLM and SGLang."

This is not a minor implementation detail — it has concrete, measurable consequences for the paper's results and for any practitioner attempting to deploy DEER today.

For the main results (Tables 1–2), the speedup numbers include KV cache for the AR verifier (standard in all frameworks) but not for the dLLM drafter. This means the dLLM recomputes attention over the entire growing prefix for every draft cycle. In a long generation (e.g., a 500-token code completion), the dLLM's forward pass cost grows with the prefix length — attention computation is O(L²) without caching. The paper's speedup measurements already account for this cost (they are end-to-end wall-clock measurements), so the reported 5.54× speedup is achieved despite the dLLM's lack of KV cache. This is simultaneously a strength (the numbers are a lower bound — they will improve when KV cache becomes available) and a practical barrier (the speedup numbers reported in the paper cannot be reproduced in production today because the infrastructure to efficiently serve dLLMs does not exist).

For batch inference (Table 5), KV cache is disabled for both AR and DEER to ensure a fair comparison. This means the batch results represent a "raw model" throughput comparison without the optimization that production systems rely on. The paper's 4.17× batch speedup at batch 8 is therefore not comparable to production throughput numbers from vLLM or SGLang, which aggressively optimize KV cache management (PagedAttention, continuous batching, prefix caching). A practitioner evaluating DEER for production deployment cannot use Table 5 to estimate their realized throughput — they need to wait for dLLM KV cache support to mature.

For adoption feasibility, the infrastructure gap creates a chicken-and-egg problem. Framework developers (vLLM, SGLang) are unlikely to prioritize dLLM support until there is demonstrated demand, but demand requires practitioners to adopt dLLM-based methods like DEER. The paper acknowledges recent progress (Fast-dLLM, Wu et al. 2025; dInfer, Ma et al. 2025) and expresses optimism that "these techniques [will] be gradually incorporated into mainstream inference frameworks" (Appendix F), but no timeline or commitment is provided. Until this happens, DEER is a research artifact, not a deployable system.

Mitigation status: Partially addressed through transparency. The paper explicitly documents the limitation in Appendix F, which is unusually honest for a systems paper (many would sweep infrastructure constraints under the rug). However, the transparency is buried in an appendix and is not reflected in the main-text claims or the abstract, which present the speedup numbers without the infrastructure caveat. A practitioner who reads only the main text would assume DEER is ready for production deployment today, which it is not. The paper does not provide workarounds (e.g., using a sliding window attention approximation for the dLLM to bound prefix cost) or estimate how much the speedup numbers would improve with KV cache.

The 32-Token Maximum Acceptance Length Is a Hard Cap Set by the Block Size, Not a Measured Ceiling — The True Capability Limit of Diffusion Drafting Is Unknown

Throughout the paper, the 32-token maximum acceptance length is presented as a strength (4× over EAGLE-3's 7–8 tokens). However, this number is an artifact of the experimental design, not a measured performance ceiling. The paper uses a fixed block size k = 32 as the maximum in all experiments (Figure 8 sweeps up to 32). Since the dLLM cannot propose more than k tokens per cycle, it is mathematically impossible for the acceptance length to exceed 32, regardless of how good the dLLM is. The true maximum — the point at which the dLLM's proposal quality degrades to the point where no further tokens are accepted — is unknown and could be substantially higher (64? 128? unlimited for highly deterministic continuations?).

This matters for two reasons. First, it means the paper's central comparison — "DEER reaches 32 tokens, EAGLE-3 reaches only 7–8" — is comparing a cap against a ceiling. EAGLE-3's 7–8 token maximum is a genuine performance limit: even if EAGLE-3 were allowed to propose arbitrarily long drafts, it would not achieve longer accepted blocks because its AR error accumulation causes acceptance to drop to zero around position 8. DEER's 32-token maximum is a cap: we don't know whether it could achieve 64 or 128 with larger block sizes. The 4× improvement ratio (32/8) is therefore a lower bound — the true ratio could be 8×, 16×, or higher. Alternatively, if acceptance probability drops sharply after position 32, the true ratio could be close to 4×. The paper presents the number as if it were a measured ceiling, which is misleading.

Second, the optimal block size is unknown for any model-benchmark pair. Figure 8 shows that acceptance length continues to increase from k=16 to k=32 for all model scales, with the steepest increase for Qwen3-30B-A3B (where the curve has not obviously saturated at k=32). This suggests that even larger blocks would yield further gains, especially for the largest target models where determinism is highest. But the paper does not explore this — k=32 is the maximum tested, and the per-token computational cost of larger blocks (the dLLM forward pass scales with total sequence length, including the mask tokens) is not analyzed. There exists some optimal k* that maximizes tokens-per-second (accounting for both acceptance length and the growing cost of the dLLM's forward pass with more mask tokens), and for Qwen3-30B-A3B, that optimum is likely above 32. The paper leaves this optimization entirely to future work.

Mitigation status: Not addressed. The paper does not discuss why 32 was chosen as the maximum, does not attempt larger block sizes, and does not characterize the tradeoff between block size and dLLM inference cost. Appendix B.2 (Figure 8) acknowledges that acceptance length increases with block size, but this is presented as a sensitivity analysis rather than as evidence that the maximum should be explored further. The paper's abstract and conclusions treat the 32-token figure as a result, not as a lower bound awaiting measurement. This is an omission that artificially caps the paper's performance claims and leaves practitioners without guidance on how to set k for their own deployments.

Generalization Beyond Code Generation Is Weakly Demonstrated — The Math Results Show Materially Lower Gains and the dLLM Is Not Fully Trained

The paper's primary results (Tables 1–2, Figures 1–8) are on code generation benchmarks. This domain has specific properties that are unusually favorable to DEER: code is highly structured with rigid syntactic constraints (once you see def quicksort(arr):, the next several tokens are heavily constrained by Python syntax), target AR models for code tend to have very peaked output distributions (the correct next token is often unambiguous), and the dLLM's training data (OpenCodeInstruct) is closely matched to the evaluation benchmarks. These properties make the dLLM's imitation task easier — the target distribution has low entropy, so the dLLM can achieve high accuracy with relatively little capacity.

The mathematical reasoning results (Table 6, Section 4.6) attempt to demonstrate generalization, but they reveal a substantially weaker performance profile:

Speedup drops from 3.62× (code, Qwen3-30B-A3B, temp=0.6) to 2.12× (math, same target and temperature) — a 41% reduction.
Acceptance length drops from 4.45 to 2.47 — a 44% reduction.
The improvement over EAGLE-3 shrinks from +80% (code) to +11% (math).
The dLLM is trained for only 40 epochs and produces "standalone generations [that] are not yet semantically reliable" (Section 4.6).

This weak generalization is partially attributed to the undertrained dLLM — but that itself is the point. Training a dLLM from scratch for a new domain (code, math, general chat, etc.) is expensive. The paper's code drafter was trained on OpenCodeInstruct (a large, high-quality code dataset) for 1 epoch (Stage I) + 1 epoch (Stage II, 100k subset). The math drafter was trained on UltraChat (a general instruction dataset, not math-specific) for 40 epochs and still produced an under-converged model. This suggests that DEER's effectiveness is highly dependent on having a well-trained, domain-matched dLLM, and that training such a dLLM for a new domain may require substantial data and compute — potentially comparable to training a small AR model for the same domain, which undermines some of the efficiency argument.

The paper does not explore whether DEER works on general-domain text generation (dialogue, summarization, creative writing), where target distributions are higher-entropy and the dLLM's imitation task is harder. The code → math performance drop suggests that the 5.54× speedup on HumanEval may not generalize to domains where the target model's output is less deterministic. Practitioners deploying DEER for non-code applications (which is most applications) are working with essentially zero evidence about expected speedups.

Mitigation status: Partially addressed through transparency. The paper honestly reports the math results and acknowledges the dLLM's undertraining. It frames the math results as demonstrating "generalizes beyond code generation" (Section 4.6), which is technically true (it does work, just less well), but the framing downplays the magnitude of the performance drop. The paper does not provide a systematic study of how DEER's performance varies with target distribution entropy, domain match between dLLM training and evaluation, or dLLM training budget — all of which would help practitioners estimate expected gains in their own domains. The paper also does not compare against domain-adapted AR drafters (e.g., an EAGLE-3 trained specifically on math data), which might close the gap on math benchmarks.

The Losslessness Guarantee Is Proved but Not Empirically Validated — Subtle Implementation Bugs in the Acceptance/Rejection Mechanism Could Introduce Distributional Drift Without Detection

Appendix E provides a formal proof (Theorem E.2) that DEER's decoding procedure is lossless — i.e., it produces exactly the same output distribution as direct autoregressive sampling from the target model. The proof is correct and follows the standard speculative decoding analysis (Leviathan et al., 2023). However, the paper provides zero empirical validation that the implementation correctly realizes the proved algorithm.

This is a concern because the acceptance/rejection mechanism has several points where implementation bugs are easy to introduce and hard to detect:

Numerical precision in the acceptance ratio: Equation 5 computes α_i = min(1, p_AR / q_θ). If either probability is very small (e.g., 1e-8), floating-point division can produce incorrect ratios. The paper does not describe any numerical stability measures (log-space computation, clamping).
Residual sampling correctness: Equation 6 requires sampling from max(0, p_AR - q_θ) — a distribution that must be computed by pointwise subtraction, zero-clipping, and renormalization. If the normalization constant is computed incorrectly (e.g., due to accumulated floating-point error across 30k+ vocabulary entries), the residual distribution is not exactly the correct one, introducing subtle bias.
Early termination on rejection: Algorithm 1 (line 13) breaks the verification loop on the first rejection, discarding the rest of the draft block. If this early termination is not correctly coordinated with the residual sampling — for instance, if the verifier's pre-computed logits for the discarded positions are accidentally used in a subsequent step — the distribution is altered.
Temperature and sampling: The paper reports results at temperature=0 (greedy) and temperature=0.6. At temperature=0, the acceptance mechanism reduces to a deterministic comparison (does the drafter's top-1 token match the target's top-1?). At temperature > 0, the stochastic acceptance/rejection with residual sampling must correctly apply temperature scaling to both p_AR and q_θ before computing ratios, and the residual sampling must account for temperature-modified distributions. Implementation errors here could produce distributions that are "close" to the target but not exactly equal, and without empirical validation, no one would know.

The consequence is that DEER's central guarantee — lossless acceleration — is trusted but unverified. In practice, small distributional errors in speculative decoding implementations are common and often go undetected because the outputs "look correct" for typical prompts. A rigorous validation would involve: running DEER and direct AR decoding on the same prompts with the same random seeds, confirming bit-identical outputs for greedy decoding, and conducting a statistical test (e.g., comparing token frequency distributions across thousands of samples) for stochastic decoding.

Mitigation status: Not addressed at all. The paper presents the proof in Appendix E and does not mention empirical validation. This is standard in speculative decoding papers — the losslessness proof is typically considered sufficient, and implementation correctness is assumed. However, given that DEER uses a non-standard proposal distribution (q_θ(· | x_{1:j}) rather than the standard AR proposal), the implementation is more complex than typical speculative decoding (the drafter's forward pass is structurally different from the verifier's), and the risk of subtle bugs is higher. The paper's release of code ("Code, model, demo, etc, will be available") will partially address this by enabling independent verification, but the paper itself provides no evidence that its implementation achieves the proved losslessness.

7. Implications and Future Directions

How This Work Changes the Landscape

DEER introduces a conceptual shift in how the field should think about speculative decoding drafters: the drafter's generative mechanism does not need to mirror the target's causal structure. Prior to this work, the implicit assumption across all major speculative decoding methods—from the original Leviathan et al. (2023) draft model approach through Medusa, Hydra, and the EAGLE series—was that because the AR verifier processes tokens left-to-right, the drafter should generate them left-to-right as well. This mirroring seemed natural: to predict what the target would predict, mimic how the target predicts. DEER demonstrates that this assumption is not only unnecessary but actively harmful. The acceptance formula (Equation 5) requires only that the drafter's marginal proposal distribution q_θ(ŷ_{j+i} | x_{1:j}) exists and satisfies the support condition—it places no constraint on how the drafter arrived at that distribution. The verifier's causal structure constrains verification (acceptance decisions must be sequential because residual resampling changes the prefix), but it does not constrain drafting. Drafting can be entirely non-causal, entirely parallel, and the losslessness guarantee remains intact (Appendix E).

This is a reframing rather than a paradigm shift—speculative decoding still works the same way (draft-then-verify), and the acceptance mechanism is unchanged from Leviathan et al. (2023). But it reframes the design space in a way that redirects research effort. The field had been optimizing within the causal drafter paradigm: better training data for AR draft heads (EAGLE-3's training-time test-time augmentation), more sophisticated head architectures (Hydra's sequentially-dependent heads), larger drafter models. DEER shows that the bottleneck was not insufficient drafter quality within the AR paradigm but rather the paradigm's architectural limitation—left-to-right dependency causing uncertainty accumulation. The reframing tells researchers: stop making AR drafters better at sequential generation; instead, eliminate sequential generation from the drafter entirely.

This reframing also resolves the tension between two conflicting observations in the speculative decoding literature. On one hand, AR drafters can achieve impressive per-token accuracy when evaluated on ground-truth prefixes—EAGLE-3's draft heads are quite good at predicting the target's next token. On the other hand, actual acceptance lengths plateau at 7–8 tokens regardless of how good the per-token accuracy is (Table 4: EAGLE-3 maxes at 7–8 tokens even for Qwen3-30B-A3B, despite the target's high determinism making individual tokens highly predictable). The "gradual collapse of trust" concept reconciles these: the drafter is accurate when conditioned on ground-truth prefixes, but during speculative decoding it conditions on its own unverified outputs, and small errors compound recursively. The collapse is not a training problem—it is a structural consequence of the dependency chain. DEER's resolution is to break the chain by conditioning only on the verified prefix, turning the problem from "make the drafter accurate under distribution shift" (hard, requires modeling the cumulative effect of its own errors) into "make the drafter accurate from a fixed prefix" (easier, requires only matching the target's marginal continuations).

Several research directions become more attractive as a result:

Non-causal drafter architectures become the primary design space. Diffusion models are one instantiation of the independence property, but masked language models, discrete energy-based models, retrieval-augmented generators, or even n-gram models with global coherence modeling could all produce prefix-conditioned joint distributions without left-to-right dependency. The field should now ask "what is the best way to produce q(y | prefix) that is independent across positions?" rather than "what is the best AR drafter architecture?"
Drafter training becomes simpler, not harder. The D2A pipeline (Section 3.1) is a supervised imitation procedure: train the dLLM to reproduce the AR teacher's continuations on truncated passages. This is conceptually simpler than training AR draft heads that must learn to predict the target's hidden state dynamics (EAGLE) or jointly optimize multiple decoding heads (Medusa). The training cost comparison (Table 8) bears this out: DEER requires 240 GPU hours vs. 696 for EAGLE-3 on Qwen3-8B—a 3× reduction. Simpler training means faster iteration, less hyperparameter tuning, and lower barriers to entry for practitioners adapting speculative decoding to new domains.
Frontier-model inference becomes the strongest use case. The finding that larger target models yield higher acceptance lengths with the same drafter (Figure 8: τ increases from ~4.3 at Qwen3-8B to ~6.6 at Qwen3-30B-A3B for block size 32) inverts the intuitive expectation that speculative decoding is a small-model optimization. AR drafters see flat or declining acceptance lengths with target scale (EAGLE-3 drops from 3.31 to 3.05 moving from 4B to 30B; Table 2), reinforcing the assumption. DEER shows that stronger target determinism directly benefits independent drafting because the dLLM only needs to capture peaked distributions. This makes the economic case for diffusion drafting strongest precisely where inference costs are highest—with frontier-scale models. A 5.54× speedup on a 30B model saves far more in absolute GPU-hours than the same speedup on an 8B model.

Conversely, some directions become less attractive:

Further optimizing AR drafter architectures (more heads, deeper draft trees, better hidden state features) faces diminishing returns if the fundamental limitation is the dependency structure, not head quality. DEER's 32-token maximum vs. EAGLE-3's 7–8 token maximum (Table 4) suggests that even a hypothetically perfect AR drafter—one with oracle-level per-token accuracy—would still be capped by error accumulation at roughly the same ceiling. The empirical plateau of EAGLE-3 across model scales (Table 2: τ stays in the 3.0–3.5 range from 4B to 30B) supports the structural interpretation: if AR drafter quality were the bottleneck, it should improve with target scale (larger targets provide richer hidden states for the draft heads to exploit), but it doesn't.
Hybrid AR-diffusion training of the target model (TiDAR, Liu et al. 2025) becomes less compelling when a modular approach achieves superior speedups (DEER's 5.54× vs. TiDAR's not-directly-comparable performance on different models) without modifying the target at all. The modular separation preserves the target's capabilities without retraining risk, is cheaper to train (only the small drafter needs updating), and generalizes across target models (the same 0.5B dLLM serves all Qwen3 scales; Table 7). The hybrid approach's dual-objective optimization conflicts and retraining cost are hard to justify when a lightweight external drafter suffices.
Continuous-space diffusion drafting (SDD, Christopher et al. 2025) is obsoleted as a research direction for lossless speculative decoding. The discrete-space formulation (DEER) provides exact probability ratios for the acceptance formula, enabling the provable losslessness that continuous-space methods cannot guarantee (the drafter's "probability" of a specific token is a density over an embedding, not a well-defined categorical probability). The paper does not directly compare against SDD (which would need to be reimplemented with different base models), but the theoretical argument—that discrete space enables exact losslessness while continuous space introduces discretization error—is definitive unless continuous methods can provide comparable guarantees.

Follow-Up Research This Work Enables

Adaptive block-size selection using real-time acceptance history. The paper uses a fixed block size k across all prompts, swept post-hoc to find the best k for each model-benchmark pair (Figure 8). This leaves substantial efficiency on the table: on easy prompts where the dLLM aligns well with the verifier, larger blocks would increase throughput; on hard prompts, smaller blocks would reduce wasted computation on rejected tokens. A follow-up could implement a simple adaptive policy: maintain an exponential moving average of recent acceptance lengths, and adjust k for the next cycle to target an acceptance rate of 50–75% (so the dLLM's forward pass cost is balanced against verification benefit). The key metric would be whether adaptive k recovers the gap between oracle block-size selection (the post-hoc sweep the paper uses) and a realistic deployment where k must be chosen per-prompt without oracle knowledge. The experiment would measure speedup vs. oracle k on HumanEval, broken down by prompt difficulty (estimated via target model entropy or dLLM confidence). The paper's Figure 8 provides the baseline: at Qwen3-30B-A3B, k=32 achieves τ=6.6 while k=16 achieves τ=5.8, a 14% difference, suggesting the adaptive policy could capture meaningful gains.

Direct measurement of per-position acceptance probability to isolate the independence mechanism from the parallelism mechanism. DEER achieves higher speedups than EAGLE-3, but the paper does not decompose the gain into (1) longer accepted blocks from eliminated error accumulation (independence benefit) and (2) faster draft generation from parallel forward passes (parallelism benefit). A follow-up experiment would plot acceptance probability P(accept | position i) as a function of draft position i ∈ {1, ..., 32} for DEER and EAGLE-3 on the same set of prompts. DEER predicts that acceptance probability should be approximately flat or slowly decaying (reflecting only the growing mismatch between q_θ(· | x_{1:j}) and p_AR(· | x_{1:j+i-1}) as i increases, which is gradual), while EAGLE-3 should show an accelerating decay (reflecting compounding error accumulation). This single plot would directly validate or refute the paper's central mechanistic claim. Additionally, an ablation could run DEER's dLLM in a simulated sequential mode—generate the draft tokens one at a time from the prefix only (no dependency between drafts), measuring acceptance without parallelism—to isolate the independence contribution. The ratio of this simulated-sequential speedup to full DEER speedup would quantify how much of the gain comes from independence vs. pure parallelism.

Training a difficulty estimator to route prompts between DEER and direct AR decoding. The paper shows that DEER's acceptance length varies with benchmark (HumanEval τ=6.58 vs. CodeAlpacaPy τ=4.04 for Qwen3-30B-A3B; Table 2), implying that some prompts benefit much more from diffusion drafting than others. On prompts where the dLLM's alignment with the target is poor, the overhead of the dLLM's forward pass plus verification may make DEER slower than direct AR decoding (the worst-case cycle: one token accepted, two full forward passes for the price of one). A follow-up could train a lightweight classifier—using features like the target model's entropy on the first few tokens, the dLLM's confidence on initial drafts, or learned prompt embeddings—to predict whether DEER will achieve >1× speedup on a given prompt, and fall back to direct AR decoding otherwise. The training signal would be observed speedup from running both methods on a calibration set. The evaluation metric would be the combined throughput (DEER on easy prompts, AR on hard) vs. using DEER universally. The paper's Figure 4 shows that ~84% of cycles accept fewer than 8 tokens even for DEER; if those cycles are actually slower than direct AR decoding (which they might be due to dLLM overhead), routing them away could improve overall throughput beyond the reported mean speedups.

Scaling the block size beyond 32 to find the true acceptance-length ceiling for diffusion drafting. The paper caps block size at 32 in all experiments, and the acceptance length vs. block size curves in Figure 8 have not saturated at k=32 for Qwen3-30B-A3B (the curve is still rising). This suggests the true acceptance-length ceiling—the point where the dLLM's proposal quality degrades enough that additional block slots yield zero additional accepted tokens—may be substantially higher, possibly 64, 128, or beyond for highly deterministic targets. A follow-up would sweep k up to 128 or 256 on HumanEval with Qwen3-30B-A3B, measuring both acceptance length τ and end-to-end tokens-per-second (accounting for the dLLM's growing forward pass cost with more mask tokens). This would characterize the optimal k* that maximizes throughput, which is where the marginal benefit of additional accepted tokens (from larger k) equals the marginal cost of the dLLM's larger forward pass. The experiment would also test whether the long-block resurgence effect (Figure 7) intensifies or saturates at extreme block sizes—if acceptance probability truly does not degrade with position, we might observe non-trivial probability mass at lengths 50, 64, or beyond. This would directly test the limits of the independence property and establish an empirical ceiling on diffusion drafting capability.

Domain-specific dLLM training budget sweep to characterize the drafter quality vs. speedup tradeoff. The math reasoning results (Table 6) used a dLLM trained for 40 epochs that was "not yet semantically reliable" and achieved only 2.12× speedup vs. 1.91× for EAGLE-3—a much smaller gain than the 3.62× vs. 2.01× on code (same target, same temperature). This suggests a strong dependence on drafter quality, but the paper doesn't characterize the shape of this dependence. A follow-up would take a single target model (e.g., Qwen3-8B) and a single benchmark (e.g., GSM8K), train multiple dLLM drafters for {1, 5, 20, 40, 80, 160} epochs on domain-matched data, and measure the resulting speedup. This would produce a "drafter quality scaling curve" analogous to model-size scaling laws. Key questions: Does speedup saturate with drafter training, and if so, at what point? Is there a regime where a very weakly trained dLLM (5 epochs) already captures most of the achievable gain, or does speedup continue improving with drafter quality? The answer determines how much practitioners should invest in dLLM training for new domains. The math results hint that 40 epochs is far from saturation (the dLLM is still unreliable as a standalone generator), so the curve might continue rising—but without the sweep, we don't know whether 80 epochs would yield 2.5× or 3.5×.

Combining DEER with KV-cache-optimized dLLM inference to measure the "true" speedup ceiling. The paper's main speedup numbers (Tables 1–2) include KV cache for the AR verifier but not for the dLLM drafter, meaning the dLLM recomputes attention over the full prefix on every cycle. Recent work (Fast-dLLM, Wu et al. 2025; dInfer, Ma et al. 2025) has demonstrated KV cache mechanisms for diffusion LMs that could eliminate this redundancy. A follow-up would integrate DEER with one of these KV cache implementations and re-measure speedups across the same benchmarks and model scales. The hypothesis is that dLLM KV cache would provide a multiplicative improvement: reducing the dLLM's per-cycle latency means shorter draft cycles and higher overall throughput, and the benefit would compound with longer generations (where prefix recomputation cost is highest). The experiment would also measure whether dLLM KV cache changes the optimal block size—with cheaper draft cycles, larger k becomes more attractive because the wasted-computation cost of rejected tokens is reduced. This would provide the first "production-realistic" speedup numbers for diffusion drafting, closing the infrastructure gap the paper acknowledges in Appendix F.

Practical Applications and Downstream Use Cases

High-throughput code generation APIs (GitHub Copilot, Codex, etc.). Code completion services serve millions of requests daily, each generating potentially hundreds of tokens. DEER's 5.54× speedup on HumanEval with Qwen3-30B-A3B (Table 2) translates directly to serving 5.54× more requests per GPU, or equivalently reducing GPU fleet size and cost by ~82% for the same throughput. Code generation is particularly favorable for DEER because: (1) target model outputs are highly deterministic (syntax constrains token choice), maximizing acceptance length; (2) the dLLM can be pre-trained once on a large code corpus (OpenCodeInstruct) and reused across all target model sizes and versions without retraining (Table 7: same 0.5B drafter for 4B–30B targets); and (3) the 240 GPU-hour training cost (Table 8) is negligible compared to the GPU-months of inference savings at scale. The primary barrier to deployment today is the lack of dLLM KV cache in production frameworks (Appendix F)—without it, the dLLM's prefix recomputation on long code files would eat into speedups. Once dInfer or Fast-dLLM integration matures, code completion APIs are the natural first deployment target.

Batch inference for offline evaluation and synthetic data generation. Organizations that run large-scale batch inference—evaluating models on test suites, generating training data via model distillation, or scoring candidate solutions—care about throughput, not per-request latency. DEER's batch scaling results (Table 5: 4.17× throughput at batch 8, 3.53× at batch 16 on HumanEval) demonstrate that the approach scales well with batch size, better exploiting GPU parallelism than AR baselines (AR throughput increases from 34 to 50 tokens/s from batch 2 to 16; DEER increases from 83 to 176). For a team generating 1 million synthetic training examples with Qwen3-30B-A3B, the 4× throughput improvement would reduce wall-clock time from ~50 GPU-days to ~12 GPU-days. Batch inference also sidesteps the latency concern (Section 6): for offline workloads, per-request latency variation doesn't matter, only aggregate throughput. This use case could be deployed today without waiting for dLLM KV cache, since the batch experiments in Table 5 were run without KV cache for both methods (fair comparison), and the 4× improvement is directly realizable on current hardware. The main practical requirement is a batch inference pipeline that can interleave dLLM draft generation and AR verification across multiple sequences to keep the GPU saturated.

On-device or edge deployment of large-model capabilities via draft-then-verify offloading. While DEER is demonstrated with a 0.5B dLLM and 4B–30B AR targets in the same GPU cluster, the architecture naturally supports a split deployment: a small dLLM runs on-device (or on a cheap edge server), proposes draft blocks, and sends them to a large AR model in the cloud for verification. The dLLM's 0.5B parameters are small enough to run on a phone or laptop (comparable to mobile-optimized LLMs), and its single forward pass per cycle means the on-device latency is predictable. The cloud verifier receives only the draft tokens (not the full model), verifies them, and returns accepted tokens plus any residual corrections. This architecture achieves the quality of the large cloud model with the perceived latency of the small on-device model (since the user sees draft tokens immediately, and verification corrects only the few that are wrong). The paper's finding that acceptance length is high on deterministic targets (6.58 tokens accepted on average; Table 2) means the on-device drafter would be "right" most of the time, and corrections would be rare and localized. The 32-token maximum acceptance length (Table 4) suggests entire lines of code or sentences could be drafted locally and verified remotely in a single round-trip, minimizing network latency impact. This use case requires solving the trust problem (the user might see an incorrect draft briefly before correction) and the engineering challenge of streaming token display during verification, but the efficiency numbers from the paper make the approach quantitatively attractive.

When to Prefer This Method

The paper does not articulate a formal decision framework for choosing DEER over specific named alternatives (EAGLE-3, Medusa, Hydra, or direct AR decoding), but the experimental results and architectural properties support a set of practical guidelines grounded in the paper's evidence:

Prefer DEER when the target AR model is large (10B+ parameters) and has a relatively deterministic output distribution (e.g., code generation, structured data extraction, formal reasoning). The paper shows acceptance length increases with target scale for DEER (Figure 8: τ grows from ~4.3 to ~6.6 moving 8B→30B) while EAGLE-3's acceptance length declines (Table 2: 3.31→3.05). Larger models' peaked distributions are easier for the dLLM to fit, and the independence property prevents error accumulation from offsetting this benefit. The economic case is strongest at frontier scale where inference cost dominates.
Prefer DEER when you can amortize dLLM training cost over many target model versions or downstream tasks. The 0.5B dLLM is trained once (240 GPU hours on code; Table 8) and serves all target scales without modification (Table 7: same drafter for 4B, 8B, 14B, 30B targets). If you deploy multiple model sizes or regularly update the target model (fine-tuning, RLHF iterations), the drafter training cost is amortized across all versions, and the speedup applies to each. In contrast, EAGLE-3's draft heads are specific to each target checkpoint and must be retrained per model version.
Prefer DEER for batch or offline throughput workloads (synthetic data generation, evaluation suites, knowledge distillation) where per-request latency distribution doesn't matter. The batch scaling results (Table 5: 4.17× throughput at batch 8) demonstrate strong GPU utilization improvements without requiring KV cache optimization for the dLLM. This is the most deployment-ready use case given current infrastructure limitations.
Consider EAGLE-3 or direct AR decoding for latency-sensitive, single-request, interactive applications until dLLM KV cache matures. For a single user typing in a code editor and expecting sub-100ms token delivery, DEER's lack of dLLM KV cache (Appendix F) means the dLLM recomputes attention over the growing prefix on each cycle, introducing latency that EAGLE-3 (with cached hidden states) avoids. The paper does not report per-token latency distributions, so the interactive experience is uncharacterized—and the worst-case cycles (one token accepted, two full forward passes) may be noticeably slower than direct AR decoding for individual keystrokes. Once dLLM KV cache becomes available, this tradeoff would need to be re-evaluated with latency-centric benchmarks.
Consider direct AR decoding when the domain is high-entropy and you cannot afford to train a domain-matched dLLM. The math results (Table 6: 2.12× speedup, only +11% over EAGLE-3) show substantially reduced gains when the dLLM is undertrained and the target distribution is less deterministic. If you need speculative decoding for a new domain today and don't have the resources to train a dLLM from scratch for 40+ epochs on domain-matched data, EAGLE-3 (which can be trained more cheaply by attaching draft heads to the existing target) may provide better speedup-per-training-investment, even if the absolute ceiling is lower. The paper's code drafter was trained on OpenCodeInstruct, a large high-quality dataset that may not exist for other domains; replicating this data pipeline is a hidden cost of the DEER approach.

🎯 Pitch

1. Executive Summary

2. Context and Motivation

The Fundamental Tension in LLM Decoding: Quality vs. Speed

Speculative Decoding: The Promise and the Structural Bottleneck

The Two Structural Problems with Autoregressive Drafters

Where Existing Methods Fall Short

The Diffusion Model Opportunity

How This Paper Positions Itself

3. Technical Approach

3.1 Reader orientation (approachable technical breakdown)

3.2 Big-picture architecture (diagram in words)

3.3 Roadmap for the deep dive

3.4 Detailed, sentence-based technical breakdown

Formulation of Lossless Speculative Decoding and the Acceptance Mechanism

Diffusion Language Models and the Need for Alignment

Stage I: AR-Style Continuation Distillation

Stage II: Scribe Refinement

Inference Algorithm: Block-Wise Speculative Decoding

Design Choices and Their Justifications

4. Key Insights and Innovations

Innovation 1: The Gradual Collapse of Trust — A New Diagnostic Concept That Names the Central Bottleneck in Speculative Decoding

Innovation 2: Drafting via Joint Independence Rather Than Sequential Conditioning — A Paradigm Shift in the Generative Mechanism of Speculative Decoding

Innovation 3: The Discovery That Diffusion Models Trained for Joint Reconstruction Can Be Converted to Prefix-Conditioned Continuation Models Through Targeted Fine-Tuning — A Bridging of Two Previously Separate Paradigms

Innovation 4: The Empirical Finding That Test-Time Compute Scaling via Speculative Decoding Shows Inverse Scaling with Target Model Size for Diffusion Drafters — Larger Target Models Make Diffusion Drafting Easier, Not Harder

5. Experimental Analysis

Evaluation Methodology

Main Quantitative Results

Overall Efficiency on Code Generation (RQ1): DEER Consistently Doubles Acceptance Length and Speedup Over EAGLE-3

Acceptance Length Distribution Analysis: DEER Reshapes the Distribution Toward Long Accepted Blocks

Scaling of Acceptance Length with Block Size: Larger Blocks Enable Longer Accepted Sequences, Especially for Larger Target Models

Batch Inference Scalability (RQ3): DEER's Throughput Advantage Grows with Batch Size

Performance on Mathematical Reasoning (RQ5): DEER Generalizes Beyond Code Even with a Weakly Trained dLLM

Maximum Acceptance Length and the Long-Block Resurgence Effect: Direct Evidence for the Independence Hypothesis

Ablation Studies and Robustness Checks

Critical Assessment

6. Limitations and Trade-offs

Latency vs. Throughput: Sequential Verification Creates a Serial Bottleneck That Parallel Drafting Cannot Eliminate

The Difficulty Estimation Problem Is Replaced by a Block-Size Selection Problem That Remains Unsolved

dLLM Infrastructure Immaturity: KV Cache and Framework Support Are Missing, Making the Headline Speedups a Lower Bound That Cannot Yet Be Realized in Production

The 32-Token Maximum Acceptance Length Is a Hard Cap Set by the Block Size, Not a Measured Ceiling — The True Capability Limit of Diffusion Drafting Is Unknown

Generalization Beyond Code Generation Is Weakly Demonstrated — The Math Results Show Materially Lower Gains and the dLLM Is Not Fully Trained

The Losslessness Guarantee Is Proved but Not Empirically Validated — Subtle Implementation Bugs in the Acceptance/Rejection Mechanism Could Introduce Distributional Drift Without Detection

7. Implications and Future Directions

How This Work Changes the Landscape

Follow-Up Research This Work Enables

Practical Applications and Downstream Use Cases

When to Prefer This Method

Adjacent in domain

Fast and Accurate Causal Parallel Decoding using Jacobi Forcing

TurboDiffusion: Accelerating Video Diffusion Models by 100-200 Times