acceptodds
Under review as a conference paper at ICLR 2027

DEdit: Iterative Draft Editing for Speculative Decoding

Abstract

Speculative decoding accelerates autoregressive LLMs by having a lightweight drafter propose tokens that the target model verifies in parallel. Diffusion-based drafters further reduce drafting latency by proposing all tokens at once. However, these tokens are predicted independently, so a single early error causes prefix verification to discard the rest of the draft, even when it contains useful downstream predictions. We introduce DEdit, a diffusion-based drafter that can not only draft by conventional parallel unmasking but also iteratively edit its draft through token-to-token predictions. Through editing, later predictions can serve as bidirectional context for repairing earlier errors and extending the accepted prefix. To teach the model to repair errors while preserving correct predictions, we propose ProposalMix, a training scheme that mixes draft predictions with ground-truth tokens based on first-pass confidence during training. Across seven benchmarks, DEdit achieves the highest macro-average token acceptance among the evaluated drafters for both Qwen3-4B and Qwen3-8B under greedy and stochastic decoding, and its acceptance increases with more editing iterations and wider drafting windows. In our execution setting, speedup follows the same trends, and DEdit reaches the highest macro-average speedups of 5.72x and 5.97x over autoregressive decoding under greedy decoding.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Speculative Decoding, Large Language Models, Diffusion Drafter, Parallel Drafting, Bidirectional Editing, Iterative Refinement

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_MMecOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes DEdit, a draft generation method based on a diffusion mechanism, which iteratively edits and refines drafts, and utilizes bidirectional context to correct previous prediction errors and extend the acceptable prefix. During training, a ProposalMix strategy is employed to mix model predictions with real tokens, enhancing error correction capabilities. Experiments show that DEdit achieves the highest macro-average token acceptance rate and inference acceleration ratio across seven benchmarks on Qwen3-4B and Qwen3-8B.

Critical strengths
  1. The comparative experiments are thorough, comparing with DFlash, Domino, and DSpark. Among them, DFlash shares the same architecture as DEdit, with clear control of variables, effectively validating the benefits of the editing mechanism itself.

  2. The architectural design is simple. DEdit uses the same drafter to complete both the initial proposal and subsequent editing, without requiring an additional editing model, and the editing capability acquired during training can be repeatedly applied to multiple rounds of editing such as P2, P3, during inference.

Critical weaknesses
  1. Under Qwen3-4B in greedy mode, the accepted length is 14.8% longer than Domino, yet the final speedup is only 7.9%. When does the benefit of an additional edit outweigh the cost of an extra drafter forward?

  2. This paper validates this under a specific environment with batch=1. How would the benefits change with larger batch sizes or concurrent requests?

  3. The main experiments use two editing passes(K = 3). How was this number of edits determined, and how many rounds of edits should be employed in practical use?

Questions for authors
  1. Can the number of edits K be adjusted dynamically, determining when to stop editing based on the quality of the current draft, thereby avoiding unnecessary drafter forward overhead?
4 comments

We thank the reviewer for recognizing our thorough comparisons, the clear control of variables that "effectively validat[es] the benefits of the editing mechanism itself", and the simple architecture. Below we address the weaknesses and the question.

W1: τ is 14.8% higher than Domino's, but speedup only 7.9% higher

TLDR — DEdit raises τ most where τ is already high: +16% on the high-τ half of the responses and +8% on the low-τ half. The low-τ responses are the bottleneck: they need more rounds per token and take 64% of the decoding time, so the overall speedup follows them. The two extra drafter passes also make each round slightly longer.

We reran both drafters on the same prompts (seven benchmarks, 30% prompt subset) and split the responses into two halves by Domino's τ:

ResponsesDomino τDEdit ττ gainShare of decoding time
Low-τ half4.865.24+8%64%
High-τ half8.319.64+16%36%

A two-response example. The time to generate a token is proportional to 1/τ, the number of rounds per token. Take two equally long responses with τ = 4 and τ = 10. The first needs 2.5× as many rounds and takes 71% of the total time. If τ rises by 20% on the second response only, the mean τ rises by 14%, but the total time falls by only 5%. Speedup therefore follows the low-τ responses, while the mean τ counts all responses equally.

