Paper: Discrete Diffusion VLA: Bringing Discrete Diffusion to Action Decoding in Vision-Language-Action Policies · Liang, Li, Yang, Wu, Mao, Nian, Pei, Zhou, Yang, Pang, Mu, Luo · ICLR 2026 · arXiv 2508.20072 Code: https://github.com/Liang-ZX/DiscreteDiffusionVLA Related summary: Discrete Diffusion VLA

This page is the long-form companion to the Discrete Diffusion VLA summary. Everything is sourced from arXiv 2508.20072v3 and the official code release.

Discrete Diffusion VLA (DDVLA) is the flagship ICLR 2026 paper for the "unified token stream" architectural family — the direct counter-proposal to the π-series' separate flow-matching action expert. Three design philosophies competing at ICLR 2026:

See Review-VLM-Action-Connection §4 (Unified token stream) and Review-VLA-Architecture §5.D.

DDVLA brings masked discrete diffusion to VLA action decoding inside a single transformer, eliminating the separate flow/diffusion action expert that the π-series depends on. Actions are quantized to 256-bin tokens (7 per timestep: 3 translation + 3 rotation + 1 gripper), treated as extra vocabulary in the VLM, and generated by iterative parallel unmasking with adaptive ordering + secondary re-masking. Headline: 96.3% average LIBERO (vs. π0 94.2%); 71.2% SimplerEnv-Fractal visual matching (+9.3 over π0-FAST); 54.2% SimplerEnv-Bridge (+6.4). Inference: T=12 forward passes vs. AR's 56, giving 4.7× fewer NFEs and 2× real latency speedup over OpenVLA while matching optimized continuous-diffusion latency. The key architectural insight: discrete diffusion preserves the VLM's discrete-token interface and cross-entropy training signal, so the action head doesn't corrupt VLM features — Knowledge Insulation becomes unnecessary because there's only one loss.

Every VLA has to answer: how does the VLM talk to the action generator? The 2025 field had two answers:

1. Autoregressive (AR) discrete tokens — OpenVLA-style. Same transformer, same CE loss, but sequential decoding (56 forward passes for a 7×8 chunk). Slow.
2. Continuous diffusion / flow-matching head — π-series. Separate transformer in the same stack with matched head-dim; parallel decoding in 5 Euler steps (63 ms on H100). Fast, but the two-loss training corrupts VLM features unless you add Knowledge Insulation to block gradient backflow.

DDVLA proposes a third way:

• Discrete like AR (same CE loss, same vocab interface) → VLM knowledge preserved
• Parallel refinement like diffusion (iterative unmasking) → fast decoding
• Adds adaptive ordering (easy-first, hard-later) and secondary re-masking (revisit uncertain tokens) that AR and BERT-style one-shot parallel can't do

Figure 1 of Liang et al. 2025. Four competing decoding paradigms over action chunks: continuous diffusion (left, sequential Euler steps over continuous vectors), AR (sequential token emission), BERT-style one-shot parallel (parallel but no refinement), and Discrete Diffusion with re-masking (right — parallel iterative refinement; uncertain tokens get re-masked across rounds). Included for scholarly review.

Figure 2 of the paper. Single-transformer VLM backbone (SigLIP+DINOv2 ViT for vision, Llama 2 for language) consumes multi-view RGB + language instruction + masked action tokens. The backbone emits all action tokens in parallel; adaptive decoding (bottom left) ranks tokens by confidence (max or gap) and commits high-confidence ones; secondary re-masking (bottom right) applies two consistency checks (threshold + residual-drop) to re-mask uncertain commitments for the next round.

flowchart LR
  V[3 camera images] --> E1[SigLIP+DINOv2 ViT]
  L[Language instruction] --> E2[Llama tokenizer]
  MA[Masked action tokens<br/>all [MASK] at t=T] --> E3[Action token embeds]
  E1 & E2 & E3 --> VLM[Single-transformer VLM<br/>bidirectional attn over action tokens]
  VLM --> SEL[Adaptive decoding<br/>max-confidence OR confidence-gap]
  SEL --> C[Commit high-confidence]
  C --> RM[Secondary re-masking<br/>threshold + residual-drop checks]
  RM -- uncertain → [MASK] again --> VLM
  RM -- stable → keep --> OUT[Action chunk<br/>H=8 × 7 tokens]
  OUT -- T=12 rounds total --> ACT[Actions]

