📌 Highlights
The central contribution is a single LLM architecture with an unchanged autoregressive verifier and adapter-based diffusion drafter. Because candidates are rejection-corrected against the frozen AR pathway, acceleration is designed to preserve the target distribution rather than trade quality for speed.
The strongest systems evidence is the open-weight comparison: UnoQwen leads EAGLE-3 and DFlash in the reported system-throughput and per-request-throughput configurations while also using fewer added parameters and less peak memory. The principal caveat is that these measurements depend on the paper’s H200 and Nano-vLLM setup, while the from-scratch model’s training data are proprietary.
- Lossless block drafting without a separate draft model.
- Linear and tree samplers target high-concurrency and low-concurrency regimes, respectively.
- The method can augment an existing Qwen3-8B checkpoint without access to its original training distribution.
- The paper reports retained rollout acceleration after AR-only RL updates, but detailed RL results are deferred.
🎯 Introduction
Next-token prediction gives LLMs a strong likelihood objective and efficient KV caching, but it forces one-token-at-a-time generation. The paper argues that this is poorly matched to predictable linguistic blocks and modern accelerators: long reasoning traces increase latency and RL rollout cost, while weight and KV-state movement can leave parallel compute underused.
Speculative decoding can preserve a target distribution but requires a well-aligned separate drafter, whereas diffusion LLMs generate in parallel but commonly expose a quality-speed tradeoff and lose their advantage at large batch sizes. The paper’s objective is therefore to retain a high-quality AR distribution, learn an internal diffusion pathway that proposes several tokens at once, and verify those proposals losslessly across realistic serving concurrency.
🔬 Methodology
A diffusion-augmented layer contains AR weights θAR and diffusion weights θΔ. The AR pathway is trained through the usual pretraining, supervised fine-tuning, and RL pipeline and determines response quality. The diffusion pathway adds LoRA adapters to the AR matrices and is trained only to draft blocks; verification runs with θAR alone. This parameter coupling avoids a second full model and permits a shared KV cache.
Diffusion Distillation maps a fully corrupted sequence directly to clean blocks. A training example concatenates clean x and corrupted z1, and a block-causal mask lets each noisy block attend to preceding clean blocks. Gated LoRA disables adapters at clean positions and enables them at noisy positions, producing frozen teacher and trainable student logits in one forward pass. The loss combines blockwise DCD with total variation, whose role is to increase the longest consecutively accepted prefix.
Ψ-Spec appends prior samples to the current prefix and uses one diffusion pass to form a block proposal. The first token is drawn through the base pathway, while later positions use the adapted pathway. A linear sampler emits one candidate sequence for compute-bound, high-batch operation; a tree sampler selects top-K branches and retains a bounded set of high-probability prefixes when low-batch execution leaves compute available. Standard speculative rejection correction then preserves the AR target distribution.
Figure 1
Caption: Figure 1: (Top) Training overview for diffusion-augmented LLMs. Gray cells indicate AR-weight training, while the blue cell indicates diffusion-weight training. (Bottom Left) System throughput of Uno, the base AR model, and the baselines; see Sec. 5.1 for details. (Bottom Right) Performance across agentic and long-context reasoning benchmarks.
Why It Matters: It shows where the drop-in diffusion phase sits relative to conventional NTP and RL training and links that design to the reported speed and quality outcomes.
AR factorization
Meaning: Defines the unchanged target distribution whose sequential next-token decisions Ψ-Spec must reproduce exactly.
Equation 1
Meaning: Defines the interpolating discrete-diffusion corruption process, with αt controlling movement from clean tokens to the prior.
Equation 2
Meaning: Specifies the Ψ transition kernel; κt sets the strength of the correction relative to the clean prediction and prior mixture.
Equation 3
Meaning: Combines teacher-distribution matching and acceptance-oriented total-variation matching; α and β determine their relative training weight.
📊 Experiments
The end-to-end evaluation covers the reported τ³ Banking and τ² Telecom/Retail tasks, Terminal-Bench v2.1, SWE-bench Verified, AA-LCR, AA-Omniscience, Humanity’s Last Exam, GPQA-Diamond, GSM8K, MATH500, AIME-24, AIME-25, AIME-26, MBPP, and HumanEval. The open-weight Qwen3-8B evaluation additionally covers LiveCodeBench v6, GPQA, MMLU-Pro, and IFEval. Baselines include Mercury 2, DiffusionGemma, Nemotron-Labs-Diffusion, EAGLE-3, DFlash, and the lossy methods SDAR, TiDAR, OPDLM, I-DLM, Jacobi Forcing, Fast-dLLM v2, FLARE, and LLaDA2.1-Flash.
Quality is evaluated with average pass@1 or the benchmark-specific accuracy, where higher is better. Acceptance is reported as τ or tokens per forward pass, also higher being better, but the authors caution that this ignores drafter size. The fixed 1K/8K systems test uses 1,024 random input tokens, an effective output length of 8,192 tokens, and enough decoding steps to match each method’s measured average acceptance. Per-request throughput is measured at batch size one; system throughput is measured at the largest batch fitting on one H200 GPU.
Table 1 reports that the 8B Uno model exceeds both evaluated open diffusion LLMs on every listed accuracy benchmark. It also exceeds Mercury 2 on the listed agentic tool-use, agentic coding, and long-context tasks, while Mercury 2 leads on AA-Omniscience and matches the displayed GPQA-Diamond score to the shown precision. Table 2 shows UnoQwen leading EAGLE-3 and DFlash in the selected system-throughput and per-request-throughput configurations, with lower reported peak memory and fewer added parameters. Figure 2 shows the claimed Pareto dominance across concurrency levels.
The main-body loss ablation reports TPF 2.39 for TV-only training versus 2.23 for DCD+TV and 2.23 for DCD alone; reducing the DCD coefficient to 0.01 raises TPF marginally to 2.40. The curriculum discussion reports TPF increasing from 2.65 to 2.71 when block size grows from 4 to 16 rather than remaining fixed at 16. Increasing LoRA rank from 128 to 256 improves TPF but also increases inference cost, and an αLoRA/rLoRA ratio of 64 performs best among the tested ratios. During AR-only RL of four specialists, frozen diffusion adapters retain their speedup with a reported nominal 6% TPF decrease; the authors report up to 40% end-to-end training acceleration, with smaller gains when tool calls dominate.
Figure 2
Caption: Figure 2: System versus per-request throughput across batch sizes (concurrency C). Uno Pareto-dominates speculative decoding and achieves up to 2.5× speedup over the base AR model. Parentheses indicate the sampler configuration yielding the highest throughput for Uno. Exact throughputs are in Table 18.
Why It Matters: It visualizes the central systems result across concurrency rather than presenting only a favorable batch-size-one measurement.
Table 1
Caption: Accuracy and TPF of Uno, Nemotron-Labs-Diffusion, Mercury 2, and DiffusionGemma on agentic and non-agentic benchmarks. Mercury 2 results are from Artificial Analysis. Results for Nemotron-Labs-Diffusion and DiffusionGemma are computed from their open-source checkpoints. For Uno, subscripts report “TPF1 / TPF2,” where TPF1 uses the system-throughput-optimal Linear sampler with B=4, and TPF2 uses (B,K,V)=(16,32,32), optimized for per-request throughput. ∗Reported by Artificial Analysis’s live tracker on August 30, 2026.
| Benchmark / metric | Uno (8B) | Mercury 2 | Diffusion-Gemma (26B-A4B) | Nemotron-Labs-Diffusion (14B) |
|---|---|---|---|---|
| τ³ Banking | $25.8_{1.8/2.7}$ | $9_{N/A}$ | -- | -- |
| τ² Telecom | $90.1_{1.7/2.1}$ | $71_{N/A}$ | $68.1_{18.8}$ | $14.3_{4.8}$ |
| τ² Retail | $67.1_{1.8/2.4}$ | -- | $65.5_{23.7}$ | $5.6_{3.1}$ |
| Terminal-Bench v2.1 | $39.6_{2.1/2.7}$ | $27_{N/A}$ | $14.7_{14.1}$ | $4.5_{7.5}$ |
| SWE-bench Verified | $68.4_{2.2/3.1}$ | -- | $18.7_{5.6}$ | $0.8_{1.5}$ |
| AA-LCR | $68.0_{_{1.8/2.6}}$ | $36_{N/A}$ | $19.7_{10.8}$ | $7.3_{1.1}$ |
| Humanity's Last Exam | $18.6_{1.8/2.8}$ | $16_{N/A}$ | $9.2_{14.1}$ | $2.6_{7.2}$ |
| GPQA-Diamond | $77.1_{2.0/4.2}$ | $77_{N/A}$ | $70.7_{11.9}$ | $40.4_{7.6}$ |
| AA-Omniscience | $14.3_{1.7/3.1}$ | $20_{N/A}$ | ||
| GSM8K | $95.4_{1.9/2.7}$ | -- | $95.1_{28.9}$ | $93.1_{6.1}$ |
| MATH500 | $98.9_{1.9/2.4}$ | -- | $92.4_{24.1}$ | $89.2_{5.6}$ |
| AIME-24 | $93.0_{1.9/2.5}$ | -- | ||
| AIME-25 | $90.7_{1.8/2.4}$ | -- | $74.3_{18.9}$ | $40.0_{4.5}$ |
| AIME-26 | $86.3_{_{1.8/2.4}}$ | -- | $70.7_{17.8}$ | $46.7_{4.8}$ |
| MBPP | $84.1_{_{1.8/2.4}}$ | -- | $80.1_{15.5}$ | $73.8_{5.3}$ |
| HumanEval | $95.2_{1.9/3.4}$ | -- | $95.1_{28.2}$ | $84.8_{7.5}$ |
| Avg. T | 1.9 / 2.7 | N/A | 17.56 | 5.41 |
| System Throughput | 5255 | $1197^*$ | 1136 | 2794 |
| Per-request Throughput | 405 | $769^*$ | 836 | 290 |
Why It Matters: The table jointly exposes quality and decoding behavior. Uno has much smaller raw TPF than the standalone diffusion models but reports higher system throughput, illustrating why tokens per forward pass cannot substitute for end-to-end throughput.
Table 2
Caption: Acceptance lengths (τ), throughput (1K/8K test), peak memory usage, and additional parameter counts for UnoQwen, EAGLE-3, and DFlash at sampling temp=1. We report the τ values that maximize system and per-request throughput.
| Benchmark / metric | UnoQwen B=4 | EAGLE-3 B=4 | DFlash B=4 | UnoQwen B=16, V=32 | EAGLE-3 B=8, V=60 | DFlash B=16 | |
|---|---|---|---|---|---|---|---|
| GSM8K | 3.99 | 2.26 | 2.47 | 6.29 | 3.83 | 3.38 | |
| MATH500 | 4.11 | 2.14 | 2.28 | 6.89 | 3.52 | 3.24 | |
| AIME-24 | 4.08 | 2.11 | 1.96 | 6.83 | 3.41 | 2.76 | |
| AIME-25 | 4.11 | 2.13 | 1.90 | 6.81 | 3.46 | 2.56 | |
| AIME-26 | 4.08 | 2.13 | 1.93 | 6.71 | 3.49 | 2.57 | |
| HumanEval | 3.83 | 2.12 | 2.35 | 5.63 | 3.71 | 3.03 | |
| MBPP | 3.87 | 2.16 | 2.22 | 5.87 | 3.65 | 3.04 | |
| LCBv6 | 3.77 | 2.04 | 1.76 | 5.34 | 3.45 | 2.22 | |
| GPQA | 3.79 | 1.99 | 1.98 | 5.49 | 3.25 | 2.57 | |
| GPQA-Diamond | 3.78 | 1.98 | 1.92 | 5.49 | 3.19 | 2.50 | |
| MMLU-Pro | 3.84 | 2.03 | 2.11 | 5.70 | 3.31 | ||
| IFEval | 3.48 | 1.91 | 1.92 | 4.58 | 3.49 | 2.26 | |
| τ | 3.89 | 2.08 | 2.07 | 5.97 | 3.48 | 2.74 | |
| Throughput (Toks / sec; ↑) | 5733 | 4944 | 5351 | 445 | 284 | 370 | |
| Peak Memory (GiB; ↓) | 122.2 | 130.0 | 130.1 | 118.0 | 129.4 | 129.8 | |
| Additional Params (B; ↓) | 0.35 | 0.40 | 1.05 | 0.35 | 0.40 | 1.05 |
Why It Matters: Under the configurations selected for each operating regime, UnoQwen leads both system and per-request throughput while using fewer additional parameters and less peak memory than the two separate-drafter baselines.
🔮 Conclusion
The paper demonstrates that parallel discrete-diffusion drafting and exact AR verification can coexist inside one model. Uno preserves the base AR distribution, eliminates a separate drafter, and reports speedups across evaluated batch sizes rather than only in a low-concurrency regime.
For practitioners, the most credible takeaway is architectural: decouple the weights responsible for quality from those optimized for acceptance and throughput. The empirical case is strongest for the matched Qwen3-8B comparison against EAGLE-3 and DFlash; broader quality comparisons should be interpreted alongside differences in model size, training data, hardware, and precision.
🛠️ Future Research Improvements
The paper explicitly leaves systematic evaluation of Ψ-Spec inference-time scaling to future work. The key question is whether additional denoising at fixed context length can exceed AR quality sufficiently to justify disabling verification, and how that quality-compute frontier changes across tasks.
Other grounded extensions include combining Uno with multi-token-prediction heads to increase draft acceptance, developing efficient quadratic-sampling kernels that merge drafting and verification, and measuring adapter drift throughout RL rather than only before and after specialist training.
- Evaluate more denoising steps across reasoning, coding, agentic, and long-context tasks.
- Test MTP-style future-token heads as a complementary acceptance-rate improvement.
- Implement and benchmark quadratic sampling with production-quality kernels.
- Publish detailed RL timing, acceptance, and quality measurements throughout training.
🏭 Potential Industry Use Scenarios
The clearest deployment scenarios are high-concurrency LLM serving and agentic systems that create parallel tool calls, branches, retries, or subagents. Uno’s small-block linear sampler is specifically positioned for aggregate throughput when devices are near their maximum feasible batch size, while the tree sampler targets interactive, low-concurrency requests.
A second use is RL post-training, where faster generation can reduce rollout time without changing PPO- or GRPO-style policy optimization. Long-context generation is also relevant because amortizing model-weight and KV-state movement becomes more valuable as context grows, although production gains must be remeasured on the target hardware and serving stack.
- High-concurrency inference services.
- Agentic coding, tool-use, and workflow systems.
- RL rollout generation for reasoning or coding specialists.
- Long-context generation constrained by memory bandwidth.
💬 Critical Analysis
The paper’s strongest conceptual choice is keeping the verifier distribution unchanged. This creates a clearer quality contract than lossy AR-to-diffusion conversion and isolates optimization failures to acceptance and speed rather than response correctness. The use of fixed input/output lengths and explicit reporting of system versus per-request throughput also makes the systems argument more meaningful than variable-trace benchmark timing.
The central empirical weakness is comparability. The from-scratch Uno model benefits from proprietary large-scale training, while Mercury 2 has undisclosed size and precision and runs on different hardware. Even among open lossless methods, throughput depends on sampler grid searches, kernels, memory layout, and cache behavior. Consequently, the matched UnoQwen, EAGLE-3, and DFlash measurements are more diagnostic than cross-model headline comparisons.
Reproducibility is mixed: code, checkpoints, and Nano-vLLM/SGLang support are released or stated, and the Qwen-based adapters use an open dataset, but the end-to-end model’s data are unavailable. The paper also provides only preliminary RL evidence and no completed evaluation of its proposed inference-time scaling mode. These gaps do not undermine the lossless drafting mechanism, but they leave its generality across architectures, accelerators, quantization regimes, and production workloads open.