Diffusion language models (DLMs) are sold on one promise: a wider decoding window means more tokens written per forward pass, so decoding should get faster. In practice, wide windows often wreck accuracy. As reported in the paper, the CD4LM evaluation pipeline shows LLaDA-8B falling from 77.7% on GSM8K with 32-token blocks to 13.2% with a single 256-token block. A paper posted to arXiv on November 16 (https://arxiv.org/abs/2611.20693, by three researchers from MBZUAI and UIUC) traces every single token commit of four open-weight DLMs, and its verdict is counterintuitive: the collapse is caused mainly by commit order, not by parallelism.
How threshold decoding works
LLaDA, Nemotron-Labs-Diffusion (NLD), and Fast-dLLM v2 all use confidence-based threshold decoding: at each step, every masked position in the window whose confidence passes 0.9 is committed at once; if none qualifies, a fallback commits the single most confident position. Commits are never revised, and they may happen in any order — a position can be filled while positions to its left are still blank. The paper calls the leftmost masked position the frontier, and a commit made while the left side is still masked an ahead commit. Wide windows give ahead commits room to roam, which is where the trouble starts.
Confidence huddles near the frontier
The first finding: rushing ahead is pointless. Across the four models, 15-24% of positions only pass the threshold once they themselves become the frontier, 60-64% pass it within seven positions of the frontier, and beyond distance 16 the share of positions passing for the first time drops below 1.5%. There simply are not many tokens worth committing early. In measurements, a frontier-only policy keeps at least 0.92 times the tokens-per-forward of vanilla across all 34 settings — roughly half of vanilla commits on NLD and about three quarters on LLaDA are ahead commits that add almost nothing. Wide windows are also expensive: at batch size 32, B=128 runs 2.4-2.5 times slower than B=32.
Order, not parallelism, loses the points
Separating where to commit from how many per step, the result is lopsided. On GSM8K, policies that commit only at the frontier beat confidence-order policies by 3 to 46 points, while committing one token per step versus several moves accuracy by at most 2 points. The widest gap: LLaDA with prompt B scores 35.5% under vanilla versus 82.2% for frontier policies, a 46.4-point difference; NLD-3B with a 256-token window sits at 54.5% versus 88.0%, a 33.3-point gap. The loss comes almost entirely from fixing words on the right before the text on the left exists.
Two failure modes, mixed differently per model
Ahead commits fail in two ways. One is early end-of-sequence: the fallback commits an EOS token from deep inside the window and the answer is cut short. This is nearly all of the damage on NLD — restricting EOS to the frontier shrinks the order effect from +8.4 points to +1.1, and from +33.3 to +0.5 at B=256. The other is early content tokens: on Fast-dLLM v2 nearly all of the loss remains (+5.3 points before and after the EOS restriction). LLaDA has both (+21.5 shrinks only to +17.8; +46.4 to +24.8). The practical lesson: a fix tuned on one model can simply fail on another.
The hardest evidence: replays
The paper nails causation with root analysis plus single-step replays. The first commit where a failing decode departs from the reference is the root: fallback commits are only 11-35% of all commits, yet they start 61-72% of the harmful departures. A per-commit Poisson regression shows that on the three block-diffusion models, an ahead commit still starts departures several times as often as a frontier commit at the same confidence (rate ratio 7.8-14.6), while a fallback commit starts harmful roots at 10.3 to 31.5 times the rate of a confident commit. In replays, repairing only the root step — switching it to frontier-only committing — fixes 7 to 39 points more failing answers than changing a matched earlier step.
The fix is embarrassingly cheap
The prescription changes no weights and requires no retraining: commit only at the frontier, or at least keep the fallback and EOS there. In the CD4LM pipeline, LLaDA climbs from 13.2% to 64.5% with the EOS restriction, and to 79.3% committing the frontier at every step, with the same number of forward passes. A distance cap of k at most 2 keeps frontier-only accuracy, and no cap value increases speed by more than 18% — there is almost nothing to gain from committing ahead. The code is released at https://github.com/rmakarovv/fast-at-the-frontier
Caveats worth stating
Four boundaries: the models are at most 8B parameters; the study covers threshold decoding that never revises a commit (a side experiment on DiffusionGemma, where revision is allowed, finds ahead commits are indeed revised more often, but the main line does not cover it); the tasks — math, code, translation (WMT16), summarization (CNN/DailyMail) — are ones where left-to-right order is natural; and the big accuracy effects appear when the window is wider than the training block, though Fast-dLLM v2 already loses 4 points going from its default 8-token sub-block to its 32-token training block.
So what? The real bottleneck of parallel decoding was never window width but the spatial spread of the model's confidence — training should make the model confident further ahead of the frontier, and inference should keep commits at the frontier. A wide window does not buy speed; it buys the chance to speak before you have thought.