Uno diffusion drafting · Nanbeige4.2-3B looped · Oct 2026

LoopUno: Turning Agentic Looped LLMs into Diffusion LLMs in One Hour

Longxuan Yu¹, Siheng Xiong²¹University of California, Riverside · ²Georgia Institute of TechnologyAdapters on Hugging Face · GitHub

We train a single LoRA for 52 minutes, and Nanbeige4.2 starts writing two tokens per step. Function calls come out 1.98× faster and math reasoning 1.47× faster, with zero loss in quality, because the original model verifies every token.

2.04TPF

Tokens per step at 52 min

60 steps, 31M tokens, lr 1e-4. AR is 1.00.

1.47×

End-to-end decode speed

2274 vs 1545 tok/s on gsm8k, 8×A100.

1.62TPF

After 8M tokens (14 min)

Step 16. Already 1.13× faster end to end.

96.0%

Accuracy, unchanged

Lossless verify: AR 96.0%, Uno 93–96% across checkpoints (200-sample noise ±1.7%).

How it works

The model drafts with noise and verifies with itself

Uno [1] keeps the base model frozen and adds one LoRA that is switched on only for noise positions. Each decode step drafts a block of 8 positions in one forward, then the unmodified model verifies them and keeps the longest correct prefix. The first position is always the exact AR token, so a step never moves backward.

Training is self-distillation

Each sequence appears twice in one batch: a clean copy (frozen model, the teacher) and a block-noised copy (model + LoRA, the student). The loss is the total-variation distance between the two next-token distributions on the response tokens. Acceptance probability under lossless verification is exactly 1 − TV, so the loss trains the quantity decoding cares about. Dataset labels are never used; the data only supplies realistic contexts.

Why the looped model fits

Nanbeige4.2-3B [2] runs its 22 layers twice per token. At decode time it reads weights like a ~6.3B model, so it costs as much per step as Qwen3-8B (28.8 ms each). Drafting more tokens per step is where a looped model gains the most, and the LoRA trains through both loops with no change to the recipe beyond ZeRO-0 for the shared weights.

Scaling with training

Tokens per step vs. training time

gsm8k (first 200 problems), block 8, temperature 1.0. One step = 0.52M tokens ≈ 52 s on 8×A100. Hover a point for details.

lr 1e-4lr 1e-5 (official lr)references

With lr 1e-4 most of the gain arrives in the first hour: TPF 2.04 at 52 min, then 2.18 after 3.5 h. lr 1e-5 needs ~4 h to reach the same point. Both curves flatten near 2.1–2.2, which is a per-position acceptance of about 0.54 (Qwen3-8B Uno reaches 0.64 after 14.7B tokens).

Speedup

Measured end-to-end speedup vs. training time

lr 1e-4 run. Measured: output tok/s ÷ AR tok/s on the same 200 problems. Per-step: TPF ÷ 1.29, the measured cost of one Uno step relative to one AR step.

measured end to endper-step estimateAR = 1×

Uno pays for itself once TPF passes ~1.3. From one hour on, decoding is 1.4–1.5× faster end to end. The gap to the per-step estimate (~1.6–1.7×) comes from the long tail of each batch, when a few long sequences keep the GPUs underfilled; single 200-problem timings vary by about ±10%.

Agentic tasks

Function calling decodes 2× faster after one hour

The same adapters, trained only on math and reasoning data, transfer to agentic outputs. Tool calls are highly structured, so the drafter guesses them more often than free-form reasoning.

1.98×

BFCL, one hour of training

3273 vs 1653 tok/s, TPF 2.34. 2.10× after 3.5 h.

1.58×

SWE-agent trajectory replay

848 vs 538 tok/s, TPF 2.06. 1.62× after 3.5 h.

87.5%

BFCL accuracy, unchanged

AR 87.2% under greedy decoding.

Task	Decoder	Trained	TPF	tok/s	vs AR	Accuracy
BFCL v3 function calling · simple, multiple, parallel, parallel-multiple · 1000 prompts · greedy
BFCL	AR	–	1.00	1653	1.00×	87.2%
BFCL	Uno step 60	52 min	2.34	3273	1.98×	87.5%
BFCL	Uno step 240	3.5 h	2.58	3464	2.10×	87.5%
SWE-agent trajectory replay · next action from 300 cut trajectories · median prompt 6.4k tokens · T=1.0
SWE replay	AR	–	1.00	538	1.00×	–
SWE replay	Uno step 60	52 min	2.06	848	1.58×	–
SWE replay	Uno step 240	3.5 h	2.34	871	1.62×	–

BFCL accuracy uses a simplified AST checker (function name, allowed argument values, one-to-one matching for parallel calls), applied identically to AR and Uno; absolute scores may differ from the official leaderboard. SWE replay takes the nebius/SWE-agent-trajectories dataset, cuts each trajectory at a random assistant turn and generates the next action without executing it, so it measures speed only. 7×A100, adapters from the lr 1e-4 run.

Step cost

One Uno step costs 1.29 AR steps

1 GPU, 4 sequences, T=1.0	AR step	Uno step	Cost	TPF
Qwen3-8B, block 16	28.9 ms	35.8 ms	1.24×	2.66
Nanbeige4.2-3B looped, block 8	28.8 ms	37.1 ms	1.29×	1.79

Nanbeige, greedy	Eager	CUDA graph	Graph hits
AR, block 1	97.1 ms	27.1 ms	100%
Uno, block 8	161.3 ms	31.2 ms	100%

Decoding at small batch is bound by weight reads, so drafting 8 rows costs little more than 1. CUDA graphs are on in every evaluation; without them the draft rows would cost 1.66× instead of 1.15× (greedy).

All runs

Experiment data

gsm8k first 200 problems, 1 sample each, temperature 1.0, top-p 0.95, max 8192 output tokens, 8×A100-40GB with data parallel 8. Training time is wall clock on one 8×A100 node, including the warm-started continuation runs.

Setup

Recipe

Base model: Nanbeige4.2-3B, 22 layers × 2 loops, frozen
Adapter: Gated LoRA r=128, α=2048, all 7 projections, noise rows only
Objective: TV distance to the frozen model's own distribution (self-distillation)
Data: 60k OpenThoughts3 prompts with responses, 4096-token cutoff
Batch: 128 × 4096 = 0.52M tokens per step, block size 8
Optimizer: lr 1e-4 constant after 3 warmup steps, ZeRO-0 (loops share weights)
Hardware: 8 × A100 40G
Inference: nano-vllm Uno decoder, linear draft/verify, FA2, CUDA graphs

Limits and next steps

What this does not show yet

Benchmark scope. Agentic results replay recorded trajectories and score single function-calling turns; a full closed-loop agent run (environment execution, multi-turn tool feedback) is still to do.
Sample size. 200 problems per point; full 1319-problem runs will tighten the end-to-end timings.
The plateau. TPF stops near 2.2. The training data was written by other models, while the drafter is scored against Nanbeige's own continuations; training on Nanbeige's self-generated responses is the first fix to test.
Cheaper drafts. Drafting with one loop instead of two halves the draft cost.

References

Subham Sekhar Sahoo, Lingjie Chen, Khiem Pham, et al. Unlocking Lossless Speedups in LLMs via Discrete Diffusion. arXiv:2609.04010, 2026. arxiv.org/abs/2609.04010
Nanbeige LLM Lab. Nanbeige4.2-3B: Unlocking Agentic Capabilities in a Compact Model. arXiv:2607.22083, 2026. arxiv.org/abs/2607.22083