💻 computer science

DiscreteRTC: Discrete Diffusion Policies are Natural Asynchronous Executors

The paper proposes DiscreteRTC, a framework that leverages the native unmasking capability of discrete diffusion policies to enable efficient, fine-tuning-free asynchronous execution for physical AI, achieving significantly higher success rates and lower inference costs compared to existing flow-matching-based approaches.

Original authors: Pengcheng Wang, Kaiwen Hong, Chensheng Peng, Katherine Driggs-Campbell, Masayoshi Tomizuka, Chenfeng Xu, Chen Tang

Published 2026-04-29

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Pengcheng Wang, Kaiwen Hong, Chensheng Peng, Katherine Driggs-Campbell, Masayoshi Tomizuka, Chenfeng Xu, Chen Tang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: The "Thinking vs. Acting" Dilemma

Imagine you are playing a fast-paced video game, like a tennis match against a computer.

The Robot's Job: The robot needs to hit the ball.
The Problem: The robot's brain (the AI) takes a moment to calculate the perfect swing. While it is "thinking," the ball keeps flying.
The Old Way (Synchronous): The robot stops, thinks, calculates, and then swings. By the time it swings, the ball has already passed. This is fatal for dynamic tasks.
The Better Way (Asynchronous): The robot needs to think while it is already moving. It should keep swinging based on its last thought while simultaneously calculating the next swing.

The Current Solution: "Real-Time Chunking" (RTC)

To solve this, engineers use a method called Real-Time Chunking (RTC).

The Analogy: Imagine the robot is writing a story in chunks of 10 words at a time.
1. It writes words 1–10.
2. While it is writing words 11–20, it starts executing words 1–10.
3. The Glitch: When the robot switches from the first chunk to the second, the transition can be jerky. It's like a writer suddenly changing their handwriting style mid-sentence. The robot might jerk its arm because the new plan doesn't perfectly match the old one.

To fix this jerkiness, the current best method (using Flow-Matching) tries to "paint over" the transition. It freezes the words it has already written and tries to "inpaint" (fill in) the rest of the sentence to make it smooth.

The Catch: This "inpainting" is like asking a painter to fix a painting while they are still mixing the paint. It requires a special, complicated guide (a heuristic) to tell the AI how to blend the old and new. It's slow, requires extra training, and often feels clunky.

The New Solution: DiscreteRTC

The authors propose a new way called DiscreteRTC. They swap the robot's "brain" (the policy) for a Discrete Diffusion Policy.

The Analogy: The "Fill-in-the-Blanks" Game
Imagine the robot isn't writing a story from scratch. Instead, it's playing a game of "Fill-in-the-Blanks" (like a Mad Libs or a crossword puzzle).

How it works: The robot is trained to look at a sentence with some words hidden (masked) and guess what the missing words are.
The Magic: Because the robot is already an expert at guessing missing words, it doesn't need to learn a special trick to "inpaint" the transition. It just does what it was born to do.

Here is why this new method is a game-changer, according to the paper:

1. No Extra Training Needed (Fine-Tuning Free)

Old Way: You had to teach the robot a special "transition skill" after it was already trained, which was hard and risky.
New Way: The robot is already trained to fill in blanks. When it needs to switch chunks, it just treats the transition as a new "fill-in-the-blanks" puzzle. It works perfectly right out of the box.

2. Natural Guidance (No Complicated Rules)

Old Way: Engineers had to write complex, manual rules (heuristics) to tell the AI how to blend the old and new actions. It was like giving a driver a manual on how to steer, rather than letting them drive.
New Way: The robot naturally knows how to handle the transition. If it has already figured out the first few words of the new chunk, it just stops there and waits for the next thought. The "unmasked" words naturally guide the next step without needing a manual.

3. Faster and Cheaper (Lower Inference Cost)

Old Way: The "painting over" method required the robot to do double the work (calculating the original plan plus the correction), making it slower.
New Way: Since the robot only needs to "unmask" (reveal) the words it hasn't figured out yet, it skips the work it has already done. It's like reading a book where you only read the pages you haven't seen yet, rather than re-reading the whole book every time you turn a page.
- Result: It is about 30% faster (0.7x computation) than the old method.

The Results: Does it actually work?

The authors tested this in two ways:

Simulated World (Kinetix): A digital playground with moving targets.
- Result: The new method solved tasks more often and handled delays much better than the old method.
Real Robot (Real World): A physical robot arm trying to pick up moving objects and place them on moving platforms.
- Result: The old method failed completely (0% success) on the hardest moving tasks. The new method succeeded 95–100% of the time.
- Speed: The new method was also faster in real-time execution.

Summary in One Sentence

DiscreteRTC is a new way for robots to think while they move that treats action planning like a "fill-in-the-blanks" game, making it naturally smoother, faster, and requiring zero extra training compared to the current clunky methods.

1. Problem Statement

Physical AI systems (robots) operate in dynamic environments where the world evolves continuously. Unlike chatbots or image generators, robots cannot afford to pause execution while the policy is computing.

