pith. sign in

arxiv: 2604.25050 · v3 · pith:NCQ4Y6O6new · submitted 2026-04-27 · 💻 cs.RO

DiscreteRTC: Discrete Diffusion Policies are Natural Asynchronous Executors

Pengcheng Wang , Kaiwen Hong , Chensheng Peng , Katherine Driggs-Campbell , Masayoshi Tomizuka , Chenfeng Xu , Chen Tang This is my paper

Pith reviewed 2026-05-08 02:27 UTC · model grok-4.3

classification 💻 cs.RO
keywords discrete diffusionasynchronous executionreal-time chunkingrobotic action policiesaction inpaintingdiffusion modelsdynamic manipulation
0
0 comments X

The pith

Discrete diffusion policies act as natural asynchronous executors because iterative unmasking makes inpainting native to them.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

Physical robots must generate actions while the environment keeps changing, so any pause between action chunks risks failure on dynamic tasks. Asynchronous execution solves this by committing to an initial chunk and then inpainting the rest as the robot moves. Continuous flow-matching policies handle inpainting only through extra inference-time corrections that demand fine-tuning and added computation. Discrete diffusion policies instead generate by repeatedly unmasking tokens, so freezing committed actions and continuing to unmask the open ones is simply the model's normal behavior. This native support removes fine-tuning, allows early stopping for cheaper adaptive guidance, and yields higher success rates on simulated and real dynamic manipulation tasks.

Core claim

Discrete diffusion policies generate actions by iteratively unmasking, which makes real-time chunking their native operation rather than an added correction. Freezing already-committed action chunks and unmasking the remainder produces consistent continuations without any task-specific fine-tuning or external guidance modules. Early stopping during the unmasking process supplies adaptive guidance at lower inference cost than generating a full new sequence from scratch.

What carries the argument

Iterative unmasking process in discrete diffusion policies, which directly supports inpainting of open action chunks while executing committed ones.

If this is right

  • Implementation requires zero extra code for the inpainting step because it reuses the existing unmasking loop.
  • Inference cost falls to roughly 0.7 times the cost of generating a full action sequence from scratch.
  • Real-world dynamic pick success rate rises by about 50 percent relative to flow-matching-based real-time chunking.
  • Early stopping during unmasking supplies adaptive guidance without separate heuristic modules.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same native inpainting property could let discrete diffusion policies handle variable-length action horizons on the fly without retraining.
  • Because inpainting is built in, the approach may transfer more readily to new robot hardware or sensor suites than methods that rely on post-training corrections.
  • Combining early-stopping guidance with online data collection might further close the gap between offline training and live deployment.

Load-bearing premise

A discrete diffusion policy trained on standard offline data will keep producing high-quality, consistent continuations when inpainting around frozen committed action chunks in changing environments.

What would settle it

A controlled experiment showing that success rates or action smoothness drop sharply when DiscreteRTC switches from synchronous to asynchronous mode in the same dynamic pick or manipulation tasks.

Figures

Figures reproduced from arXiv: 2604.25050 by Chenfeng Xu, Chensheng Peng, Chen Tang, Kaiwen Hong, Katherine Driggs-Campbell, Masayoshi Tomizuka, Pengcheng Wang.