When an additional edit outweighs its cost. An extra edit pays off when its relative gain in τ exceeds the relative round time it adds. In our setting, the second edit adds 6.6% to τ and 1.6% to round time (W3). The round time that a pass adds depends on how the system schedules drafting (W2).

W2: Larger batches and concurrent requests

TLDR — Batch size 1 is the standard setting for main results in the literature. Following your suggestion, we also measured larger static batches. τ is the same at every batch size. DEdit is the fastest at batch sizes 1 and 4. At batch sizes 16 and 32, GPU compute becomes the limit, and DEdit is slower than the baselines.

Our main results use batch size 1, as do the main evaluations of EAGLE-3, DMax, and Fast-dLLM. For this response we ran static batches that replicate each prompt on one GPU (seven benchmarks, 72 responses, same execution setting as the paper). Speedup is over AR at the same batch size.

Batch sizeτ, K=3DFlash W=16Domino W=16DEdit K=1DEdit K=3Two edits add (ms)
17.204.51×5.02×4.50×5.55×0.1
47.154.47×4.98×4.46×5.39×0.6
167.103.67×4.08×3.08×3.00×9.8
327.112.43×2.54×1.67×1.64×17.8
  1. τ holds at every batch size. τ stays at 7.1–7.2 from batch size 1 to 32. At batch sizes 1 and 4, K=3 is 21–23% faster than K=1 and 8–11% faster than Domino.

  2. At batch sizes 16 and 32, GPU compute is the limit and DEdit is slower. The round then no longer absorbs the drafter passes (W3): the two edits add 10–18 ms per round, and K=3 is within 3% of K=1. DEdit at W=32 is also slower than Domino at W=16, because verifying a 32-token block costs more than verifying a 16-token block. Verifying only a confidence-selected prefix of the block, as DSpark does (Cheng et al., 2026), may recover this cost at wide windows.

  3. Serving needs scheduling. These are static batches of identical prompts. A serving engine adds varied prompts and a scheduler, which can overlap drafting with verification (MineDraft, Tang et al., 2026; JetSpec++, Feng et al., 2026) and decide which requests get extra passes. DEdit contributes the drafter side of this problem: a drafter that iterates over a wide window and reaches a higher acceptance length than DFlash and Domino, with K chosen at inference without retraining. We see this co-design of editing and scheduling as important future work.

W3: Choice of K

TLDR — We chose K=3 from the measured trade-off: the speedup stops improving after K=3, and we prefer fewer passes. The round absorbs the first two edits, so they raise τ at almost no added round time. A fourth pass raises τ by only 2.6% and brings no further speedup. In practice, add a pass while it raises τ more than round time; K can be changed at inference without retraining.

K counts drafter passes: one proposal pass plus K−1 edits. The table splits each round into its drafter part and its target part (W=32, rerun on a 30% prompt subset):

K (passes)τDrafter (ms)Target (ms)Round (ms)
16.033.821.425.5
27.317.417.825.5
3 (ours)7.7911.014.725.9
47.9914.614.529.4
  1. How we chose K. Each pass adds about 3.6 ms of drafter time. Up to K=3, the target part shrinks by the same amount, because the CPU enqueues the target operations while the drafter runs. At K=3 the target part is close to its floor (14.7 ms, vs. 14.5 ms at K=4). A fourth pass therefore adds 3.5 ms to the round for a 2.6% gain in τ, so the speedup stops rising after K=3 (5.83× vs. 5.26× for K=4). We will update Appendix C.1 with these measurements.

  2. K in practice. A pass costs more as the batch grows (W2), and how much of it the round absorbs depends on the schedule. Passes that fit in the time overlapped with verification add no round time and should be used. Beyond that, the rule from W1 applies: add a pass while its relative gain in τ exceeds the relative round time it adds. K can be changed at inference without retraining.

  3. Making K=3 work is part of our contribution. Training includes only the proposal pass and one edit, yet the second and third edits still raise τ (7.31 → 7.79 → 7.99). This is not a given: an edit can rewrite every position, including correct ones, and DFlash and Domino lose τ when run again on their own proposals (our response to Reviewer HMLz, W1). ProposalMix teaches the editor to keep correct tokens, so DEdit can iterate beyond what it was trained on, and K becomes a choice at inference.

Q: Dynamic K