• 256-bin quantile-based quantization (1st–99th percentiles per dimension)
• 7 tokens per timestep: 3 translation + 3 rotation + 1 gripper
• Chunk sizes: H=8 for LIBERO / SimplerEnv-Fractal, H=3 for SimplerEnv-Bridge
• Total sequence length: L = H × 7 (so 56 tokens for H=8)

• Backbone: Prismatic-7B (OpenVLA's backbone — SigLIP + DINOv2 ViT for vision, Llama 2 for language)
• Key change from OpenVLA: converts causal attention to bidirectional attention over action tokens so every action token sees every other during refinement
• Single transformer — no separate action expert, no MoE, no cross-attention module

Forward process: at corruption level $\gamma_t$, a fraction of action tokens are replaced with [MASK]. Training loss is masked cross-entropy computed only on masked positions:

$$\mathcal{L}_{\text{CE}}(\theta) = -\sum_{i \in \mathcal{M}_{\gamma_t}} \log p_\theta(a_{0,i} \mid \tilde{a}_t, c)$$

where $\tilde{a}t$ is the corrupted action chunk, $c$ is the context (vision+language), and $p\theta = \text{softmax}(W f_\theta(\tilde{a}_t, c))$.

This is the VLM's native cross-entropy objective. Unlike the π-series, there's no separate flow-matching loss — so no gradient backflow problem, no Knowledge Insulation needed.

Round t = T, T-1, …, 1:

1. Forward pass → get per-token distributions over all masked positions
2. Confidence selection:
   • Max-confidence: $s_{t,i} = \max_k p_\theta(k \mid a_t, c)$
   • Confidence-gap: top1 − top2 probability
3. Commit the top-scoring tokens (step-dependent number)
4. Secondary re-masking — two cheap consistency checks:
   • Threshold check: re-mask if confidence < step-dependent threshold $\eta_t^{\text{abs}}$
   • Residual-drop check: re-mask if confidence degrades relative to previous round or falls outside top-Q
5. Remaining + re-masked tokens → next round

Refinement rounds: T = 12 (efficiency/accuracy knee point). Temperature schedule: linear decay from τ=1.0 to τ=0.

• +0.8% over OpenVLA-OFT (same tokenization, different decoder) — isolates the discrete-diffusion mechanism from tokenization
• +2.1% over π0 (flow matching)
• +23.9% over vanilla Diffusion Policy

Per-task visual matching: Pick Coke 85.4%, Move Near 67.5%, Drawer 60.6%.

• +5.9% over π0-FAST, +14.1% over π0
• Put-eggplant grasp rate: 20.8% · success: 70.8%

DDVLA is evaluated against all four decoder families:

• Autoregressive (OpenVLA) → DDVLA wins on speed + accuracy
• Continuous diffusion (π0, Dita) → DDVLA wins on accuracy, ties on latency
• BERT-style one-shot parallel (OpenVLA-OFT) → DDVLA wins by +0.9% average
• Flow matching (GR00T-N1) → DDVLA wins on the same benchmarks

Every component matters. Random order helps marginally; confidence-based ordering is the big jump; re-masking adds the final 0.4%.

Anneal rather than clip — +1.2% over argmax.

• Diminishing returns beyond T=12
• Most accuracy at T∈[8,12]
• T=12 is the efficiency/accuracy knee point

DDVLA's discrete-token interface preserves pretrained VLM priors better under distribution shift — the clearest numerical argument for the unified-token-stream thesis.

• 4.7× fewer NFEs than AR → 2× real latency speedup
• Matches optimized continuous-diffusion latency (67 ms vs. 69 ms)
• Secondary re-masking overhead: <1 ms (negligible)
• Parallel one-shot is 2× faster but loses 1.8% accuracy

DDVLA sits on the Pareto frontier: same latency as continuous diffusion, better accuracy, no gradient-insulation headache.

DDVLA's empirical wins rest on four structural properties that AR, BERT-style parallel, and continuous diffusion can't combine:

1. Parallel but iterative. AR is sequential. BERT-style is parallel but one-shot. Continuous diffusion is iterative but on vectors. DDVLA is parallel AND iterative over discrete tokens — the only way to get both.
2. Adaptive order. AR forces left-to-right. BERT forces all-at-once. DDVLA lets the model decide which tokens to commit first based on its own confidence — instance-wise routing that matches the actual difficulty structure of the action chunk.
3. Re-masking = error correction. Once AR or BERT commits a token, it can't be revisited. DDVLA's secondary re-masking lets uncertain commitments be re-examined in later rounds — the only category-D mechanism with error correction.
4. Single loss, single interface. The VLM's CE loss trains every parameter. No separate flow-matching objective, no gradient backflow, no Knowledge Insulation needed. This is why DDVLA preserves VLM knowledge better under OOD.

The paper does not have a dedicated limitations section. Concerns worth flagging:

1. Fixed chunk length. H must be chosen in advance (H=8 for LIBERO, H=3 for Bridge). Not as flexible for variable-horizon tasks.
2. Refinement is required. T=12 forward passes vs. one-shot parallel's 1 — DDVLA is 2× slower than BERT-style but 1.8% more accurate. That accuracy/latency trade-off is real.
3. OOD gap is not zero. −21% vision-aug degradation is better than baselines but still large in absolute terms.
4. Discrete → 256 bins. Fine-grained manipulation (sub-millimeter precision) could hit the quantization ceiling.

1. No head-to-head with π0.6 or π0.7. The paper compares to π0 and π0-FAST (2024–25 era) but not the Nov 2025 π0.6 (Knowledge Insulation + Gemma3-4B) or Apr 2026 π0.7. The π-series has moved on; the numerical comparison isn't current.
2. No real-robot deployment. All results are sim (LIBERO + SimplerEnv). π0.6/π0.7 claim production-grade real-robot performance; DDVLA hasn't demonstrated that yet.
3. Chunk-size hyperparameter leakage. H=8 for LIBERO/Fractal, H=3 for Bridge — this is a per-benchmark tuning that's not always transparent.
4. The accuracy wins are small (+0.8% over OpenVLA-OFT with matched tokenization). Most of the gain over π0 comes from tokenization + backbone differences, not from the discrete-diffusion mechanism itself.
5. Closed-weights competitors (π0.6, π0.7) have better real-world evidence. Open code ≠ winning in production.
6. Fixed denoising schedule. T=12 and linear temperature decay are not adaptive to task difficulty — DexterityGen-style task-adaptive inference is absent.

DDVLA is the strongest empirical case for "unified token stream" (Category D). Together with Unified Diffusion VLA (joint frame+action denoising), dVLA (with text CoT channel), and DIVA & Fast-dVLA (latency optimizations), it defines the ICLR 2026 alternative to the π-series flow-matching paradigm.

Three structural contributions:

1. Discrete diffusion as an action decoder — not a minor tokenizer tweak, a genuine new decoder family at the mechanism level
2. Adaptive ordering + re-masking — the first category-D system with error correction across refinement rounds
3. Empirical parity with π0 on continuous-control benchmarks while keeping the unified-transformer simplicity

What DDVLA does not prove: that discrete diffusion can match π0.6/π0.7 / Gemini Robotics on real-robot production benchmarks. That comparison hasn't been run. The 2026 flow-matching vs. discrete-diffusion debate is still open — DDVLA's case rests on LIBERO/SimplerEnv, while the π-series case rests on "cleans real homes / folds UR5e laundry zero-shot."

Placement (see Review-VLA-Architecture §5.D and Review-VLM-Action-Connection §4): DDVLA is the canonical ICLR 2026 Category D exemplar. Any subsequent discrete-diffusion VLA paper that doesn't beat DDVLA on LIBERO is not seriously in the race.

• Summary page: Discrete Diffusion VLA
• Architecture family siblings: Unified Diffusion VLA (+ future-frame co-denoising), dVLA (+ text CoT), DIVA & Fast-dVLA (latency optimizations)
• The competing paradigm: π0.6 · π0.7 — separate flow-matching action expert with Knowledge Insulation
• Per-paper reviews: Review-pi06 · Review-pi07 · Review-Fast-in-Slow · Review-VLM4VLA
• Cross-paper reviews: Review-VLA-Architecture §5.D (Unified token stream) · Review-VLM-Action-Connection §4 (Unified token stream mechanism)

• arXiv: https://arxiv.org/abs/2508.20072 · HTML: https://arxiv.org/html/2508.20072
• OpenReview: https://openreview.net/forum?id=YWeNCMxdhM
• Hugging Face paper: https://huggingface.co/papers/2508.20072
• Code: https://github.com/Liang-ZX/DiscreteDiffusionVLA/tree/libero
• Authors: Liang, Li, Yang, Wu, Mao, Nian, Pei, Zhou, Yang, Pang, Mu, Luo · Affiliations: HKU, Shanghai AI Laboratory, Shanghai Jiao Tong University, Huawei Cloud

← Back to ICLR-2026-Discrete-Diffusion-VLA · ICLR-2026 · Home