Figure 1
Figure 1. Figure 1: Async Execution with discrete diffusion policies solving dynamic manipulation. Gray rectangles and blocks represent the action chunks and the actions. Yellow and green cubes represent the masked and unmasked action tokens. During each inference cycle, discrete diffusion policies copy the tail of the last action chunk as the committed prefix, and inpaint upon it by simply forwardin itself. Compared with flo… view at source ↗
Figure 2
Figure 2. Figure 2: RTC with flow-matching head. Color represents the noise level, where green stands for the clear action and yellow stands for the pure noise. The flow-matching head is ill-suited for RTC because (a) during pre-training, the base policy is not trained on inpainting tasks; (b) to acquire this capability, a specially designed fine-tuning stage is required; (c) at inference time, RTC relies on heuristic guidanc… view at source ↗
Figure 3
Figure 3. Figure 3: RTC with discrete diffusion head. Color represents the masking status, where green stands for the unmasked token and yellow stands for the masked token. The discrete diffusion head is naturally suited for RTC because (a) during pre-training, the base policy is already trained on inpainting tasks; (b) consequently, no inpainting-specific fine-tuning is required; (c) at inference time, early stopping from th… view at source ↗
Figure 4
Figure 4. Figure 4: Experimental Results in Kinetix. The throughputs represent the task completed by the policy every 256 steps. Left: Average solve rate and throughputs across all environments with different inference delays; Right: Solve rates for every tasks with different inference delays. The executions horizon follows s = max(1, d) and each datapoint represents 2048 trials. To ensure valid execution before the next infe… view at source ↗
Figure 5
Figure 5. Figure 5: Extend Experimental Results in Kinetix. Left: Required interative steps for each in￾painting inference of different policy architectures in Kinetix with s = max(1, d); Right: Average solve rates of extended variants in Kinetix. The evaluation setup keeps the same with view at source ↗
Figure 6
Figure 6. Figure 6: Unmasking Trajectory Sample with Natural Schedule Inference. Green blocks denote unmasked action tokens, yellow blocks denote masked tokens, and the red rectangle marks the early￾stop boundary beyond which tokens do not need to be unmasked before the next inference. In practice, the natural schedule does work as expected compared to the simple hard mask approach. In this section, we show how the inappropri… view at source ↗
Figure 7
Figure 7. Figure 7: Detailed Main Results in Kinetix. The evaluation setup keeps the same with view at source ↗
Figure 8
Figure 8. Figure 8: Fine-tuning Ablation in Kinetix. The evaluation setup keeps the same with view at source ↗
Figure 9
Figure 9. Figure 9: dynamic Pick and Place Real-world Setup Hardware and Data. We use a single UR5e arm with a Robotiq gripper and a wrist-mounted RGB camera. Demonstrations are recorded at 500 Hz via the FastUMI pipeline. Each action is a 10D vector [∆x, ∆y, ∆z, rot6d(6), gripper], with translational dimensions normalized to [−1, 1] via min-max scaling, rotation dimensions left unnormalized, and the gripper binarized to {0, … view at source ↗
read the original abstract

Unlike chatbots, physical AI must act while the world keeps evolving. Therefore, the inter-chunk pause of synchronous executors are fatal for dynamic tasks regardless of how fast the inference is. Asynchronous execution -- thinking while acting -- is therefore a structural requirement, and real-time chunking (RTC) makes it viable by recasting chunk transitions as inpainting: freezing committed actions and consistently generating the remainder. However, RTC with flow-matching policy is structurally suboptimal: its inpainting comes from inference-time corrections rather than the base policy, yielding little pre-training benefit, specific fine-tuning, heuristic guidance, and extra computation that inflates the latency. In this work, we observe that discrete diffusion policies, which generate actions by iteratively unmasking, are natural asynchronous executors that resolve all limitations at once: they are fine-tuning free since inpainting is their native operation, while early stopping further provides adaptive guidance and reduces inference cost. We propose DiscreteRTC, which replaces external corrections with native unmasking, and show on dynamic simulated benchmarks and real-world dynamic manipulation tasks that it achieves higher success rates than continuous RTC and other baselines. In summary, DiscreteRTC is simpler to implement with 0 lines of additional code to enable async inpainting, faster at inference with only ~0.7 computation compared with generating actions from scratch, and better at execution with 65% higher success rate in real-world hockey defend task compared with flow-matching RTC, and 30% higher compared with training-time flow-matching RTC. More visualizations are on https://outsider86.github.io/DiscreteRTCSite/.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 1 minor

Summary. The paper claims that discrete diffusion policies generate actions via iterative unmasking and are therefore natural asynchronous executors for real-time chunking (RTC). By treating chunk transitions as native inpainting, DiscreteRTC avoids the inference-time corrections, task-specific fine-tuning, and extra compute required by flow-matching RTC; early stopping further supplies adaptive guidance. Empirical results on dynamic simulated benchmarks and real-world manipulation tasks are reported to show higher success rates (50% improvement in a real pick task) and lower inference cost (0.7x compute) relative to continuous RTC and other baselines.

Significance. If the empirical claims hold under rigorous testing, the work would be significant for robotics and control: it supplies a structurally simpler mechanism for asynchronous execution that directly exploits the generative process of discrete diffusion, eliminating the need for external corrections or fine-tuning while simultaneously lowering latency. This could reduce the engineering overhead for deploying policies in dynamic physical environments where synchronous chunking is inadequate.

major comments (2)
  1. [Abstract] Abstract: the reported gains (50% higher success rate in the real pick task, 0.7x compute) are presented without error bars, statistical tests, or a detailed experimental protocol. Because these numbers are the primary evidence for the superiority of DiscreteRTC over flow-matching RTC, the absence of statistical rigor is load-bearing for the central empirical claim.
  2. [Abstract and Experiments] The skeptic concern about distribution shift is not addressed: a policy trained on complete offline trajectories may not produce consistent, high-quality inpainted continuations when a prefix of actions is committed and the world state evolves during execution. Without ablations that explicitly test partial-commitment conditioning or measure degradation under dynamic conditions, the assertion that inpainting is 'fine-tuning free' and native remains vulnerable.
minor comments (1)
  1. [Abstract] Abstract: the informal phrasing '0 lines of code for async inpainting' should be replaced by a precise statement of what implementation changes (if any) are required to enable the inpainting behavior.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive feedback on our work. We address the concerns about statistical rigor and distribution shift by committing to revisions that add error bars, statistical details, and targeted ablations while preserving the core claims supported by our dynamic benchmarks and real-world results.

read point-by-point responses

  1. Referee: [Abstract] Abstract: the reported gains (50% higher success rate in the real pick task, 0.7x compute) are presented without error bars, statistical tests, or a detailed experimental protocol. Because these numbers are the primary evidence for the superiority of DiscreteRTC over flow-matching RTC, the absence of statistical rigor is load-bearing for the central empirical claim.

    Authors: We agree that the abstract requires greater statistical transparency to support the central claims. In the revised manuscript, we will add error bars to the reported success rates and compute metrics, specify the number of trials (e.g., 20 independent runs for the real pick task), and include references to statistical tests such as paired t-tests for significance between DiscreteRTC and flow-matching RTC. The full experimental protocol, including environment details, hyperparameters, and evaluation procedures, is already provided in Section 4 and the appendix; we will add an explicit cross-reference in the abstract. revision: yes

  2. Referee: [Abstract and Experiments] The skeptic concern about distribution shift is not addressed: a policy trained on complete offline trajectories may not produce consistent, high-quality inpainted continuations when a prefix of actions is committed and the world state evolves during execution. Without ablations that explicitly test partial-commitment conditioning or measure degradation under dynamic conditions, the assertion that inpainting is 'fine-tuning free' and native remains vulnerable.

    Authors: We appreciate this valid concern about potential distribution shift in asynchronous settings. Discrete diffusion policies are trained with a random masking objective that naturally includes partial action sequences, enabling native inpainting without fine-tuning or external corrections. Our dynamic simulated benchmarks and real-world manipulation tasks already evaluate performance under evolving world states with sequential action commitment, where DiscreteRTC outperforms baselines. To directly address partial-commitment conditioning, we will add an ablation in the revised paper that measures success rates, consistency of generated continuations, and any performance degradation across varying prefix commitment lengths in simulated dynamic environments. revision: yes

Circularity Check

0 steps flagged

No circularity: claim follows directly from discrete diffusion generative mechanism

full rationale

The paper's core assertion—that discrete diffusion policies serve as natural asynchronous executors because inpainting (freezing committed actions and unmasking the rest) is their native operation—derives immediately from the standard iterative unmasking process in discrete diffusion models, without any equations, fitted parameters, or self-citations reducing the result to a constructed input. The abstract and described mechanism present this as an inherent property of the architecture, with empirical benchmarks (success rates, inference cost) serving as external validation rather than definitional support. No load-bearing steps match the enumerated circularity patterns; the derivation remains self-contained against the model's generative definition.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

The claim rests on the standard generative properties of discrete diffusion models (iterative unmasking) and the assumption that these properties transfer to real-time inpainting without additional training; no new free parameters, axioms, or invented entities are introduced for the core argument.

pith-pipeline@v0.9.0 · 5595 in / 1167 out tokens · 85170 ms · 2026-05-08T02:27:34.437853+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.