TLDR — Yes, dynamic K can work, and we show a first result: a learned gate skips a third of the edits and keeps 98.5% of τ. Without scheduling designed for it, fixed K=3 still has higher τ and is faster. We see dynamic K with scheduling design as promising future work, where a rule's accuracy has to be traded against its decision time (up to 11% of a drafter pass).

Rule (W=32)Passes / roundτDecision cost, ms (% of a pass)
Fixed K=227.31—
Fixed K=337.79—
Confidence threshold (heuristic)2.307.390.13 (4%)
Learned gate2.377.670.41 (11%)
  1. A learned gate works better than a heuristic rule. We tried a heuristic rule (following standalone diffusion LMs such as DMax (Chen et al., 2026), it stops when the drafter is confident) and a learned gate, a small classifier on drafter features that decides whether to run the second edit. The learned gate works better: it skips a third of the edits and keeps 98.5% of τ, well above fixed K=2 at a similar number of passes.

  2. Turning skipped edits into speed needs scheduling. How much time a skipped edit saves depends on how drafting and verification are scheduled. Our implementation has no scheduling designed for dynamic K, so fixed K=3 has higher τ and is also faster than every rule we tried. The decision has its own cost as well, 11% of a drafter pass for the learned gate. With a more accurate gate, and with drafting, the decision, and verification scheduled together, dynamic K can turn skipped edits into speed. Our response to Reviewer XauH (W1) gives the full comparison.

We will (1) add this analysis of the τ gain and the stopping-rule results to the appendix, (2) update Appendix C.1 with the per-pass timing above, (3) add the batch-size results to the appendix, and (4) discuss batch scheduling and dynamic K in Future Work, citing MineDraft and JetSpec++.

References

Tang et al., 2026. MineDraft: A Framework for Batch Parallel Speculative Decoding. ICML 2026.

Feng et al., 2026. JetSpec++: Foresight Parallel Drafting with Self Refinements. arXiv:2610.19792.

Cheng et al., 2026. DSpark: Confidence-Scheduled Speculative Decoding with Semi-Autoregressive Generation. arXiv:2607.05147.

Chen et al., 2026. DMax: Aggressive Parallel Decoding for dLLMs. arXiv:2604.08302.

Thanks for your timely and detailed response. It partially solves my concerns. I keep my score. Well done and good luck!

Thank you for your support and helpful questions. The batch-size and dynamic-K results they led to make DEdit's position among recent concurrent work clearer. We will add them to the revision.

Reviewer_HMLzOpenReview ↗
Rating
3
Confidence
1
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

[AC PLEASE READ] I am not the expertise for this field, actually I only collaborate one paper which is about Speculative Decoding, therefore please lower my weight of ratings.

Research questions: how to improve the diffusion-based drafter's token acceptance and inference efficiency in speculative decoding?

traditional parallel drafting predict independently on multiple tokens, when tokens in the early position are predicted incorrect, then prefix verification will ignore all later tokens, although some of them are predicted correct.

core: propose DEdit, use iterative bidirectional editing to muti-fixing the original draft. In addition, authors propose ProposalMix policy, mixing draft predictions and gt tokens by first-pass confidence, making models maintain the correct prediction while fixing the wrong prediction.

results on qwen3-4b and qwen3-8b over 7 benchmarks show the improvements.

Critical strengths
  1. motivation is clear, and method is novel.

  2. experiment results are consistent.

  3. ablations are sufficient.

Critical weaknesses
  1. baseline comparision seems not fair. baselines are use W-16, but DEdit use W=32 and three times drafting passes.

  2. I suggest adding the experiments on causal and bi-direct editors in the same conditions. to support the replacement of bi-direct attn to causal attn.

Questions for authors

n/a

3 comments

We thank the reviewer for finding the motivation clear, the method novel, and the ablations sufficient. Below we address the two weaknesses.

W1: Fairness of the baseline comparison (W=32 and three drafting passes)

TLDR — At the same window (W=16), DEdit already has the highest τ in the ablation study (6.87 vs. 6.60 for Domino). The wider window and the extra passes are abilities that our method contributes: DFlash and Domino gain little from a wider window and lose τ with extra passes.