The Bottleneck: Modern Vision-Language-Action (VLA) models often use Action Chunking (generating a sequence of future actions at once) to improve stability. However, standard synchronous execution forces a mandatory pause between chunks while the next chunk is generated.
The Consequence: In dynamic tasks (e.g., tracking moving objects), this inter-chunk pause causes the robot to become idle while the world moves, leading to failure.
Current Solution & Limitations: Real-Time Chunking (RTC) attempts to solve this by treating chunk transitions as an inpainting problem: freezing the committed actions from the previous chunk and generating the remainder to ensure smoothness.
- Current RTC implementations rely on Flow-Matching policies.
- Critical Flaws of Flow-Matching RTC:
  1. Pre-training Mismatch: Flow-matching models are pre-trained on consistent noise levels, not the mixed-noise patterns required for inpainting (frozen prefix + noisy future). Scaling pre-training does not improve async performance.
  2. Fine-Tuning Overhead: Achieving good inpainting requires dedicated fine-tuning with specific noise patterns and loss functions, which is computationally expensive and risks degrading base generation quality.
  3. Heuristic Guidance: RTC requires external, hand-crafted guidance schedules (e.g., $\Pi$ GDM) to steer generation toward the frozen prefix. These are inflexible and require tuning.
  4. Latency Penalty: The external correction term in flow-matching roughly doubles the inference cost per step, ironically increasing the latency RTC aims to hide.

2. Methodology: DiscreteRTC

The authors propose DiscreteRTC, a framework that replaces the Flow-Matching action head with a Discrete Diffusion Policy. The core insight is that discrete diffusion policies are "natural asynchronous executors" because their native operation is iterative unmasking, which aligns perfectly with the inpainting requirement.

Key Mechanisms

Native Inpainting via Pre-training:
- Discrete diffusion models are pre-trained to reconstruct randomly masked token sequences.
- In RTC, the "frozen" actions from the previous chunk are treated as unmasked tokens, and the future actions are masked.
- The model simply performs a forward pass to unmask the future tokens. No external correction or fine-tuning is needed because the model has already learned this exact task during pre-training.
Natural Guidance via Early Stopping:
- Unlike continuous diffusion where the output is only valid at the end of the process, discrete diffusion produces valid semantic tokens as soon as they are unmasked.
- The system can early-exit inference once the necessary number of actions (the execution horizon) are unmasked.
- The remaining partially masked tokens from the current inference serve as a natural, adaptive guidance signal for the next inference cycle, eliminating the need for heuristic weighting schedules.
Reduced Inference Cost:
- Since the model starts from an intermediate state (partially unmasked) and only needs to unmask the remaining future tokens, the total number of unmasking steps per inference is significantly reduced compared to generating a full chunk from scratch.
- This leads to lower computational overhead compared to Flow-Matching RTC, which adds heavy correction costs.

3. Key Contributions

Structural Insight: Identified that Discrete Diffusion Policies are structurally superior to Flow-Matching for asynchronous execution because inpainting is their native operation.
DiscreteRTC Framework: Proposed a method that achieves asynchronous execution with 0 lines of code for async inpainting logic (relying solely on the base policy's forward pass).
Elimination of Overhead: Removed the need for:
- Inpainting-specific fine-tuning.
- Heuristic guidance schedules ( $\Pi$ GDM).
- Extra inference computation for corrections.
Performance Gains: Demonstrated that DiscreteRTC is faster (lower latency) and more accurate (higher success rate) than state-of-the-art Flow-Matching RTC.

4. Experimental Results

A. Simulated Benchmarks (Kinetix)

Setup: Evaluated on dynamic physics tasks with varying inference delays ( $d$ ).
Metrics: Solve Rate and Throughput.
Results:
- DiscreteRTC consistently outperformed ContinuousRTC (Flow-Matching) and other baselines (Naive, Bidirectional Decoding) across all delay settings.
- Efficiency: DiscreteRTC required fewer iterative steps per policy compared to ContinuousRTC.
- Fine-tuning: DiscreteRTC achieved higher success rates than "Training-time Continuous RTC" (which required explicit fine-tuning), proving the efficacy of the "fine-tuning-free" approach.

B. Real-World Dynamic Manipulation

Setup: UR5e robot with a Robotiq gripper performing Dynamic Pick (picking moving objects) and Dynamic Place (placing on moving platforms).
Baselines: Synchronous (Sync) and RTC variants using both Flow-Matching and Discrete Diffusion.
Key Findings (Table 1):
- Success Rate: Synchronous methods failed completely (0%). DiscreteRTC achieved 100% on Dynamic Place and 95% on Dynamic Pick, significantly outperforming ContinuousRTC (45% on Dynamic Pick).
- Inference Latency:
  - ContinuousRTC increased inference time by ~1.7x (from 151ms to 256ms) due to $\Pi$ GDM corrections.
  - DiscreteRTC reduced inference time by ~0.7x (from 303ms to 206ms) because fewer tokens needed unmasking.
- Conclusion: DiscreteRTC is both faster and more accurate than Flow-Matching RTC in real-world scenarios.

5. Significance

Paradigm Shift: The paper challenges the dominance of Flow-Matching in VLA action heads for real-time control, suggesting Discrete Diffusion as a superior alternative for dynamic tasks.
Practical Deployment: It offers a "plug-and-play" solution for real-time robotics that requires no complex engineering (no custom loss functions, no heuristic tuning, no extra compute).
Scalability: By leveraging pre-training directly for async execution, the method scales naturally with larger models and datasets, unlike Flow-Matching RTC which hits a performance ceiling without expensive fine-tuning.
Future Directions: The authors highlight that further gains can be achieved by developing temporally-aware tokenizers and unified discrete-diffusion VLAs, but the current method already establishes a new state-of-the-art for asynchronous execution.

In summary, DiscreteRTC demonstrates that by aligning the policy architecture (Discrete Diffusion) with the execution requirement (Asynchronous Inpainting), one can achieve superior performance, lower latency, and simpler implementation compared to current Flow-Matching based approaches.