Finish First, Perfect Later: Test-Time Token-Level Cross-Validation for Diffusion Large Language Models

## Abstract

Abstract Diffusion large language models (dLLMs) have recently emerged as a promising alternative to autoregressive (AR) models, offering advantages such as accelerated parallel decoding and bidirectional context modeling.
However, the vanilla decoding strategy in discrete dLLMs suffers from a critical limitation: once a token is accepted, it can no longer be revised in subsequent steps.
As a result, early mistakes persist across iterations, harming both intermediate predictions and final output quality.
To address this issue, we propose Tolerator ( To ken- Le vel C r oss-V a lida t i o n R efinement), a training-free decoding strategy that leverages cross-validation among predicted tokens.
Unlike existing methods that follow a single progressive unmasking procedure, Tolerator introduces a two-stage process: (i) sequence fill-up and (ii) iterative refinement by remasking and decoding a subset of tokens while treating the remaining as context.
This design enables previously accepted tokens to be reconsidered and corrected when necessary, leading to more reliable diffusion decoding outputs.
We evaluate Tolerator on five standard benchmarks covering language understanding, code generation, and mathematics.
Experiments show that our method achieves consistent improvements over the baselines under the same computational budget.
These findings suggest that decoding algorithms are crucial to realizing the full potential of diffusion large language models. Code and data are publicly available .

## 1 Introduction

Large language models (LLMs) (Chowdhery et al., 2022; Hurst et al., 2024; Comanici et al., 2025) have driven remarkable progress across diverse NLP domains (Zhao et al., 2023; Minaee et al., 2024).
The dominant architecture behind these advances is the autoregressive (AR) transformer (Vaswani et al., 2017). While highly effective, AR decoding is inherently sequential, creating a fundamental bottleneck that limits generation parallelism (Fu et al., 2024; Xia et al., 2024).

To address this, diffusion language models (Austin et al., 2021a; Li et al., 2022) have emerged as a powerful alternative, generating sequences through iterative denoising with bidirectional attention and parallel token predictions. This paradigm offers distinct advantages over AR models (Li et al., 2025b), including accelerated inference, stronger global coherence, and controllable quality–speed trade-offs. Recent progress (Labs et al., 2025; Nie et al., 2025; Ye et al., 2025b) has further demonstrated the practicality and competitiveness of discrete diffusion large language models (dLLMs). Commercial dLLMs such as Mercury Coder (Labs et al., 2025) and Gemini Diffusion (Google DeepMind, 2025) claim to match the performance of autoregressive LLMs (Hurst et al., 2024; Team et al., 2024) while achieving up to $10\times$ faster inference on tasks like code generation (Chen et al., 2021; Austin et al., 2021b).