Our contribution — DEdit adds two abilities that existing drafters lack: (1) it benefits from a wide window, because editing uses the additional future tokens, and (2) it can iterate, so extra passes raise τ. The comparison in Table 1 uses both, and the two points below test whether DFlash and Domino have them.

  1. Window size. DFlash and Domino are released at W=16 (Section 4.1), and there is no established recipe for extending a drafter to a wider window. Window expansion (Section 3.4) is part of our method. Table 2(a) applies the same recipe to all methods:
τ (Table 2(a))W=16W=24W=32
DFlash5.896.016.01
Domino6.606.916.93
DEdit, no edit5.825.935.93
DEdit, two edits6.877.397.58

DFlash and Domino stop gaining at W=24. Running DFlash and Domino at W=32 would therefore not necessarily be a fairer comparison: the target would verify twice as many tokens per round for a τ gain of 0.12 and 0.33. DEdit keeps gaining up to W=32, because editing uses the additional future tokens.

  1. Drafting passes. Three passes are one proposal pass plus two edits. We gave DFlash and Domino the same extra passes by running them again on their own proposals, with the proposal replacing the mask tokens in the drafter input (τ, W=16, seven benchmarks, 30% prompt subset):
Drafter (W=16)One passTwo passesThree passes
DFlash, run on its own proposal5.982.632.68
Domino, run on its own proposal6.684.534.56
DEdit (ours)5.896.756.97

DFlash and Domino were trained only on mask tokens, so their own proposal is an input they have never seen. Run on it, they change many correct tokens, and τ falls on every benchmark. Joint training with ProposalMix teaches DEdit to revise its own proposal, so its edits raise τ on every benchmark, and ProposalMix halves the rounds in which an edit shortens the accepted prefix (Section 5.1). The speedups in Table 1 are measured end to end with all three passes. How this cost depends on the execution setting is discussed in our response to Reviewer XauH (W3).

W2: Causal vs. bidirectional editors under the same conditions

TLDR — We ran the suggested experiment. Trained with an identical recipe, the bidirectional editor outperforms the causal editor on all seven benchmarks.

We trained two editors with the same recipe: W=16, the same 100K training examples, schedule, and seed. They differ only in the attention mask of the editing pass. The table reports τ over all prompts of the seven benchmarks; the 100K training set makes absolute τ lower than in Table 2(a).

PassCausal editorBidirectional editorΔ95% CIBenchmarks with Δ > 0
P1 (proposal)5.355.37+0.020[−0.000, 0.040]6/7
P2 (one edit)5.875.99+0.119[0.092, 0.145]7/7
P3 (two edits)6.046.14+0.105[0.077, 0.134]7/7

P1 is the control: the two editors start from nearly equal proposals. The gap opens once editing begins and holds on all seven benchmarks at P2 and P3. This supports the finding of Section 5.2 that bidirectional editing gains from future proposal context. This control uses W=16; Section 5.2 also shows that the advantage grows with the number of correct future tokens, which a wider window provides.

We will (1) discuss the window-scaling ablation (Table 2(a)) alongside the main comparison, (2) add the self-iteration baselines, and (3) add the matched-training control to the paper.

Reviewer_HMLzOpenReview ↗

Thank you

Thank you for your rebuttal, it partially solves my concerns. Therefore, I keep my score. (I slightly improve scores, but I dont think it reach to acceptance score. i.e., from 2.6(initial)->3.3(now), so it is still 3).

Thank you for carefully considering our rebuttal and for your thoughtful feedback. We appreciate your updated assessment and are glad that our response has helped address some of your concerns.

Reviewer_XauHOpenReview ↗
Rating
4(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents DEdit, a diffusion-based drafter that can not only draft using conventional parallel unmasking but also iteratively edit its draft through token-to-token predictions. This paper points out that although current diffusion-based drafter can predict multiple token in parallel, as predicting different positions independently, an early incorrect predicted position will cause prefix verification to discard the rest drafts, which may contain useful predictions. For the proposed DEdit, it proposes bidirectional editing. Through editing, later predictions can serve as bidirectional context for repairing earlier errors and extending the accepted prefix. To teach the model to repair errors while preserving correct predictions, the authors propose ProposalMix. Across seven benchmarks on Qwen3-4B and Qwen3-8B, DEdit achieves the highest macro-average token acceptance and speedup over autoregressive generation under greedy decoding.

Critical strengths
  1. The motivation in this paper is very reasonable, enhancing draft quality by allowing the diffusion drafter to iteratively self-correct. The early error may cause discarding the rest useful predicted tokens during prefix verification, then the proposed bidirectional editing can effectively utilize these wasted predicted results to correct earlier errors.
  2. The paper is very clearly written, with comprehensive technical details.
  3. Comprehensive experimental results show that the proposed method achieves a higher speedup ratio compared to previous baselines. The paper also provides ablation experiments and analysis for each component.
Critical weaknesses
  1. Currently, DEdit uses a fixed number of draft forwards, which can lead to significant wasted computational costs. I believe the number of draft forwards should be adaptive, similar to self-revising dLLMs like DMax [1] or GemmaDiffusion, they set a draft convergence condition for the current block.
  2. Would adding a Domino [2] causal head to the draft model further improve the iterative refinement effect?
  3. Speedup's advantage seems to depend on the execution setting.

[1] DMax: Aggressive Parallel Decoding for dLLMs

[2] Domino: Decoupling Causal Modeling from Autoregressive Drafting in Speculative Decoding

Questions for authors
  1. Why adopting fixed number of draft forwards, any advantages compared with adaptive one?
  2. Would adding a Domino [2] causal head to the draft model further improve the iterative refinement effect?
  3. Maybe more analysis on the speedup gains, e.g., the part of the proposed component, the execution setting contribution.
3 comments

We thank the reviewer for finding our motivation "very reasonable", the paper "very clearly written", and the experiments "comprehensive".

W1 & Q1: Fixed vs. adaptive number of passes

TLDR — We agree that adaptive stopping is promising, and we show a first result: a learned gate skips a third of the edits and keeps 98.5% of τ. Without scheduling designed for it, fixed K=3 still has higher τ and is faster, so the paper uses a fixed K. We see adaptive stopping with scheduling design as promising future work, where a rule's accuracy has to be traded against its decision time (up to 11% of a drafter pass).

We added stopping rules to DEdit (W=32, seven benchmarks, 30% prompt subset, lossless). A DEdit round runs one proposal pass and up to two edits, which is K=3 in the paper. A stopping rule decides in each round whether to skip the remaining edits. AUROC measures how well a rule predicts whether the edit it skips would help. Decision cost is the drafter time that a rule's decision adds per round, also given as a share of one drafter pass (3.6 ms).

RuleDecides afterAUROCPasses / roundτDecision cost, ms (% of a pass)
Fixed, one pass——16.03—
Fixed, two passes——27.31—
Fixed, three passes (ours)——37.79—
Prefix unchangedFirst edit0.482.337.450.05 (1%)
Confidence thresholdFirst edit0.382.307.390.13 (4%)
Learned gateFirst edit0.702.377.670.41 (11%)
Learned gateProposal0.671.386.970.20 (6%)
  1. A diffusion drafter stops differently from a standalone diffusion LM. DMax and DiffusionGemma generate the final output themselves, so they stop when further passes would not change it, which high confidence signals. A drafter's output is verified by the target, so an edit helps only when it repairs the first token the target would reject. We built two heuristic rules based on the standalone idea, prefix unchanged and confidence threshold (AUROC 0.48 and 0.38). Neither predicts when an edit helps, and the confidence rule points the opposite way: edits help more often when the drafter is confident. What stopping can save also differs: DMax needs 6.5 passes per block on average, from 2 to 13 (10th–90th percentile), and these passes are its whole decoding cost, while DEdit runs at most two edits, each a forward of a 5-layer drafter.

  2. A learned rule works better. The learned gate, a small classifier on drafter features, reaches 0.70. Deciding after the first edit, it skips about a third of the edits and keeps 98.5% of τ.

  3. Why the paper uses a fixed K. Every rule in the table lowers τ, so a rule is faster only if the edits it skips save more time than the lost τ costs. How much time a skipped edit saves depends on how drafting and verification are scheduled. Our implementation has no scheduling designed for adaptive stopping, so fixed K=3 has higher τ and is also faster than every rule we tried. The decision also has its own cost: the learned gate adds 0.4 ms per round, about 11% of one drafter pass. K can be set per deployment without retraining, so a fixed K is a simple default. With a more accurate rule, and with drafting, the decision, and verification scheduled together, adaptive stopping can turn skipped edits into speed. We see this co-design of stopping rule and scheduling as a very interesting direction for future work.

W2 & Q2: Adding a Domino causal head

TLDR — Yes. DEdit, without retraining, can apply to Domino's generated proposals and improve its acceptance length, and training them jointly is an interesting direction that may improve them further.

We applied DEdit's editor to Domino's first 15 proposal tokens, matching DEdit's proposal length (τ, W=16):

P1 source (W=16)P1 only+ 1 DEdit edit+ 2 DEdit edits
Domino6.686.937.03
DEdit5.896.756.97
  1. The two mechanisms do different jobs. A causal head conditions each position on the tokens before it. This keeps a draft consistent with its own prefix, and it also keeps draft trees consistent (JetSpec; Hu et al., 2026). Bidirectional editing, the contribution of this paper, uses later proposal tokens to revise earlier ones. Its advantage over a causal corrector grows with the number of correct future tokens (Section 5.2).

  2. They overlap in part. Editing improves Domino's proposal on all seven benchmarks. The gain is smaller on Domino's proposals (+0.35) than on DEdit's own (+1.08), which suggests that the causal head already fixes part of what editing fixes. The remaining gain comes from future context, which a causal head cannot use.

  3. A joint design is a natural next step. This editor has never seen Domino's proposals. A small bidirectional editing module trained jointly with a causal head may bring further gains, especially at wide windows, where editing gains most (W3).

W3 & Q3: Contribution of components vs. execution setting

TLDR — The comparison is controlled: every method runs in the same setting, with CUDA Graphs on every drafter. In this setting, editing is the main source of the speedup gain: two edits raise the speedup from 4.74× to 5.83×. We agree that the size of this gain depends on the execution setting, which decides how much drafting cost a round hides.

Passes (W=32)τSpeedup
16.034.74×
27.315.63×
3 (ours)7.795.83×
  1. What each component contributes. Two edits raise τ by 29% and the speedup by 23%. A wider window adds +0.71 to τ with editing and +0.11 without it (Table 2(a)), so wide windows are a capability that editing unlocks. ProposalMix and joint training add +0.144 and +0.085 to τ (Table 2(b)).

  2. What the execution setting contributes. All methods use the same target, hardware, and prompts. With CUDA Graphs on the drafter only, the drafter runs while the CPU enqueues the eager target operations, so drafting cost is largely overlapped and two edits add 2% to round time. With CUDA Graphs on both models, they add 53%, and one pass is fastest. Our setting therefore shows the upper bound of speedup from DEdit's acceptance gain.

  3. Turning acceptance into speed is a scheduling problem. In a serving engine such as SGLang, the scheduler has to decide when a drafter runs extra passes, which requests in a batch get them, and how drafting is overlapped with verification. MineDraft (Tang et al., 2026) overlaps the two across batches. The concurrent JetSpec++ (Feng et al., 2026) pipelines drafting with verification, so extra refinement passes add almost no latency while they fit within the verification window. DEdit contributes the drafter side of this problem: a drafter that iterates over a wide window and reaches a higher acceptance length than DFlash and Domino, with the number of passes chosen at inference without retraining. We see this co-design of editing and scheduling as important future work.

We will (1) add the adaptive-stopping and Domino results to the appendix, (2) discuss the joint causal and bidirectional design and the co-design of editing and scheduling in Future Work, citing JetSpec, MineDraft, and JetSpec++, and revise the stopping signals suggested there in light of the results above.

References

Hu et al., 2026. JetSpec: Breaking the Scaling Ceiling of Speculative Decoding with Parallel Tree Drafting. arXiv:2606.18394.

Tang et al., 2026. MineDraft: A Framework for Batch Parallel Speculative Decoding. ICML 2026.

Feng et al., 2026. JetSpec++: Foresight Parallel Drafting with Self Refinements. arXiv:2610.19792.

Chen et al., 2026. DMax: Aggressive Parallel Decoding for dLLMs. arXiv:2604.08302.

Thanks for the authors' detailed response. My concerns have mostly been addressed, and I can also see the potential of the proposed method. I think I will raise my positive score to 4.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.