Despite recent advances, current discrete dLLM decoding strategies (Israel et al., 2025; Yu et al., 2025; Wu et al., 2025) suffer from a critical limitation: once a token is accepted, it is typically fixed and cannot be modified in later steps (Wang et al., 2025; von Rütte et al., 2025). For instance, in two widely adopted open-source dLLMs, LLaDA (Nie et al., 2025) and Dream (Ye et al., 2025b), a token is considered *accepted* if, at a specific iteration, it is unmasked and no longer remasked, as illustrated in Figure [1](https://arxiv.org/html/2510.05090v1#S1.F1).
Once accepted, it will serve as fixed context for all future predictions. This causes early mistakes to persist and propagate throughout the generation process (Wang et al., 2025; von Rütte et al., 2025).

Figure: Figure 1: Overview of Tolerator. Compared to the vanilla decoding strategy, we first fill the masked tokens with high parallelism and then iteratively refine the draft through token-level cross-validation. Here, cross-validation means tokens alternately act as the target and the context of prediction. This process allows previously accepted tokens to be revisited and corrected when necessary.
Refer to caption: src/figures/pdf/overview_v7.jpg

There have been some early explorations on this issue. ReMDM (Wang et al., 2025) introduces a sampler that applies a stochastic backward remasking process for predicted tokens. RCR (He et al., 2025) tracks each token’s running max confidence and remasks persistently low-confidence tokens. GIDD (von Rütte et al., 2025) trains diffusion models with a mixing schedule that interpolates between data and noise distributions to enable the remasking of predicted tokens. While these works demonstrate the significance of dLLM decoding strategies, their improvements have not achieved ideal performance on general tasks, so the challenge remains an open problem.

To further bridge this gap, we propose Tolerator (Token-Level Cross-Validation Refinement), a test-time dLLM decoding method that explicitly separates generation into two stages: fill-up and refinement. In the first stage, we fill up the masked tokens following vanilla dLLM decoding strategy. In the second stage, we iteratively refine this draft by remasking and decoding subsets of tokens while using the remaining as context, so that predictions are revised by cross-validating against one another.
Our approach differs from existing strategies which perform refinement within the ongoing generation process. By explicitly decoupling fill-up and refinement into two separate phases, Tolerator enables a more thorough form of token-level error correction than prior methods.

We evaluate Tolerator on five standard benchmarks across language understanding (TriviaQA (Joshi et al., 2017), GPQA (Rein et al., 2024)), code generation (MBPP (Austin et al., 2021b), HumanEval (Chen et al., 2021)), and mathematics (GSM8K (Cobbe et al., 2021)). We use vanilla decoding, ReMDM (Wang et al., 2025), and RCR (He et al., 2025) as baselines. Experimental results show that, under the same computational cost measured by the number of forward steps, Tolerator achieves noticeable and consistent improvements over the baselines (relatively improves 17.9% for Dream (Ye et al., 2025b) and 15.3% on LLaDA (Nie et al., 2025)). Overall, our findings indicate that decoding strategy is not merely an implementation detail, but a crucial factor that substantially influences the performance of dLLMs.

## 2 Related Work

### 2.1 From Autoregression to Diffusion

Modern natural language generation (Hendrycks et al., 2020; Suzgun et al., 2023; Rein et al., 2024) has been dominated by the autoregressive (AR) model architectures like GPT (Brown et al., 2020) and LLaMA (Touvron et al., 2023). Despite its empirical success, AR models introduce a fundamental bottleneck: generation is inherently sequential, limiting decoding parallelism (Li et al., 2023; Zou et al., 2023). To address this limitation, diffusion language models (Austin et al., 2021a; Li et al., 2022) have emerged as a promising alternative (Li et al., 2025b). By reversing a noising process over multiple steps, diffusion language models generate tokens in parallel (Labs et al., 2025) while leveraging full bidirectional attention (Nie et al., 2025; Ye et al., 2025b).

Existing diffusion language models can be classified into three main categories depending on how the diffusion process is applied. Early *continuous diffusion language models* (Li et al., 2022; Strudel et al., 2022; Karimi Mahabadi et al., 2024; Lovelace et al., 2023; Dieleman et al., 2022) denoised *embeddings* before mapping them back to tokens. However, this paradigm struggles with issues like optimization and has largely been replaced by discrete diffusion language models. *Discrete diffusion language models* (Austin et al., 2021a; He et al., 2023) define diffusion directly in *token* space, and further scale up model parameter size (Gong et al., 2025), achieving the state-of-the-art with open-source models like Dream (Ye et al., 2025b) and LLaDA (Nie et al., 2025). A third line integrates AR philosophy with diffusion, including block-wise or multi-level scheduling (Han et al., 2023; Wu et al., 2023) and the reintroduction of sequential dependency while retaining diffusion-style refinement (Arriola et al., 2025; Huang & Tang, 2025).

### 2.2 Training and Inference Strategies in Diffusion Language Models

Beyond architectural explorations, another line of work studies how to effectively train diffusion LMs.
Large-scale instruction tuning (Ye et al., 2025b; Nie et al., 2025) has demonstrated that diffusion models can achieve general capabilities comparable to autoregressive LLMs.
Researchers also explore refinements of the training objective: simplified masked losses (Shi et al., 2024; Sahoo et al., 2024), likelihood-based formulations (Gulrajani & Hashimoto, 2023), and variants that enhance generation robustness and reasoning (von Rütte et al., 2025; Ye et al., 2025a).
Another direction focuses on adapting reinforcement learning to diffusion, either to strengthen reasoning (Huang & Tang, 2025; Ye et al., 2024; Zhao et al., 2025) or for preference optimization (Zhu et al., 2025).

Decoding is another key bottleneck for diffusion language models: parallel generation improves efficiency but often degrades quality. Adaptive Parallel Decoding (APD) (Israel et al., 2025) mitigates this trade-off by adjusting the degree of parallelism with an auxiliary autoregressive verifier, while dilated (Luxembourg et al., 2025) scheduling further accelerates inference. At the same time, KV-caching (Ma et al., 2025; Wu et al., 2025) and autoregressive-guided unmasking (Hu et al., 2025) are applied to further accelerate dLLMs. Recent works (Li et al., 2025a; Kim et al., 2025) also address flexibility by extending diffusion to variable-length and token insertion.

### 2.3 Error Correction in Diffusion Decoding

It is often claimed that vanilla discrete diffusion language models possess an inherent ability for error correction, since each position is repeatedly predicted as the context evolves over iterations (Wang et al., 2025; Google DeepMind, 2025). However, this view is incomplete: once a token is accepted, it becomes fixed and cannot be revised. For example, LLaDA (Nie et al., 2025) and Dream (Ye et al., 2025b) decide at every iteration whether a token should be further remasked; if it is not, the token is considered accepted and remains unchanged thereafter. As a result, any early mistake will persist and propagate through subsequent steps, limiting the reliability of diffusion generation.

Several methods have sought to address this limitation. ReMDM (Wang et al., 2025) introduces a probabilistic remasking process that allows already revealed tokens to be re-predicted. RCR (He et al., 2025) proposes a simple confidence-based strategy that remasks uncertain tokens during inference. GIDD (von Rütte et al., 2025) modifies the corruption process with hybrid noise during training. While these approaches demonstrate the feasibility of token revision, their empirical gains remain relatively modest on general tasks or they require additional training, leaving the core problem unresolved. In contrast, our approach departs from prior work by explicitly decoupling fill-up and refinement. We first generate a draft following vanilla diffusion decoding, and then apply a targeted refinement stage that revisits the accepted tokens according to a cross-validation principle. This separation not only makes error correction conceptually more systematic but also delivers markedly stronger empirical gains.

## 3 Methodology

### 3.1 Preliminaries

#### Decoding in Discrete dLLMs.

We consider the decoding process of discrete diffusion large language models (Ye et al., 2025b; Nie et al., 2025). Specifically, let $x^{(t)}_{i}\in\mathcal{V}$ denote the token at position $i\in\{1,\dots,L\}$ and time step $t\in\{0,\dots,T\}$, where $\mathcal{V}$ is the vocabulary, $L$ is the sequence length, and $T$ is the total number of forward steps. At inference time, the sequence is initialized with

$$ $x^{(0)}\;=\;\bigl(c_{1},\dots,c_{m},\underbrace{\text{[{MASK}]}_{m+1},\dots,\text{[{MASK}]}_{L}}_{L-m}\bigr)\;\in\;\mathcal{V}^{L},$ $$

where $c_{1}$ to $c_{m}$ are prompt tokens and the remaining $L-m$ positions are masked tokens. At each time step, discrete diffusion large language models output the logits of all masked tokens and decode them by sampling, where $y^{(t)}_{i}\sim p_{\theta}(\cdot\mid x^{(t)},t)$, and $p_{\theta}$ is the conditional distribution parameterized by the dLLMs. A deterministic rule then decides whether to accept or remask each decoded token.
Specifically, the next sequence is constructed as

$$ $x^{(t+1)}_{i}=\begin{cases}y^{(t)}_{i},&\text{accepted},\[6.0pt] \text{[{MASK}]},&\text{remasked},\end{cases}\quad\text{for }i\notin\mathcal{I}_{t},\qquad x^{(t+1)}_{j}=x^{(t)}_{j}\quad\text{for }j\in\mathcal{I}_{t}.$ $$

where $\mathcal{I}_{t}\subseteq\{1,\dots,L\}$ is the index set of tokens already accepted at step $t$. In the vanilla setup, each step accepts approximately $\lfloor L/T\rfloor$ tokens, which are selected based on criteria like model confidence or entropy. Different dLLMs may adopt alternative decoding strategies. For example, semi-autoregressive decoding (Nie et al., 2025) only proceeds to the next block once all tokens in the current block have been accepted. Our study focuses on the vanilla setup, as it is widely adopted in existing dLLMs.

#### Limitations of Conventional Discrete dLLM Decoding.

In the conventional decoding setup, masked positions are iteratively unmasked and decoded, while accepted tokens become fixed and remain unchanged. Formally, once a position index $i$ enters the visible set $\mathcal{I}_{t}$, we have $i\in\mathcal{I}_{t^{\prime}}$ and $x^{(t^{\prime})}_{i}=x^{(t)}_{i}$ for all $t^{\prime}>t$. As a result, an early error at position $j\in\mathcal{I}_{t}$ is permanently preserved and enters the context for all future predictions $p_{\theta}(x^{(t^{\prime})}_{i}\mid x^{(t^{\prime}-1)},t^{\prime}-1)$, where $i\notin\mathcal{I}_{t^{\prime}-1}$. Such errors cannot be revised and may propagate through the decoding process as persistent noise, ultimately degrading the quality of the generated sequence.

### 3.2 Method Overview

To overcome this limitation, we propose Tolerator (Token-Level Cross-Validation Refinement), which moves beyond the traditional view of decoding as a single, progressive unmasking trajectory, and instead reframes it as a two-stage process of fill-up and refinement.

#### Stage I (Sequence Fill-Up).

In the fill-up stage, the model produces a coarse draft by filling masked positions following the vanilla dLLM decoding strategy, providing a complete but potentially imperfect hypothesis of the output.

Stage II (Cross-Validation Refinement).
In the refinement stage, our iterative procedure follows a token-level cross-validation principle, where tokens alternately act as validator and as validation targets. This alternating role improves the overall consistency of generated sequence.

Overall, this design offers a training-free, model-agnostic solution to the challenge of irreversible early errors and their propagation in the decoding process.

### 3.3 Sequence Fill-Up

The sequence fill-up stage is largely based on the vanilla dLLM decoding procedure described in Section [3.1](https://arxiv.org/html/2510.05090v1#S3.SS1.SSS0.Px1). However, to facilitate the refinement stage, we introduce one modification: the logit penalty on the End-of-Text (EoT) token.

#### EoT Penalty.

Since the refinement stage can correct errors, we prefer longer and more informative drafts to overly short completions. To this end, we apply an *EoT penalty* (Bai et al., 2021; Laban et al., 2020), which discourages the generation of EoT tokens in the fill-up stage. Concretely, we scale down the logit of the EoT token by a factor $\lambda_{\text{eot}}>1$ before softmax. While this adjustment does not directly improve draft quality, it effectively prevents early termination and produces drafts that are better suited for subsequent refinement. Formally, let $z_{v}$ be the unnormalized logit for token $v$ at position $i$ and time step $t$. The penalized distribution is

$$ $\tilde{p}_{\theta}(v\mid x^{(t)},t)\propto\begin{cases}\exp(z_{v})/\lambda_{\text{eot}},&\text{if }v=\texttt{[EoT]}\\ \exp(z_{v}),&\text{otherwise.}\end{cases}$ $$

Finally, the fill-up stage produces a sequence consisting of the prompt tokens and model predictions for previously masked positions:

$$ $x^{(\rho T)}=\bigl(c_{1},\dots,c_{m},\,x^{(\rho T)}_{m+1},\dots,x^{(\rho T)}_{L}\bigr)\in\mathcal{V}^{L},$ $$

where $x^{(\rho T)}_{i}\neq\texttt{[MASK]}$ for all $i>m$. Here $\rho\in(0,1)$ controls the split between the two stages.

### 3.4 Cross-Validation Refinement

The refinement stage corrects errors in the draft with a token-level cross-validation principle, where tokens alternately act as validator and as validation targets. In each iteration, a different subset of tokens is *sampled*, *remasked* and *decoded* conditioned on the preserved context, progressively reducing mistakes and improving coherence.

#### Iterative Refinement.

At each iteration $k$, we remask a random subset $S^{(k)}\subseteq\{m+1,\dots,L\}$ of non-prompt positions, sampled at rate $\gamma_{k}$ so that $|S^{(k)}|=\lfloor\gamma_{k}(L-m)\rfloor$.

$$ $x^{(k)}_{i}=\begin{cases}\texttt{[MASK]},&i\in S^{(k)}\\ x^{(k)}_{i},&\text{otherwise.}\end{cases}$ $$

The sequence for the next iteration is then obtained by predicting the masked tokens:

$$ $x^{(k+1)}_{i}=\begin{cases}y^{(k)}_{i},&i\in S^{(k)}\\ x^{(k)}_{i},&\text{otherwise,}\end{cases}\quad\text{where }y^{(k)}_{i}\sim p_{\theta}(\cdot\mid x^{(k)},k).$ $$

In each iteration, a subset of generated tokens is held fixed as context, while the remaining tokens are remasked and decoded to better align with the fixed context tokens. Iterating this process gradually improves the coherence of the entire sequence.

#### Annealed Refinement Rate.

To improve the stability of refinement steps, we anneal the refinement rate $\gamma_{k}$ over time. Higher refinement rates in early iterations encourage broader corrections of initial errors, while lower rates in later iterations help stabilize the predictions. We adopt a cosine annealing schedule with both upper and lower bounds:

$$ $\gamma_{k}\;=\;\gamma_{\min}+\tfrac{1}{2}(\gamma_{\max}-\gamma_{\min})\left(1+\cos\!\ \bigl(\tfrac{\pi k}{K}\bigr)\right),$ $$

where $k$ is the current refinement iteration and $K$ is the total number of refinement steps.

## 4 Experiment

### 4.1 Experimental Setup

#### Models.

Following previous studies (Ma et al., 2025; Israel et al., 2025; Wu et al., 2025; He et al., 2025), we evaluate our method on two representative open-source discrete dLLMs: Dream-v0-Instruct-7B (Ye et al., 2025b) and LLaDA-8B-Instruct (Nie et al., 2025). Both are state-of-the-art representatives of open-source discrete diffusion large language models.

#### Datasets & Metrics.

To assess the general effectiveness of our method, we evaluate it on three representative tasks with five standard benchmarks: (i) language understanding with TriviaQA (Joshi et al., 2017) and GPQA (Rein et al., 2024), (ii) code generation with HumanEval (Chen et al., 2021) and MBPP (Austin et al., 2021b), and (iii) mathematics with GSM8K (Cobbe et al., 2021). We report accuracy for TriviaQA, GPQA, GSM8K and pass@1 for HumanEval and MBPP.

#### Baselines.

We compare our method against the vanilla decoding strategy and two training-free baselines that propose to revise the accepted tokens. (i) Vanilla follows the standard dLLM decoding procedure: once a token is accepted, it remains fixed throughout the generation process and cannot be revised. (ii) ReMDM (Wang et al., 2025) introduces a stochastic sampler that applies a backward remasking process for predicted tokens. (iii) RCR (He et al., 2025) records each token’s running max confidence and remasks persistently low-confidence tokens.

#### Configurations.

For fairness, all methods are evaluated with the same dLLM backbones in the zero-shot setting. We equalize the computational cost between baselines and our method by allocating the same total forward-step budget. Specifically, for our method, we set the allocation ratio $\rho$ between sequence fill-up and refinement to 0.5. However, it is worth noting that our method itself has no restriction on how steps are allocated. This constraint is introduced solely to ensure a fair comparison.

For our method, we adopt a cosine annealing scheduler for the refinement rate with $\gamma_{\max}=0.8$ and $\gamma_{\min}=0.4$, and increase the EoT penalty $\lambda_{\text{eot}}$ from 1.0 to 1.3 as the number of forward steps $T$ grows. For baselines, we use the recommended hyperparameters for ReMDM ($t_{\text{on}}=0.55$, $t_{\text{off}}=0.05$, $\alpha_{\text{on}}=0.9$) and use the linear remasking scheduling function for RCR, which is reported to be optimal (He et al., 2025).

We follow the default prompts from the LM-Eval framework (Gao et al., 2024) and fix the generation length $L$ at 256. The total number of forward steps $T$ varies from 4 to 256 in powers of two, covering the scenarios from highly parallel to fully sequential decoding. All experiments are run on 8 NVIDIA H200 GPUs, and each data point is evaluated with three random seeds to ensure statistical significance.

### 4.2 Main Results

Figure: Figure 2: Performance-Efficiency Trade-Off for Different Decoding Methods. This figure illustrates the performance of different methods under varying parallel sizes. Gray bars represent generation throughput (tokens per second, TPS). Colored lines show average performance across five benchmarks as forward step $T$ varies.
Refer to caption: x1.png

Figure: Figure 3: Performance across different benchmarks for different decoding methods. This figure presents the performance of various methods under different benchmarks. Colored bars represent average performance across different forward steps ($T$).
Refer to caption: x2.png

To systematically evaluate performance across tasks and inference speeds, we compared our method against three baselines on five standard datasets. Some prior work (Nie et al., 2025; Ye et al., 2025b; Zhu et al., 2025) mainly focused on non-parallel decoding, where the number of forward steps equals the generation length. This setting achieves the highest accuracy but is also the most computationally expensive. In contrast, we additionally examined parallel decoding scenarios, which we consider to be an essential feature of dLLMs and more common in practical applications (Labs et al., 2025; Google DeepMind, 2025). Specifically, for a generation length of $L=256$, we varied the forward step budget $T$ over values of 4, 8, 16, 32, 64, 128, and 256. This corresponds to decoding 64, 32, 16, 8, 4, 2, and 1 tokens per forward pass. Figures [2](https://arxiv.org/html/2510.05090v1#S4.F2) and [3](https://arxiv.org/html/2510.05090v1#S4.F3) show the average performance across different forward steps and tasks (with detailed results in Appendix [A](https://arxiv.org/html/2510.05090v1#A1)).

Figure [2](https://arxiv.org/html/2510.05090v1#S4.F2) illustrates the *performance–efficiency* trade-off curves. Tolerator consistently improves generation quality across parallel decoding settings. On Dream, our method outperforms baselines with especially large gains at moderate parallelism levels (between 8 and 128 steps). On average, the percentage score increases from 29.0 to 34.6 (+17.9% relatively). On LLaDA, improvements are similarly strong and remain stable even at extreme settings (steps = 4 and 256), with average performance increased from 21.3 to 24.5 (+15.3% relatively). These results demonstrate that our approach improves over the baselines and adapts well across different levels of parallelism.

Figure [3](https://arxiv.org/html/2510.05090v1#S4.F3) summarizes performance across the five tasks, averaged over all forward steps. In most cases, our method outperforms the baselines. For instance, on Dream, the average score on TriviaQA improves from 24.8 to 36.1 (+45.16% relatively), while on LLaDA, the score on GSM8K improves from 30.46 to 46.28 (+51.91% relatively). Overall, these findings highlight the robustness and broad applicability of our method as a general improvement of dLLM decoding strategies.

### 4.3 Ablation Studies

To analyze the effect of different components in our decoding strategy, we conduct ablation studies on (i) token-level cross-validation refinement, (ii) EoT Penalty, and (iii) refinement rate annealing.

#### Cross-Validation Refinement.

**Table 1: Performance under different refinement steps (#$R$) with fixed fill-up stage steps. Results are reported for both Dream-Instruct and LLaDA on GPQA and GSM8K.**
| Fill-Up | Model | Task | #$R$=0 | #$R$ = 4 | #$R$ = 8 | #$R$ = 16 | #$R$ = 32 | #$R$ = 64 | #$R$ = 128 | #$R$ = 256 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Steps = 16 | Dream | GPQA | 18.23 | 26.56 | 26.95 | 27.73 | 29.30 | 26.95 | 27.34 | 26.95 |
| Dream | GSM8K | 26.79 | 41.41 | 42.19 | 47.66 | 58.20 | 64.45 | 65.23 | 66.80 |  |
| LLaDA | GPQA | 19.87 | 25.39 | 22.66 | 25.39 | 21.09 | 23.83 | 24.22 | 24.61 |  |
| LLaDA | GSM8K | 22.87 | 48.44 | 52.73 | 51.95 | 54.69 | 58.59 | 56.64 | 58.98 |  |
| Steps = 64 | Dream | GPQA | 22.25 | 28.12 | 31.64 | 31.64 | 31.64 | 35.16 | 35.55 | 30.08 |
| Dream | GSM8K | 50.11 | 53.91 | 60.16 | 60.94 | 66.80 | 69.92 | 73.05 | 71.48 |  |
| LLaDA | GPQA | 25.00 | 23.83 | 25.39 | 19.53 | 25.78 | 26.95 | 22.66 | 25.39 |  |
| LLaDA | GSM8K | 40.99 | 59.38 | 64.06 | 66.02 | 67.97 | 65.23 | 71.09 | 69.14 |  |

We fix the number of forward steps in the fill-up stage at 16 and 64, then gradually increase the number of cross-validation refinement steps (#$R$) from 0 to 256. The results are shown in Table [1](https://arxiv.org/html/2510.05090v1#S4.T1). We first observe that even a small number of refinement steps leads to substantial performance gains. For instance, on GSM8K, LLaDA achieves 22.87 with vanilla decoding in 16 steps. Adding just 4 refinement steps nearly doubles performance to 48.44.

Moreover, on GSM8K, increasing the number of refinement steps to 128 or even 256 continues to yield steady improvements. On GPQA, the trend is less pronounced, but the benefit of enabling cross-validation refinement is consistent: across all step counts, refinement outperforms the baseline without refinement (from 21.34 to 26.86 averaged over two models and two forward steps). Overall, these results demonstrate that the cross-validation refinement design is effective and well-motivated.

#### EoT penalty.

Figure: Figure 4: Ablation Studies of EoT Penalty. We fix the fill-up and refinement configurations while varying $\lambda_{\text{eot}}$ from 1.0 to 1.3, with results shown for 32 and 128 forward step $T$. Across most tasks, introducing an appropriate EoT penalty substantially improves generation quality. The precise numerical values are reported in Appendix [A](https://arxiv.org/html/2510.05090v1#A1).
Refer to caption: x3.png

To isolate the impact of the EoT penalty, we fix the fill-up and refinement configurations and vary only the penalty coefficient $\lambda_{\text{eot}}$. Specifically, we vary $\lambda_{\text{eot}}$ from 1.0 to 1.3 while keeping the number of forward step $T$ fixed at 32 and 128.
We find that applying non-trivial $\lambda_{\text{eot}}$ consistently improves generation quality, with notable gains at $\lambda_{\text{eot}}=1.1$, $1.2$, and $1.3$ (+23.2%, +28.4%, +23.9% relatively).
This is because the EoT penalty encourages longer fill-up sequence: although these drafts may not always be fully correct, they tend to contain more information overall. During refinement, the useful content can be preserved and amplified while the incorrect parts are likely to be corrected.

#### Refinement Rate Annealing.

**Table 2: Performance of LLaDA and Dream models with and without refinement rate annealing. Across varying forward steps (#$F$), annealing consistently improves accuracy for both models on GSM8K and TriviaQA.**
| Model | Task | Setting | #$F$=4 | #$F$=8 | #$F$=16 | #$F$=32 | #$F$=64 | #$F$=128 | #$F$=256 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LLaDA | GSM8K | w/ Annealing | 20.31 | 24.22 | 35.55 | 52.73 | 65.49 | 70.18 | 70.31 |
| w/o Annealing | 19.92 | 22.66 | 33.98 | 52.73 | 60.55 | 65.23 | 68.75 |  |  |
| Dream | GSM8K | w/ Annealing | 12.37 | 25.26 | 36.20 | 50.00 | 62.76 | 69.53 | 74.09 |
| w/o Annealing | 14.06 | 23.05 | 33.98 | 47.27 | 64.84 | 67.97 | 70.31 |  |  |
| LLaDA | TriviaQA | w/ Annealing | 14.84 | 16.41 | 19.14 | 20.70 | 26.17 | 29.30 | 24.22 |
| w/o Annealing | 13.67 | 15.62 | 17.19 | 19.92 | 19.53 | 21.88 | 23.44 |  |  |
| Dream | TriviaQA | w/ Annealing | 0.78 | 0.78 | 1.56 | 3.52 | 8.98 | 12.50 | 16.02 |
| w/o Annealing | 0.39 | 2.34 | 1.17 | 0.78 | 4.30 | 10.94 | 15.23 |  |  |

In cross-validation refinement, we found that the ratio between sampled predicted tokens serving as validators and those serving as validation targets (referred to as the *refinement rate* here) is critical. A rate that is too small makes it difficult to effectively revise validated tokens, while a rate that is too large limits the available context and lowers refinement quality. Thus, choosing an appropriate refinement rate is essential for stable performance. To achieve this balance, we introduce cosine annealing of the refinement rate, which provides sufficient momentum in the early steps of refinement while ensuring stability in the later steps.

To evaluate the effectiveness of this design, we compare the performance of Dream and LLaDA on GSM8K and TriviaQA with and without refinement rate annealing across different numbers of forward steps (Table [2](https://arxiv.org/html/2510.05090v1#S4.T2)). For LLaDA, annealing consistently delivers an average improvement of +2.1 points across all step settings on GSM8K. For Dream, while exceptions occur at 4 and 64 steps, the overall effect is still an average improvement of +1.3 points on this dataset. On TriviaQA, refinement rate annealing remains effective across most forward steps, delivering average gains of +2.8 on LLaDA and +1.3 on Dream. These results demonstrate that refinement rate annealing is, overall, a robust and effective strategy.

Furthermore, Appendix [C](https://arxiv.org/html/2510.05090v1#A3) presents several case studies that qualitatively illustrate the error correction process of our method.

## 5 Discussion

### 5.1 Why our method can be training-free?

Our method does not require additional training, yet still achieves significant improvements, because the refinement stage closely matches the training objective of dLLMs. During training, these models reconstruct randomly masked tokens given the visible context, and the loss is computed uniformly over all masked positions. This is exactly what our refinement stage does: in each iteration, a subset of tokens is remasked and predicted conditioned on the others, so that every token can in turn act as target or context under the same conditional distribution the model was optimized for.

Vanilla decoding, by contrast, is not fully consistent with this training setup. At inference it accepts a small set of the most confident tokens (based on logit features). The predictions are evaluated only on those high-confidence positions, while other masked tokens contribute nothing and simply get remasked—despite the fact that, during training, losses were computed on them as well.

### 5.2 Why our strategy is good for large parallel sizes?

Our method achieves better improvements in parallel decoding scenarios, i.e., when the forward step is smaller than the sequence length and multiple tokens are decoded in each forward step.

One key reason may lie in the visibility constraint during parallel decoding: tokens generated within the same step cannot attend to each other, which often leads to local inconsistencies. This phenomenon is even more noticeable with larger parallel sizes. Our token-level cross-validation process helps to mitigate this issue. During cross-validation, tokens filled up in the same step can be validated such that one serves as context (or validator) while another serves as the validation target. This mechanism enables tokens that were originally invisible to each other to interact directly—for example, when validating token A, token B (from the same step) can now be used as part of the context. Such interactions promote coherence among simultaneously decoded tokens. By repeating this process across multiple rounds, inconsistencies introduced by parallel decoding are progressively reduced, resulting in more coherent sequences overall.

In contrast, when the forward step equals the sequence length (i.e., non-parallel decoding with one token per step), every token naturally conditions on all previously accepted tokens. Since there is no within-step invisibility, the inconsistency problem does not arise, and thus the potential benefit of our method is relatively limited in this scenario.

### 5.3 Limitations

#### Format Stability.

Although our method achieves consistent improvements across benchmarks, the gains are relatively smaller on code generation tasks such as HumanEval (Chen et al., 2021) and MBPP (Austin et al., 2021b). These tasks are highly format-sensitive, where even slight deviations in syntax or structure can render an otherwise correct solution invalid. Because our refinement process operates purely at the token level and does not enforce explicit structural constraints, it can occasionally disrupt the formatting of well-formed code. This indicates a limitation of our approach when applied to domains that demand strict output adherence. A similar limitation has also been noted in methods such as RCR (He et al., 2025), which require heavier remasking than vanilla generation and can likewise compromise sequence formatting.

#### Natural Convergence.

The cross-validation refinement in our method can be viewed as an iterative self-mapping process, where the input and output spaces are identical. Ideally, such a process should terminate naturally when, after a certain iteration, the sequence reaches a stable fixed point—subsequent updates would then map the sequence onto itself, eliminating the need to predefine a fixed number of steps. In practice, however, our current approach does not exhibit this kind of natural convergence. Even after many refinement steps, while the number of tokens edited by the model tends to decrease, it never converges to zero. Instead, the process continues to oscillate.

## 6 Conclusion

In this work, we revisited a key limitation of diffusion large language models (dLLMs): once a token is accepted during decoding, it is typically fixed and cannot be revised, causing early mistakes to persist and propagate through subsequent iterations. To address this, we proposed Tolerator, a training-free decoding strategy that explicitly decouples decoding into fill-up and refinement stages. By first generating a coarse draft and then iteratively remasking and decoding tokens with the token-level cross-validation principle, Tolerator enables more systematic and effective error correction than prior approaches.

Through extensive experiments on five benchmarks spanning natural language understanding, code generation, and mathematical reasoning, we showed that Tolerator consistently improves over baselines under the same forward step budgets. Beyond empirical gains, our results highlight that decoding strategy is not merely an implementation choice, but a crucial component that influences the overall performance of dLLMs.

## Ethics Statement

All datasets used in this work (TriviaQA (Joshi et al., 2017), GPQA (Rein et al., 2024), GSM8K (Cobbe et al., 2021), HumanEval (Chen et al., 2021), MBPP (Austin et al., 2021b)) are publicly available academic benchmarks that do not contain personally identifiable or sensitive information. Our study focuses on improving inference in discrete diffusion language models and does not involve the collection of new human subject data. We acknowledge that large language models may generate incorrect or misleading content, and that code generation models can potentially produce insecure or faulty programs. Our method does not eliminate these risks, and users should exercise caution when deploying such systems in high-stakes scenarios. The potential societal benefits of our work include improved decoding performance of diffusion large language models. This research was conducted in accordance with the ICLR Code of Ethics. The authors take full responsibility for all analyses and conclusions presented in this paper.

## Reproducibility Statement

We have taken several steps to ensure the reproducibility of our results. Our experiments were conducted on two representative open-source discrete diffusion language models: Dream-v0-Instruct-7B (Ye et al., 2025b) and LLaDA-8B-Instruct (Nie et al., 2025). We evaluate across five widely used public benchmarks—TriviaQA (Joshi et al., 2017), GPQA (Rein et al., 2024), GSM8K (Cobbe et al., 2021), HumanEval (Chen et al., 2021), and MBPP (Austin et al., 2021b). For all methods, we adopt the same model backbones, zero-shot setting, and equalized computational budgets to guarantee fairness. Reported results are averaged over 3 random seeds, and exact numerical results for both main experiments and ablations are provided in the appendix. We detail hyperparameter configurations in Section 4.1, including scheduler settings, penalty coefficients, and baseline parameters (ReMDM (Wang et al., 2025) and RCR (He et al., 2025)). Code, configuration files, and data preprocessing scripts are made anonymously available to facilitate replication. With the provided code and instructions, our results can be reproduced using 8×H200 GPUs or equivalent hardware.

## References

- Anthropic (2025)
Anthropic.
Claude code — claude.
[https://claude.com/product/claude-code](https://claude.com/product/claude-code), 2025.
Accessed: 2025-09-24.
- Arriola et al. (2025)
Marianne Arriola, Aaron Gokaslan, Justin T Chiu, Zhihan Yang, Zhixuan Qi, Jiaqi Han, Subham Sekhar Sahoo, and Volodymyr Kuleshov.
Block diffusion: Interpolating between autoregressive and diffusion language models.
*arXiv preprint arXiv:2503.09573*, 2025.
- Austin et al. (2021a)
Jacob Austin, Daniel D. Johnson, Jonathan Ho, Daniel Tarlow, and Rianne van den Berg.
Structured denoising diffusion models in discrete state-spaces.
In M. Ranzato, A. Beygelzimer, Y. Dauphin, P.S. Liang, and J. Wortman Vaughan (eds.), *Advances in Neural Information Processing Systems*, volume 34, pp. 17981–17993. Curran Associates, Inc., 2021a.
URL [https://proceedings.neurips.cc/paper_files/paper/2021/file/958c530554f78bcd8e97125b70e6973d-Paper.pdf](https://proceedings.neurips.cc/paper_files/paper/2021/file/958c530554f78bcd8e97125b70e6973d-Paper.pdf).
- Austin et al. (2021b)
Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, et al.
Program synthesis with large language models.
*arXiv preprint arXiv:2108.07732*, 2021b.
- Bai et al. (2021)
He Bai, Peng Shi, Jimmy Lin, Luchen Tan, Kun Xiong, Wen Gao, Jie Liu, and Ming Li.
Semantics of the unwritten: The effect of end of paragraph and sequence tokens on text generation with GPT2.
In Jad Kabbara, Haitao Lin, Amandalynne Paullada, and Jannis Vamvas (eds.), *Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing: Student Research Workshop*, pp. 148–162, Online, August 2021. Association for Computational Linguistics.
doi: 10.18653/v1/2021.acl-srw.16.
URL [https://aclanthology.org/2021.acl-srw.16/](https://aclanthology.org/2021.acl-srw.16/).
- Brown et al. (2020)
Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al.
Language models are few-shot learners, 2020.
URL [https://arxiv.org/abs/2005.14165](https://arxiv.org/abs/2005.14165).
- Chen et al. (2021)
Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al.
Evaluating large language models trained on code, 2021.
URL [https://arxiv.org/abs/2107.03374](https://arxiv.org/abs/2107.03374).
- Chowdhery et al. (2022)
Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al.
Palm: Scaling language modeling with pathways, 2022.
URL [https://arxiv.org/abs/2204.02311](https://arxiv.org/abs/2204.02311).
- Cobbe et al. (2021)
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al.
Training verifiers to solve math word problems, 2021.
URL [https://arxiv.org/abs/2110.14168](https://arxiv.org/abs/2110.14168).
- Comanici et al. (2025)
Gheorghe Comanici, Eric Bieber, Mike Schaekermann, Ice Pasupat, Noveen Sachdeva, Inderjit Dhillon, Marcel Blistein, Ori Ram, Dan Zhang, Evan Rosen, et al.
Gemini 2.5: Pushing the frontier with advanced reasoning, multimodality, long context, and next generation agentic capabilities.
*arXiv preprint arXiv:2507.06261*, 2025.
- Dieleman et al. (2022)
Sander Dieleman, Laurent Sartran, Arman Roshannai, Nikolay Savinov, Yaroslav Ganin, Pierre H Richemond, Arnaud Doucet, Robin Strudel, Chris Dyer, Conor Durkan, et al.
Continuous diffusion for categorical data.
*arXiv preprint arXiv:2211.15089*, 2022.
- Fu et al. (2024)
Yichao Fu, Peter Bailis, Ion Stoica, and Hao Zhang.
Break the sequential dependency of llm inference using lookahead decoding.
In *Proceedings of the 41st International Conference on Machine Learning*, ICML’24. JMLR.org, 2024.
- Gao et al. (2024)
Leo Gao, Jonathan Tow, Baber Abbasi, Stella Biderman, Sid Black, Anthony DiPofi, Charles Foster, Laurence Golding, Jeffrey Hsu, Alain Le Noac’h, et al.
The language model evaluation harness, 07 2024.
URL [https://zenodo.org/records/12608602](https://zenodo.org/records/12608602).
- Gong et al. (2025)
Shansan Gong, Shivam Agarwal, Yizhe Zhang, Jiacheng Ye, Lin Zheng, Mukai Li, Chenxin An, Peilin Zhao, Wei Bi, Jiawei Han, et al.
Scaling diffusion language models via adaptation from autoregressive models.
In *The Thirteenth International Conference on Learning Representations*, 2025.
URL [https://openreview.net/forum?id=j1tSLYKwg8](https://openreview.net/forum?id=j1tSLYKwg8).
- Google DeepMind (2025)
Google DeepMind.
Gemini diffusion - google deepmind, 2025.
URL [https://deepmind.google/models/gemini-diffusion/](https://deepmind.google/models/gemini-diffusion/).
Accessed: 2025-09-19.
- Gulrajani & Hashimoto (2023)
Ishaan Gulrajani and Tatsunori B Hashimoto.
Likelihood-based diffusion language models.
*Advances in Neural Information Processing Systems*, 36:16693–16715, 2023.
- Han et al. (2023)
Xiaochuang Han, Sachin Kumar, and Yulia Tsvetkov.
SSD-LM: Semi-autoregressive simplex-based diffusion language model for text generation and modular control.
In Anna Rogers, Jordan Boyd-Graber, and Naoaki Okazaki (eds.), *Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)*, pp. 11575–11596, Toronto, Canada, July 2023. Association for Computational Linguistics.
doi: 10.18653/v1/2023.acl-long.647.
URL [https://aclanthology.org/2023.acl-long.647/](https://aclanthology.org/2023.acl-long.647/).
- He et al. (2025)
Haoyu He, Katrin Renz, Yong Cao, and Andreas Geiger.
Mdpo: Overcoming the training-inference divide of masked diffusion language models, 2025.
URL [https://arxiv.org/abs/2508.13148](https://arxiv.org/abs/2508.13148).
- He et al. (2023)
Zhengfu He, Tianxiang Sun, Qiong Tang, Kuanning Wang, Xuanjing Huang, and Xipeng Qiu.
DiffusionBERT: Improving generative masked language models with diffusion models.
In Anna Rogers, Jordan Boyd-Graber, and Naoaki Okazaki (eds.), *Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)*, pp. 4521–4534, Toronto, Canada, July 2023. Association for Computational Linguistics.
doi: 10.18653/v1/2023.acl-long.248.
URL [https://aclanthology.org/2023.acl-long.248/](https://aclanthology.org/2023.acl-long.248/).
- Hendrycks et al. (2020)
Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt.
Measuring massive multitask language understanding.
*arXiv preprint arXiv:2009.03300*, 2020.
- Hu et al. (2025)
Zhanqiu Hu, Jian Meng, Yash Akhauri, Mohamed S. Abdelfattah, Jae sun Seo, Zhiru Zhang, and Udit Gupta.
Accelerating diffusion language model inference via efficient kv caching and guided diffusion, 2025.
URL [https://arxiv.org/abs/2505.21467](https://arxiv.org/abs/2505.21467).
- Huang & Tang (2025)
Chihan Huang and Hao Tang.
Ctrldiff: Boosting large diffusion language models with dynamic block prediction and controllable generation, 2025.
URL [https://arxiv.org/abs/2505.14455](https://arxiv.org/abs/2505.14455).
- Hurst et al. (2024)
Aaron Hurst, Adam Lerer, Adam P Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, et al.
Gpt-4o system card.
*arXiv preprint arXiv:2410.21276*, 2024.
- Israel et al. (2025)
Daniel Israel, Guy Van den Broeck, and Aditya Grover.
Accelerating diffusion llms via adaptive parallel decoding, 2025.
URL [https://arxiv.org/abs/2506.00413](https://arxiv.org/abs/2506.00413).
- Joshi et al. (2017)
Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer.
TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension.
In Regina Barzilay and Min-Yen Kan (eds.), *Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)*, pp. 1601–1611, Vancouver, Canada, July 2017. Association for Computational Linguistics.
doi: 10.18653/v1/P17-1147.
URL [https://aclanthology.org/P17-1147/](https://aclanthology.org/P17-1147/).
- Karimi Mahabadi et al. (2024)
Rabeeh Karimi Mahabadi, Hamish Ivison, Jaesung Tae, James Henderson, Iz Beltagy, Matthew Peters, and Arman Cohan.
TESS: Text-to-text self-conditioned simplex diffusion.
In Yvette Graham and Matthew Purver (eds.), *Proceedings of the 18th Conference of the European Chapter of the Association for Computational Linguistics (Volume 1: Long Papers)*, pp. 2347–2361, St. Julian’s, Malta, March 2024. Association for Computational Linguistics.
doi: 10.18653/v1/2024.eacl-long.144.
URL [https://aclanthology.org/2024.eacl-long.144/](https://aclanthology.org/2024.eacl-long.144/).
- Kim et al. (2025)
Jaeyeon Kim, Lee Cheuk-Kit, Carles Domingo-Enrich, Yilun Du, Sham Kakade, Timothy Ngotiaoco, Sitan Chen, and Michael Albergo.
Any-order flexible length masked diffusion, 2025.
URL [https://arxiv.org/abs/2509.01025](https://arxiv.org/abs/2509.01025).
- Laban et al. (2020)
Philippe Laban, Andrew Hsi, John Canny, and Marti A. Hearst.
The summary loop: Learning to write abstractive summaries without examples.
In Dan Jurafsky, Joyce Chai, Natalie Schluter, and Joel Tetreault (eds.), *Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics*, pp. 5135–5150, Online, July 2020. Association for Computational Linguistics.
doi: 10.18653/v1/2020.acl-main.460.
URL [https://aclanthology.org/2020.acl-main.460/](https://aclanthology.org/2020.acl-main.460/).
- Labs et al. (2025)
Inception Labs, Samar Khanna, Siddhant Kharbanda, Shufan Li, Harshit Varma, Eric Wang, Sawyer Birnbaum, Ziyang Luo, Yanis Miraoui, Akash Palrecha, et al.
Mercury: Ultra-fast language models based on diffusion, 2025.
URL [https://arxiv.org/abs/2506.17298](https://arxiv.org/abs/2506.17298).
- Li et al. (2025a)
Jinsong Li, Xiaoyi Dong, Yuhang Zang, Yuhang Cao, Jiaqi Wang, and Dahua Lin.
Beyond fixed: Training-free variable-length denoising for diffusion large language models, 2025a.
URL [https://arxiv.org/abs/2508.00819](https://arxiv.org/abs/2508.00819).
- Li et al. (2025b)
Tianyi Li, Mingda Chen, Bowei Guo, and Zhiqiang Shen.
A survey on diffusion language models, 2025b.
URL [https://arxiv.org/abs/2508.10875](https://arxiv.org/abs/2508.10875).
- Li et al. (2022)
Xiang Lisa Li, John Thickstun, Ishaan Gulrajani, Percy Liang, and Tatsunori B. Hashimoto.
Diffusion-lm improves controllable text generation.
In *Proceedings of the 36th International Conference on Neural Information Processing Systems*, NIPS ’22, Red Hook, NY, USA, 2022. Curran Associates Inc.
ISBN 9781713871088.
- Li et al. (2023)
Yifan Li, Kun Zhou, Wayne Xin Zhao, and Ji-Rong Wen.
Diffusion models for non-autoregressive text generation: a survey.
In *Proceedings of the Thirty-Second International Joint Conference on Artificial Intelligence*, IJCAI ’23, 2023.
ISBN 978-1-956792-03-4.
doi: 10.24963/ijcai.2023/750.
URL [https://doi.org/10.24963/ijcai.2023/750](https://doi.org/10.24963/ijcai.2023/750).
- Lovelace et al. (2023)
Justin Lovelace, Varsha Kishore, Chao Wan, Eliot Shekhtman, and Kilian Q Weinberger.
Latent diffusion for language generation.
*Advances in Neural Information Processing Systems*, 36:56998–57025, 2023.
- Luxembourg et al. (2025)
Omer Luxembourg, Haim Permuter, and Eliya Nachmani.
Plan for speed: Dilated scheduling for masked diffusion language models, 2025.
URL [https://arxiv.org/abs/2506.19037](https://arxiv.org/abs/2506.19037).
- Ma et al. (2025)
Xinyin Ma, Runpeng Yu, Gongfan Fang, and Xinchao Wang.
dkv-cache: The cache for diffusion language models, 2025.
URL [https://arxiv.org/abs/2505.15781](https://arxiv.org/abs/2505.15781).
- Minaee et al. (2024)
Shervin Minaee, Tomas Mikolov, Narjes Nikzad, Meysam Chenaghlu, Richard Socher, Xavier Amatriain, and Jianfeng Gao.
Large language models: A survey.
*arXiv preprint arXiv:2402.06196*, 2024.
- Nie et al. (2025)
Shen Nie, Fengqi Zhu, Zebin You, Xiaolu Zhang, Jingyang Ou, Jun Hu, Jun Zhou, Yankai Lin, Ji-Rong Wen, and Chongxuan Li.
Large language diffusion models, 2025.
URL [https://arxiv.org/abs/2502.09992](https://arxiv.org/abs/2502.09992).
- OpenAI (2025)
OpenAI.
Introducing gpt-5.
[https://openai.com/index/introducing-gpt-5/](https://openai.com/index/introducing-gpt-5/), 2025.
Accessed: 2025-09-24.
- Rein et al. (2024)
David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, Julien Dirani, Julian Michael, and Samuel R Bowman.
Gpqa: A graduate-level google-proof q&a benchmark.
In *First Conference on Language Modeling*, 2024.
- Sahoo et al. (2024)
Subham Sahoo, Marianne Arriola, Yair Schiff, Aaron Gokaslan, Edgar Marroquin, Justin Chiu, Alexander Rush, and Volodymyr Kuleshov.
Simple and effective masked diffusion language models.
*Advances in Neural Information Processing Systems*, 37:130136–130184, 2024.
- Shi et al. (2024)
Jiaxin Shi, Kehang Han, Zhe Wang, Arnaud Doucet, and Michalis Titsias.
Simplified and generalized masked diffusion for discrete data.
*Advances in neural information processing systems*, 37:103131–103167, 2024.
- Strudel et al. (2022)
Robin Strudel, Corentin Tallec, Florent Altché, Yilun Du, Yaroslav Ganin, Arthur Mensch, Will Grathwohl, Nikolay Savinov, Sander Dieleman, Laurent Sifre, et al.
Self-conditioned embedding diffusion for text generation, 2022.
URL [https://arxiv.org/abs/2211.04236](https://arxiv.org/abs/2211.04236).
- Suzgun et al. (2023)
Mirac Suzgun, Nathan Scales, Nathanael Schärli, Sebastian Gehrmann, Yi Tay, Hyung Won Chung, Aakanksha Chowdhery, Quoc Le, Ed Chi, Denny Zhou, et al.
Challenging BIG-bench tasks and whether chain-of-thought can solve them.
In Anna Rogers, Jordan Boyd-Graber, and Naoaki Okazaki (eds.), *Findings of the Association for Computational Linguistics: ACL 2023*, pp. 13003–13051, Toronto, Canada, July 2023. Association for Computational Linguistics.
doi: 10.18653/v1/2023.findings-acl.824.
URL [https://aclanthology.org/2023.findings-acl.824/](https://aclanthology.org/2023.findings-acl.824/).
- Team et al. (2024)
Jamba Team, Barak Lenz, Alan Arazi, Amir Bergman, Avshalom Manevich, Barak Peleg, Ben Aviram, Chen Almagor, Clara Fridman, Dan Padnos, et al.
Jamba-1.5: Hybrid transformer-mamba models at scale, 2024.
URL [https://arxiv.org/abs/2408.12570](https://arxiv.org/abs/2408.12570).
- Touvron et al. (2023)
Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, et al.
Llama: Open and efficient foundation language models, 2023.
URL [https://arxiv.org/abs/2302.13971](https://arxiv.org/abs/2302.13971).
- Vaswani et al. (2017)
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin.
Attention is all you need.
In I. Guyon, U. Von Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), *Advances in Neural Information Processing Systems*, volume 30. Curran Associates, Inc., 2017.
URL [https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf](https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf).
- von Rütte et al. (2025)
Dimitri von Rütte, Janis Fluri, Yuhui Ding, Antonio Orvieto, Bernhard Schölkopf, and Thomas Hofmann.
Generalized interpolating discrete diffusion, 2025.
URL [https://arxiv.org/abs/2503.04482](https://arxiv.org/abs/2503.04482).
- Wang et al. (2025)
Guanghan Wang, Yair Schiff, Subham Sekhar Sahoo, and Volodymyr Kuleshov.
Remasking discrete diffusion models with inference-time scaling, 2025.
URL [https://arxiv.org/abs/2503.00307](https://arxiv.org/abs/2503.00307).
- Wu et al. (2025)
Chengyue Wu, Hao Zhang, Shuchen Xue, Zhijian Liu, Shizhe Diao, Ligeng Zhu, Ping Luo, Song Han, and Enze Xie.
Fast-dllm: Training-free acceleration of diffusion llm by enabling kv cache and parallel decoding, 2025.
URL [https://arxiv.org/abs/2505.22618](https://arxiv.org/abs/2505.22618).
- Wu et al. (2023)
Tong Wu, Zhihao Fan, Xiao Liu, Hai-Tao Zheng, Yeyun Gong, Jian Jiao, Juntao Li, Jian Guo, Nan Duan, Weizhu Chen, et al.
Ar-diffusion: Auto-regressive diffusion model for text generation.
*Advances in Neural Information Processing Systems*, 36:39957–39974, 2023.
- Xia et al. (2024)
Heming Xia, Zhe Yang, Qingxiu Dong, Peiyi Wang, Yongqi Li, Tao Ge, Tianyu Liu, Wenjie Li, and Zhifang Sui.
Unlocking efficiency in large language model inference: A comprehensive survey of speculative decoding.
In Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), *Findings of the Association for Computational Linguistics: ACL 2024*, pp. 7655–7671, Bangkok, Thailand, August 2024. Association for Computational Linguistics.
doi: 10.18653/v1/2024.findings-acl.456.
URL [https://aclanthology.org/2024.findings-acl.456/](https://aclanthology.org/2024.findings-acl.456/).
- Ye et al. (2024)
Jiacheng Ye, Shansan Gong, Liheng Chen, Lin Zheng, Jiahui Gao, Han Shi, Chuan Wu, Xin Jiang, Zhenguo Li, Wei Bi, et al.
Diffusion of thought: Chain-of-thought reasoning in diffusion language models.
In A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang (eds.), *Advances in Neural Information Processing Systems*, volume 37, pp. 105345–105374. Curran Associates, Inc., 2024.
URL [https://proceedings.neurips.cc/paper_files/paper/2024/file/be30024e7fa2c29cac7a6dafcbb8571f-Paper-Conference.pdf](https://proceedings.neurips.cc/paper_files/paper/2024/file/be30024e7fa2c29cac7a6dafcbb8571f-Paper-Conference.pdf).
- Ye et al. (2025a)
Jiacheng Ye, Jiahui Gao, Shansan Gong, Lin Zheng, Xin Jiang, Zhenguo Li, and Lingpeng Kong.
Beyond autoregression: Discrete diffusion for complex reasoning and planning, 2025a.
URL [https://arxiv.org/abs/2410.14157](https://arxiv.org/abs/2410.14157).
- Ye et al. (2025b)
Jiacheng Ye, Zhihui Xie, Lin Zheng, Jiahui Gao, Zirui Wu, Xin Jiang, Zhenguo Li, and Lingpeng Kong.
Dream 7b: Diffusion large language models, 2025b.
URL [https://arxiv.org/abs/2508.15487](https://arxiv.org/abs/2508.15487).
- Yu et al. (2025)
Runpeng Yu, Xinyin Ma, and Xinchao Wang.
Dimple: Discrete diffusion multimodal large language model with parallel decoding, 2025.
URL [https://arxiv.org/abs/2505.16990](https://arxiv.org/abs/2505.16990).
- Zhao et al. (2025)
Siyan Zhao, Devaansh Gupta, Qinqing Zheng, and Aditya Grover.
d1: Scaling reasoning in diffusion large language models via reinforcement learning.
*arXiv preprint arXiv:2504.12216*, 2025.
- Zhao et al. (2023)
Wayne Xin Zhao, Kun Zhou, Junyi Li, Tianyi Tang, Xiaolei Wang, Yupeng Hou, Yingqian Min, Beichen Zhang, Junjie Zhang, Zican Dong, et al.
A survey of large language models.
*arXiv preprint arXiv:2303.18223*, 1(2), 2023.
- Zhu et al. (2025)
Fengqi Zhu, Rongzhen Wang, Shen Nie, Xiaolu Zhang, Chunwei Wu, Jun Hu, Jun Zhou, Jianfei Chen, Yankai Lin, Ji-Rong Wen, et al.
Llada 1.5: Variance-reduced preference optimization for large language diffusion models.
*arXiv preprint arXiv:2505.19223*, 2025.
- Zou et al. (2023)
Hao Zou, Zae Myung Kim, and Dongyeop Kang.
A survey of diffusion models in natural language processing, 2023.
URL [https://arxiv.org/abs/2305.14671](https://arxiv.org/abs/2305.14671).

## Appendix A Experimental Details

### A.1 Main Experiment

**Table 3: Main Experiment Results. Performance of Dream and LLaDA across five standard benchmarks under different numbers of forward steps. Highest values for specific task and model are bold.**
| Model | Method | TriviaQA |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| #F=4 | #F=8 | #F=16 | #F=32 | #F=64 | #F=128 | #F=256 |  |  |
| Dream | Vanilla | 23.08$\pm$0.01 | 23.22$\pm$0.02 | 23.16$\pm$0.03 | 23.24$\pm$0.02 | 23.51$\pm$0.01 | 28.08$\pm$0.03 | 29.32$\pm$0.03 |
| ReMDM | 22.11$\pm$1.17 | 22.94$\pm$0.28 | 22.87$\pm$0.10 | 22.94$\pm$0.16 | 23.27$\pm$0.32 | 27.98$\pm$0.41 | 29.26$\pm$0.37 |  |
| RCR | 15.63$\pm$0.23 | 14.53$\pm$0.12 | 15.02$\pm$0.13 | 17.68$\pm$0.13 | 18.92$\pm$0.27 | 26.81$\pm$0.34 | 36.64$\pm$0.42 |  |
| Tolerator | 27.78$\pm$0.29 | 31.61$\pm$0.11 | 33.76$\pm$0.19 | 35.98$\pm$0.16 | 40.61$\pm$0.16 | 42.46$\pm$0.22 | 40.47$\pm$0.16 |  |
| LLaDA | Vanilla | 0.19$\pm$0.02 | 0.65$\pm$0.03 | 2.13$\pm$0.01 | 4.63$\pm$0.02 | 9.36$\pm$0.06 | 16.25$\pm$0.02 | 22.76$\pm$0.01 |
| ReMDM | 0.25$\pm$0.02 | 0.43$\pm$0.01 | 1.08$\pm$0.02 | 1.82$\pm$0.03 | 3.05$\pm$0.06 | 5.43$\pm$0.03 | 8.24$\pm$0.02 |  |
| RCR | 0.09$\pm$0.01 | 0.80$\pm$0.01 | 4.44$\pm$0.01 | 8.62$\pm$0.01 | 16.08$\pm$0.02 | 24.04$\pm$0.01 | 29.30$\pm$0.01 |  |
| Tolerator | 0.99$\pm$0.01 | 1.86$\pm$0.08 | 3.52$\pm$0.09 | 6.19$\pm$0.06 | 10.94$\pm$0.10 | 16.46$\pm$0.09 | 19.72$\pm$0.14 |  |
| Model | Method | GPQA |  |  |  |  |  |  |
| #F=4 | #F=8 | #F=16 | #F=32 | #F=64 | #F=128 | #F=256 |  |  |
| Dream | Vanilla | 10.27$\pm$0.59 | 17.04$\pm$0.34 | 18.23$\pm$0.56 | 20.91$\pm$1.10 | 22.25$\pm$0.93 | 27.01$\pm$0.80 | 27.98$\pm$0.85 |
| ReMDM | 7.44$\pm$1.05 | 15.92$\pm$1.03 | 17.93$\pm$0.13 | 19.27$\pm$0.90 | 22.62$\pm$1.12 | 23.36$\pm$0.72 | 28.20$\pm$0.68 |  |
| RCR | 1.79$\pm$0.21 | 3.12$\pm$0.13 | 7.81$\pm$0.11 | 14.06$\pm$0.28 | 25.00$\pm$0.32 | 24.78$\pm$0.41 | 19.20$\pm$0.43 |  |
| Tolerator | 8.11$\pm$1.05 | 17.19$\pm$0.97 | 22.84$\pm$0.13 | 26.71$\pm$1.45 | 26.93$\pm$1.10 | 29.91$\pm$1.77 | 29.32$\pm$1.23 |  |
| LLaDA | Vanilla | 10.79$\pm$1.58 | 13.47$\pm$1.58 | 19.87$\pm$1.39 | 23.88$\pm$0.67 | 25.00$\pm$1.02 | 25.37$\pm$0.46 | 26.04$\pm$0.13 |
| ReMDM | 9.60$\pm$0.89 | 16.67$\pm$0.13 | 23.66$\pm$1.18 | 24.70$\pm$1.01 | 25.74$\pm$0.68 | 25.82$\pm$1.01 | 24.93$\pm$0.13 |  |
| RCR | 20.46$\pm$0.46 | 18.45$\pm$0.13 | 19.05$\pm$0.13 | 18.97$\pm$0.22 | 21.80$\pm$0.13 | 26.19$\pm$0.13 | 24.78$\pm$0.13 |  |
| Tolerator | 20.76$\pm$1.46 | 20.76$\pm$1.46 | 22.47$\pm$1.45 | 25.67$\pm$1.18 | 27.01$\pm$1.56 | 26.41$\pm$2.03 | 26.86$\pm$1.49 |  |
| Model | Method | HumanEval |  |  |  |  |  |  |
| #F=4 | #F=8 | #F=16 | #F=32 | #F=64 | #F=128 | #F=256 |  |  |
| Dream | Vanilla | 8.13$\pm$0.35 | 13.41$\pm$0.00 | 11.79$\pm$0.35 | 12.80$\pm$0.61 | 26.02$\pm$0.35 | 37.80$\pm$0.61 | 50.61$\pm$0.00 |
| ReMDM | 2.03$\pm$0.70 | 9.35$\pm$0.35 | 12.20$\pm$0.00 | 13.21$\pm$0.35 | 27.03$\pm$0.70 | 38.82$\pm$0.70 | 50.20$\pm$0.93 |  |
| RCR | 1.22$\pm$0.24 | 8.54$\pm$0.31 | 8.54$\pm$0.31 | 22.56$\pm$0.45 | 30.49$\pm$0.37 | 26.22$\pm$0.28 | 26.22$\pm$0.28 |  |
| Tolerator | 4.88$\pm$1.06 | 17.89$\pm$1.27 | 27.03$\pm$2.54 | 30.89$\pm$1.37 | 33.03$\pm$2.21 | 40.24$\pm$0.81 | 47.56$\pm$0.61 |  |
| LLaDA | Vanilla | 9.55$\pm$0.35 | 14.23$\pm$0.35 | 15.24$\pm$1.22 | 15.45$\pm$1.27 | 18.29$\pm$1.40 | 23.68$\pm$2.54 | 27.13$\pm$0.30 |
| ReMDM | 4.88$\pm$1.22 | 6.10$\pm$0.00 | 8.13$\pm$1.27 | 10.37$\pm$1.22 | 18.09$\pm$3.07 | 22.76$\pm$0.70 | 25.61$\pm$3.23 |  |
| RCR | 9.96$\pm$0.35 | 5.08$\pm$0.93 | 7.52$\pm$0.35 | 7.93$\pm$0.35 | 11.99$\pm$0.35 | 15.85$\pm$0.84 | 18.29$\pm$0.31 |  |
| Tolerator | 7.52$\pm$1.53 | 12.40$\pm$0.35 | 20.43$\pm$1.40 | 23.58$\pm$0.93 | 22.05$\pm$0.77 | 24.19$\pm$0.77 | 22.46$\pm$5.99 |  |
| Model | Method | MBPP |  |  |  |  |  |  |
| #F=4 | #F=8 | #F=16 | #F=32 | #F=64 | #F=128 | #F=256 |  |  |
| Dream | Vanilla | 14.40$\pm$0.20 | 14.73$\pm$0.12 | 17.00$\pm$0.20 | 25.00$\pm$0.40 | 31.07$\pm$0.12 | 45.13$\pm$0.31 | 56.93$\pm$0.83 |
| ReMDM | 8.80$\pm$0.53 | 14.67$\pm$0.31 | 15.93$\pm$0.12 | 26.00$\pm$0.20 | 33.13$\pm$0.70 | 45.27$\pm$0.64 | 56.60$\pm$0.35 |  |
| RCR | 4.80$\pm$0.84 | 10.40$\pm$0.71 | 23.60$\pm$0.55 | 29.00$\pm$0.29 | 36.00$\pm$0.36 | 42.60$\pm$0.43 | 41.73$\pm$0.12 |  |
| Tolerator | 10.53$\pm$1.01 | 25.13$\pm$0.64 | 35.00$\pm$0.80 | 41.07$\pm$2.91 | 44.40$\pm$1.20 | 48.47$\pm$1.55 | 51.53$\pm$0.76 |  |
| LLaDA | Vanilla | 9.53$\pm$0.81 | 14.40$\pm$0.40 | 13.40$\pm$0.69 | 17.73$\pm$0.12 | 24.07$\pm$0.64 | 31.27$\pm$0.81 | 37.87$\pm$0.61 |
| ReMDM | 1.53$\pm$0.31 | 2.33$\pm$0.58 | 4.53$\pm$0.42 | 10.53$\pm$0.12 | 17.27$\pm$0.64 | 23.33$\pm$1.72 | 35.47$\pm$0.90 |  |
| RCR | 0.60$\pm$0.40 | 3.47$\pm$0.46 | 10.00$\pm$0.20 | 13.33$\pm$0.12 | 15.93$\pm$0.46 | 22.27$\pm$0.31 | 26.73$\pm$0.12 |  |
| Tolerator | 5.53$\pm$1.03 | 16.00$\pm$0.87 | 22.73$\pm$1.03 | 25.60$\pm$0.69 | 29.27$\pm$0.42 | 33.87$\pm$0.81 | 38.53$\pm$1.50 |  |
| Model | Method | GSM8K |  |  |  |  |  |  |
| #F=4 | #F=8 | #F=16 | #F=32 | #F=64 | #F=128 | #F=256 |  |  |
| Dream | Vanilla | 9.22$\pm$0.46 | 23.07$\pm$0.04 | 26.79$\pm$0.12 | 35.36$\pm$0.09 | 50.11$\pm$0.00 | 65.38$\pm$0.12 | 73.10$\pm$0.06 |
| ReMDM | 11.02$\pm$0.64 | 18.12$\pm$0.59 | 27.98$\pm$0.00 | 35.91$\pm$0.09 | 47.81$\pm$0.09 | 61.66$\pm$0.16 | 70.00$\pm$0.44 |  |
| RCR | 3.79$\pm$0.25 | 6.90$\pm$0.27 | 21.46$\pm$0.33 | 42.00$\pm$0.41 | 48.90$\pm$0.38 | 46.55$\pm$0.29 | 36.47$\pm$0.35 |  |
| Tolerator | 14.40$\pm$0.59 | 24.92$\pm$1.22 | 35.96$\pm$1.45 | 47.66$\pm$0.18 | 62.80$\pm$0.90 | 68.99$\pm$0.92 | 72.61$\pm$0.46 |  |
| LLaDA | Vanilla | 3.23$\pm$0.18 | 7.58$\pm$0.35 | 22.87$\pm$0.70 | 37.55$\pm$0.42 | 40.99$\pm$0.61 | 49.46$\pm$0.74 | 50.75$\pm$0.57 |
| ReMDM | 7.46$\pm$0.16 | 8.24$\pm$1.10 | 16.83$\pm$0.40 | 34.77$\pm$0.61 | 43.85$\pm$0.24 | 50.77$\pm$0.24 | 51.33$\pm$0.81 |  |
| RCR | 4.93$\pm$0.32 | 9.29$\pm$0.70 | 20.81$\pm$0.27 | 35.03$\pm$0.54 | 41.09$\pm$0.64 | 46.17$\pm$0.32 | 50.34$\pm$0.96 |  |
| Tolerator | 17.49$\pm$0.43 | 22.24$\pm$0.90 | 32.58$\pm$1.20 | 51.88$\pm$1.14 | 63.66$\pm$0.23 | 67.20$\pm$0.64 | 68.89$\pm$1.05 |  |

In the main text, we present line and bar plots to highlight overall trends and comparisons on different tasks and forward step $T$. For completeness, here we report the exact numerical results of our main experiments in tabular form, which allow for more precise inspection and direct comparison across different methods and settings.

### A.2 Ablation Studies

Similarly, we present the exact numerical results our further analysis on EoT penalty in tables below.

**Table 4: Performance with different values of the EoT penalty coefficient $\lambda_{\text{eot}}$ (1.0–1.3) under fixed fill-up and refinement configurations. Evaluated on GPQA and GSM8K with Dream-Instruct and LLaDA. Reported as mean (± variance) over 3 seeds.**
| Forward Steps | Model | Task | $\lambda_{\text{eot}}=1.0$ | 1.1 | 1.2 | 1.3 |
| --- | --- | --- | --- | --- | --- | --- |
| 32 | Dream | GPQA | 19.27 ±0.90 | 23.74 ±0.52 | 25.67 ±1.18 | 24.33 ±2.95 |
| Dream | GSM8K | 41.80 ±1.23 | 51.68 ±0.57 | 51.88 ±1.14 | 49.56 ±1.25 |  |
| LLaDA | GPQA | 19.27 ±1.52 | 23.74 ±1.44 | 26.71 ±1.45 | 22.77 ±1.24 |  |
| LLaDA | GSM8K | 40.21 ±0.64 | 47.66 ±0.18 | 47.49 ±1.01 | 46.17 ±0.55 |  |
| 128 | Dream | GPQA | 26.79 ±0.00 | 25.15 ±0.72 | 26.41 ±2.03 | 26.34 ±0.80 |
| Dream | GSM8K | 54.61 ±0.56 | 67.93 ±0.53 | 67.20 ±0.64 | 67.63 ±0.13 |  |
| LLaDA | GPQA | 19.94 ±0.93 | 26.12 ±0.80 | 29.91 ±1.77 | 28.20 ±1.23 |  |
| LLaDA | GSM8K | 46.25 ±0.08 | 64.22 ±0.79 | 68.99 ±0.92 | 67.27 ±1.03 |  |

## Appendix B Use of LLMs Disclosure

We disclose the following uses of large language models in the preparation of this work. GPT-5 (OpenAI, 2025) was employed solely to assist with language polishing and improving the readability of the manuscript. In addition, Claude Code (Anthropic, 2025) was used as a coding assistant to generate and debug experimental scripts. At no point did LLMs contribute to the core research ideas, methodology, or interpretation of results. All scientific contributions, analyses, and conclusions remain the responsibility of the authors. Outputs produced by LLMs were carefully reviewed and revised where necessary to ensure accuracy and integrity.

## Appendix C Qualitative Examples

In this section, we present a qualitative case study showing how cross-validation refinement performs token-level error correction. Consider the GSM8K  (Cobbe et al., 2021) query: “Marilyn’s first record sold 10 times as many copies as Harald’s. If they sold 88,000 copies combined, how many copies did Harald sell?”

Figure [8](https://arxiv.org/html/2510.05090v1#A3.F8) shows LLaDA (Nie et al., 2025) with 16 fill-up forward steps without refinement. Different colors indicate the decoding order. Early steps are syntactically and semantically reasonable, but by step 16 (orange) the output degrades—failing to carry out precise arithmetic (e.g., producing “88,000000”) and losing grammatical consistency (e.g., “the number the number”).

Cross-validation refinement then iteratively edits inconsistent tokens and inserts more appropriate ones. Figures [8](https://arxiv.org/html/2510.05090v1#A3.F8), [8](https://arxiv.org/html/2510.05090v1#A3.F8) and [8](https://arxiv.org/html/2510.05090v1#A3.F8) show results after 1, 8, and 16 refinement steps, respectively. After one step, redundant tokens like “the number the number” are removed and spurious digits are trimmed (e.g., “88,000000” → “88,000”), though minor issues (e.g., fragments like “Har Harald”) may remain. As refinement proceeds, the text becomes well-formed and the arithmetic is corrected, ultimately converging to the correct answer: 88,000.

This example indicates that dLLMs already contain the knowledge needed to solve the problem since initial generations include relevant fragments such as “88” and “00/0000”, but benefit from a more stable mechanism for parallel language modeling. Cross-validation refinement provides this mechanism, enabling correction over iterations.

Figure: Figure 5: Output of Fill-Up Stage.We use colors fading from blue to red to demonstrate the order of decoding.Using fill-up and refinement steps =16, special tokens like [EoT] are not shown.
Refer to caption: x4.png

## Peer Reviews

confidence: 4
contribution: 1
initial_rating: 2
presentation: 2
questions: Please see the weakness section above.
soundness: 1
strengths: 1. The idea of remasking tokens is both timely and important for diffusion language models. While prior works have proposed alternative strategies to remask previously unmasked tokens, this paper provides compelling evidence that **repeated remasking of an initial draft**, generated via confidence-based unmasking samplers such as those used in LLaDA, can consistently improve performance.  

2. The improvements are demonstrated across **five benchmarks** spanning natural language understanding, code generation, and mathematical reasoning, highlighting the generality of the proposed method.  The proposed reweighting of the *end-of-text (EoT)* token during draft generation is a simple yet effective idea that yields promising gains in generation quality.
summary: This paper addresses a key limitation in current diffusion language models (DLLMs): once a token is generated, it is typically never revised, which can propagate early errors and limit overall quality. The authors propose a **two-stage test-time token-level cross-validation** approach to mitigate this issue.  

In the first stage, a standard dLLM sampler generates a complete initial draft sequence starting from all masks. In the second stage, a subset of tokens is randomly remasked and regenerated using the remaining context. This remasking-refinement process is repeated multiple times under a **cosine annealing schedule**, where the remasking rate decreases over time to stabilize predictions.  

Experiments demonstrate strong improvements, with relative gains of **17.9% on Dream** and **15.3% on LLaDA**, showing that the proposed method effectively enhances reasoning and consistency in diffusion language models without additional training.
weaknesses: 1.  The abstract claims that once a token is accepted, it is no longer changed in diffusion language models. While this is true for earlier methods such as MDLM, MD4, and LLaDA, more recent works like **ReMDM** (https://openreview.net/pdf?id=IJryQAOy0p, NeurIPS 2025) and **ADLM** (https://openreview.net/pdf?id=E8adS5srds, NeurIPS 2025) already support token remasking. Although the introduction briefly discusses ReMDM, the abstract should clarify the challenges that remain in existing remasking algorithms and what specifically differentiates this work from these relevant baselines.

2. The distinction between the proposed approach and ReMDM should be discussed in detail. ReMDM includes a baseline where remasking can be disabled early and re-enabled later in the reverse process. With appropriate hyperparameter choices, the proposed method seems to reduce to a special case of ReMDM. The paper should explicitly describe how its algorithm decouples fill-up and refinement, and how it meaningfully differs from ReMDM’s stochastic remasking strategy.

3. In the iterative refinement stage, remasked tokens are predicted as $y_i^{(k)} \sim p_\theta(\cdot | x^{(k)}, k)$. Since the pretrained model conditions on discrete time steps $t$, the refinement index $k$ should not differ arbitrarily from these training-time values. It is unclear whether the proposed cosine-annealed refinement rate can deviate from the pretrained denoising schedule. The authors should clarify this apparent mismatch.

4. The reported base performance of LLaDA (e.g., 30.46 vs. 70.3 in the original paper) differs significantly from the published results. The proposed method achieves 46.28, but it remains unclear whether improvements persist under identical settings (e.g. with **in-context examples**, which LLaDA shows can strongly improve accuracy). The evaluation setup should be made consistent for a fair comparison.

5. While increasing refinement steps generally improves results, GPQA results on LLaDA show little to no gain. The authors should analyze why performance plateaus in this case and whether this limitation arises from dataset characteristics, the base model, or the proposed remasking strategy itself.

6. The ablation on refinement-rate annealing shows minimal gains. In some cases (e.g., Dream dataset at forward steps 4, 64 and in the neighborhood), the model without refinement even outperforms the refined version. This raises doubts about the claimed importance of design choices, suggesting that their contribution might be overstated.

7. The claim that tokens unmasked at the same time step do not interact contradicts prior work. ADLM demonstrates that a two-stage process (first generating soft tokens, then remasking/unmasking) allows token interactions through soft samples, leading to improved remasking. ReMDM combined with ADLM outperforms ReMDM with MDLM (https://s-sahoo.com/mdlm/). The paper should discuss this distinction.

8. Lines 452-456:  The authors claim a limitation based on remasking at the end of the process but do not provide supporting empirical evidence. Concurrent works at ICLR 2026 show that final-stage remasking has negligible effect on LLaDA base models.
9. The conclusion suggests that this paper is the first to introduce remasking in diffusion language models. However, earlier works (ReMDM, ADLM) already explore token-level remasking. The conclusion should be revised to accurately position this paper’s contribution relative to prior remasking works.

---

confidence: 5
contribution: 2
initial_rating: 4
presentation: 3
questions: - In §3.3 the paper states that after the fill-up stage the sequence is fully unmasked:
   $$
   x^{(\rho T)}=\left(c_1,\dots,c_m,x^{(\rho T)}_{m+1},\dots,x^{(\rho T)}_L\right),\quad x_i^{(\rho T)}\neq[\text{MASK}]\ \forall i>m.
   $$
   But under the "vanilla" scheme in §3.1, each step accepts approximately $L/T$ tokens, so after only $\rho T < T$ steps there will still be masked tokens unless the acceptance schedule is altered. Either (i) $\rho=1$, (ii) the method accepts $>L/T$ tokens per step during fill-up (not described), or (iii) the claim that all masks are gone at step $\rho T$ is incorrect?
  

- With $\gamma_{\min}=0.4$, even the last refinement iteration remasks approximately $0.4(L-m)$ tokens, preventing fixed-point convergence by design (as also noted in §5.2). If "natural convergence" is a desideratum, why not anneal to $\gamma_{\min}\approx 0$ or a stopping rule $\mathbb{1}[x^{(k+1)}=x^{(k)}]$?

- §3.1/§3.3 allude to confidence/entropy, what are the thresholds?
soundness: 2
strengths: - The paper reframes diffusion-LM decoding into a two-stage pipeline: fill-up followed by token-level cross-validation refinement. Instead of irreversibly accepting tokens step by step, the method remasks a subset at rate $\gamma_k$ so tokens alternately play validator and target roles—making error correction explicit. It's a simple but clever idea: training-free and model-agnostic cross-validation of token interactions, plus an End-of-Text penalty and cosine annealing schedule. This tackles a core limitation of prior decoding strategies with minimal algorithmic overhead.

- The experiments are promising; results span two models (Dream-7B, LLaDA-8B) and five benchmarks (TriviaQA, GPQA, HumanEval, MBPP, GSM8K) with three seeds. Gains are consistent and substantial (average +17.9% on Dream, +15.3% on LLaDA), especially at high parallelism where within-step "invisibility" hurts most. The ablations isolate each component: more refinement helps, $\lambda_{\text{eot}}$ improves drafts, and annealing stabilizes convergence. The analysis connects wins to the parallel architecture rather than hyperparameter tuning.

- The problem is crisply formalized, the method notation is precise (remasking sets $S^{(k)}$, annealed $\gamma_k$, EoT scaling), and compute accounting is transparent. Figures and tables cleanly separate throughput vs. accuracy; ablations tell a clear causal story; hyperparameters and their effects are documented for reproducibility. The narrative makes the intuition behind cross-validation at high parallelism obvious.

- The method is drop-in, training-free, and model-agnostic, so practitioners can immediately use it with existing diffusion LMs. The broad, budget-matched improvements and the token-level cross-validation framework elevate decoding from an implementation detail to a first-class algorithmic lever for diffusion LMs. This will likely influence both practitioners (who want quality without retraining) and researchers (exploring richer refinement schemes), and it strengthens the case for diffusion LMs as viable, fast alternatives to autoregressive decoding.
summary: This paper targets a core limitation of discrete diffusion LLM decoding, irreversible early token acceptances that propagate errors, and proposes TOLERATOR, a training-free, model-agnostic decoding strategy that explicitly decouples generation into (i) sequence fill-up and (ii) cross-validation refinement. In Stage I, the model performs standard parallel fill-up but regularizes premature termination via an End-of-Text penalty; in Stage II, it iteratively remasks a random subset $S^{(k)}$ of positions at rate $\gamma_k$ and redecodes them conditioned on the fixed remainder, so tokens alternately serve as validator and validation target (“token-level cross-validation”). The refinement rate follows a cosine schedule, while total forward steps $T$ are split by ratio $\rho$ between fill-up and refinement under a matched compute budget to baselines. Across Dream-v0-Instruct-7B and LLaDA-8B-Instruct on TriviaQA, GPQA, HumanEval, MBPP, and GSM8K, TOLERATOR delivers consistent gains over vanilla, ReMDM, and RCR—on average +17.9% (Dream) and +15.3% (LLaDA)—robust to parallelism levels, with strong improvements at larger parallel sizes where within-step “invisibility” creates local inconsistencies. Ablations isolate each component’s effect (more refinement steps help; $\lambda_{\text{eot}}$ improves drafts; annealed $\gamma_k$ stabilizes convergence). Limitations are candidly discussed (smaller gains on format-sensitive code; lack of natural convergence). Contributions: a clear reframing of dLLM decoding as fill-up + token-level cross-validation; a simple EoT penalty and annealed remasking schedule; and broad empirical evidence that decoding algorithms, not only model training, materially improve dLLM quality-efficiency trade-offs.
weaknesses: - EoT penalty
   §3.3 states the method "scale[s] down the logit of the EoT token by a factor $\lambda_{\text{eot}}>1$ before softmax," but the formula applies a probability rescale: $\tilde{p}(v)\propto \exp(z_v)/\lambda_{\text{eot}}$ for $v=[\text{EOT}]$. Dividing the post-exp term is equivalent to subtracting $\log\lambda_{\text{eot}}$ from the logit (an additive shift), not scaling the logit by $1/\lambda$.


- The paper equalizes "number of forward steps" ($T$), but per-step work differs across methods, so reporting FLOPs/token and throughput for each setting, and clarifying how per-step token counts compare across methods, may make more sense.


- “Consistent improvements” claim is not supported by Table 1  
    There are multiple regimes where TOLERATOR underperforms a baseline:

    - Dream/GPQA, #F=4: Vanilla 10.27 vs. TOLERATOR 8.11.
    - Dream/HumanEval, #F=256: Vanilla 50.61 vs. TOLERATOR 47.56.
    - Dream/MBPP, #F=256: Vanilla 56.93 vs. TOLERATOR 51.53.
    - LLaDA/TriviaQA, #F=16–256: RCR dominates (e.g., #F=256: RCR 29.30 vs. TOLERATOR 19.72).
    - LLaDA/HumanEval, #F=256: Vanilla 27.13 vs. TOLERATOR 22.46.

    These contradict statements like “our method consistently improves under different parallel decoding configurations” (§4.2) and “consistent improvements over the baselines under the same computational budget” (Abstract).  

-  §4.3 says refinement steps show an “increasing trend,” but Table 2 shows several non-monotonicities (e.g., Dream/GPQA 16 fill-up: 29.30 at #R=32 then 26.95 at #R=64; LLaDA/GPQA 64 fill-up: 26.95 at #R=64 then 22.66 at #R=128).  


-  Annealing helps "in most cases," but also hurts noticeably.
    Table 4 shows Dream/GSM8K at #F=64: 62.76 (with) vs. 64.84 (without); LLaDA/GSM8K #F=128: 70.18 vs 65.23 (helps).

-  §4.2 mentions very large TriviaQA and GSM8K improvements; however, on LLaDA/TriviaQA the strongest baseline (RCR) dominates at higher #F.

-    §3.1/§3.3 allude to confidence/entropy but give no formula or thresholds.  

- Notation wise, in §3.4 the paper presents:
   $$
   x_i^{(k)}=
     \begin{cases}
       [\text{MASK}], & i\in S^{(k)} \\
       x_i^{(k)}, & \text{otherwise}
     \end{cases}
   $$
   which defines $x^{(k)}$ in terms of itself. This should be a masked copy (e.g., $\tilde{x}^{(k)}$) formed from the previous iterate: $\tilde{x}^{(k)} = \text{Mask}(x^{(k)}; S^{(k)})$, followed by decoding to get $x^{(k+1)}$. Likewise, the next line conditions on the wrong object:
   $$
   y_i^{(k)}\sim p_\theta(\cdot\,|\,\tilde{x}^{(k)},\,\text{time})
   $$

---

confidence: 4
contribution: 2
initial_rating: 4
presentation: 3
questions: 1. Are there heuristics to detect convergence (e.g., minimal token change ratio), or could reinforcement learning be applied to decide refinement length?

2. Can cross-validation refinement be expressed as an approximate consistency regularization or ensemble expectation over token subsets? 

3. Could TOLERATOR’s annealed refinement be integrated on top of related methods, such as dLLM cache, WINO etc.?
soundness: 3
strengths: 1. The motivation of the paper is clear and it proposes a conceptually elegant and general solution. 

2. The authors have done comprehensive evaluation across five benchmarks and two leading dLLMs (Dream and LLaDA).  Consistent improvements across tasks and varying degrees of parallel decoding (T=4–256) are demonstrating robustness of the proposed method. 

3. The authors evaluate contributions of refinement steps, end-of-text (EoT) penalty, and annealing schedule, which shows that each design choice contributes to performance gains. 

4. The paper also provides a conceptual explanation for why cross-validation helps especially with large parallel sizes, to help the readers understand what's the insights when tokens in the same step can’t see each other. 

5. The writing and structure of the paper is overall clear, plus anonymous code link provided, with reproducibility details.
summary: This paper introduces TOLERATOR (Token-Level Cross-Validation Refinement), a training-free decoding strategy for diffusion large language models (dLLMs). Compared to conventional dLLM, decoding fixes tokens once they’re accepted, which causes early mistakes to persist,  TOLERATOR uses a two-stage decoding process:

	1.	Fill-up stage: generate a coarse draft with high parallelism (vanilla diffusion decoding).

	2.	Refinement stage: iteratively remask and regenerate subsets of tokens, where some tokens act as “context” and others as “validation targets,” allowing mutual correction through cross-validation.

Experiments on five benchmarks—TriviaQA, GPQA, GSM8K, MBPP, and HumanEval—show consistent performance improvements (e.g., +17.9% for Dream and +15.3% for LLaDA) under the same computational budget.
weaknesses: 1. The paper lacks a formal justification for why cross-validation improves the likelihood or convergence properties of the diffusion process. Moreover, there is no analytical comparison with prior probabilistic remasking approaches (e.g., ReMDM (Wang et al., 2025)). 

2. Evaluation mainly focuses on standard text and code tasks; lacks analysis on more complex scenarios such long-context generation (e.g., BigCodeBench), where diffusion LMs may differ most from AR models.

3. While authors claim equal “forward-step” cost, the two-stage process may incur subtle computational overhead (e.g., due to multiple refinement passes). Clarity on real wall-clock time or GPU-hour parity would strengthen fairness.

4. As acknowledged by the authors, refinement can fail to converge naturally, which raises questions about how to determine optimal refinement steps or stopping criteria.

5. Missing prior works discussions. WINO (arXiv:2507.18578) already demonstrated training-free iterative token verification and revocation for dLLMs, enabling backward revision of previously accepted tokens. TOLERATOR’s idea of “remasking accepted tokens during decoding” is conceptually aligned, differing only in timing (post-hoc refinement vs. in-process correction).  The authors need to clarify the differences in the paper and compare if necessary.

---

confidence: 4
contribution: 2
initial_rating: 4
presentation: 2
questions: See Weaknesses.
soundness: 2
strengths: 1. The paper accurately identifies the core flaw in current dLLM decoding strategies: the irreversibility of errors. As dLLMs gain attention as alternatives to autoregressive (AR) models, addressing the trade-off between decoding efficiency and quality is highly valuable.
2. Code is provided to facilitate reproducibility.
summary: This paper tackles a key limitation in dLLM decoding, where committed tokens cannot be revised, causing early errors to persist. To address this, the authors propose TOLERATOR (Token-Level Cross-Validation Refinement), a training-free strategy that first generates a complete draft using standard dLLM decoding (Sequence Fill-Up) and then iteratively refines it (Cross-Validation Refinement) by remasking subsets of tokens and re-predicting them using the remaining tokens as context.
weaknesses: 1. The main issue with the paper lies in its practical performance: recent methods that reduce sampling steps (e.g., arXiv:2505.22618, arXiv:2506.10848, arXiv:2507.18578) can accelerate inference while maintaining quality, yet the proposed approach often underperforms vanilla decoding in many scenarios, even with the same computational budget (Table 1).
2. Some baselines appear unusually low. For example, LLaDA on GSM8K achieves only around 50%, which seems implausibly low.
3. Experiments show that the EoT penalty provides substantial improvements, but it is not a core component of the proposed method, which further diminishes the practical impact of the main approach.