DiscreteRTC: Diffusion Policies for Asynchronous RTC

• DiscreteRTC is an asynchronous execution method for robot actions that uses discrete diffusion and iterative unmasking to handle real-time chunk transitions.
• It reframes the RTC problem into a masked-token reconstruction task, eliminating additional fine-tuning or correction code during inference.
• Empirical results demonstrate reduced latency and a 50% improvement in dynamic task success compared to flow-matching RTC methods.

DiscreteRTC is an asynchronous execution method for chunked robot action policies that uses discrete diffusion to turn real-time chunk transitions into a native masked-token reconstruction problem rather than an inference-time correction problem. Introduced in "DiscreteRTC: Discrete Diffusion Policies are Natural Asynchronous Executors" (Wang et al., 27 Apr 2026), it addresses the setting in which physical AI must continue acting while the world changes during inference. Its central claim is that discrete diffusion policies are structurally well matched to real-time chunking (RTC) because they already generate by iterative unmasking: committed actions from the previous chunk can simply remain fixed, and the remainder of the chunk can be completed by ordinary unmasking. In the reported implementation and experiments, this yields zero new training stages, "0 lines of code for async inpainting," approximately $0.7\times$ computation relative to generating a full chunk from scratch, and a $50\%$ relative improvement in real-world dynamic pick success over flow-matching-based RTC (Wang et al., 27 Apr 2026).

1. Problem setting and motivation

DiscreteRTC is defined against the failure mode of synchronous chunked control. In that regime, a policy predicts a block of $H$ future actions $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$, but inference introduces a delay $d$ during which execution stalls while the environment continues evolving. For dynamic tasks such as tracking a moving object or placing on a moving platform, this inter-chunk pause is described as structurally fatal because the robot becomes idle exactly when the world is changing (Wang et al., 27 Apr 2026).

Real-time chunking recasts this pause as an inpainting problem. If inference takes $d$ steps, then the first $d$ actions of the next chunk are already committed by the previous chunk and must be frozen; only the remaining $H-d$ actions need to be generated. This overlap between execution and generation is the basis of "thinking while acting." DiscreteRTC inherits that RTC formulation but changes the action head used to solve it. The paper argues that the dominant continuous alternative—flow-matching policies trained via conditional velocity fields—is structurally mismatched to RTC because the inpainting behavior must be imposed externally rather than arising from the base policy itself (Wang et al., 27 Apr 2026).

Four limitations of flow-matching RTC are emphasized. First, there is a pre-training mismatch: training exposes the model to chunks in which all $H$ actions are noised at the same level, whereas RTC induces a mixed-noise pattern with a committed prefix and a newly generated suffix. Second, inpainting typically requires fine-tuning with action-suffix conditioning or explicit mixed-noise training. Third, inference uses external correction through IIGDM and hand-crafted soft-mask weights $W_i=\exp(-\lambda i)$, which are fixed rather than adaptive. Fourth, IIGDM increases compute through vector-Jacobian products and therefore inflates latency, undermining the purpose of RTC itself (Wang et al., 27 Apr 2026).

2. Discrete diffusion formulation

The DiscreteRTC construction begins from a discrete diffusion policy over tokenized actions. A continuous action chunk $50\%$0 is quantized into a token sequence $50\%$1, with each token in $50\%$2. The paper describes tokenization either through $50\%$3-bin quantization or VQ-VAE, and it treats the forward process as repeated masking and the reverse process as iterative unmasking (Wang et al., 27 Apr 2026).

The forward process is defined by a fully masked initial sequence $50\%$4. At each step $50\%$5, a subset of masked positions is revealed according to the ground-truth sequence, yielding a Markov chain $50\%$6 that unmasks a fixed number of tokens per step. The reverse process is the policy $50\%$7, which predicts token distributions conditioned on the current partially unmasked sequence and the observation $50\%$8. The update is written as

$50\%$9

where $H$0 denotes the selection rule used to decide which masked positions to reveal next, for example by confidence (Wang et al., 27 Apr 2026).

Training is correspondingly a masked-token reconstruction objective. The loss is

$H$1

The first term is cross-entropy on masked positions, and the second is an optional auxiliary $H$2 penalty on decoded continuous actions. Because random masking and inpainting are already the pre-training objective, the policy is described as natively prepared for RTC’s frozen-prefix completion. This is the basis for the paper’s characterization of DiscreteRTC as fine-tuning-free (Wang et al., 27 Apr 2026).

The key conceptual shift is that RTC no longer requires a separate inference-time mechanism to enforce a frozen prefix. In continuous RTC, prefix consistency is added by correction; in DiscreteRTC, it is already the native semantics of masked-token prediction. The paper therefore frames scaling pre-training as directly beneficial for asynchronous execution quality, rather than as pre-training for one task followed by a distinct RTC adaptation stage (Wang et al., 27 Apr 2026).

3. Inference algorithm and asynchronous execution

At inference time, DiscreteRTC initializes the next chunk by concatenating the committed prefix from the previous chunk with masks over the not-yet-generated suffix. With $H$3 the inference delay, $H$4 the chunk length, and $H$5 the execution horizon, the initial state is built from the last $H$6 committed actions and $H$7 masked positions. The policy then repeatedly predicts logits at all masked positions, unmasks approximately $H$8 high-confidence tokens, and stops early once the next $H$9 actions needed for execution are available (Wang et al., 27 Apr 2026).

The algorithmic structure can be summarized as follows. First, initialize the chunk with a frozen prefix of length $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$0 and a masked suffix of length $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$1. Second, for up to $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$2 unmasking steps, run the usual policy forward pass, identify masked positions, and reveal a confidence-ranked subset. Third, once positions $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$3 are all unmasked, decode the partial token sequence back to continuous actions and execute the first $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$4 actions while the next inference runs. The returned state is the partially or fully unmasked chunk itself, which becomes the starting point for the next RTC step (Wang et al., 27 Apr 2026).

Early stopping is central to the method. The paper states that if the required execution-horizon tokens are already resolved, there is no need to finish the entire chunk. This reduces the average number of reverse steps from $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$5 to $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$6. The still-masked future portion of the chunk then acts as "natural guidance" for the next inference call. Unlike IIGDM-based RTC, no additional gradient corrections or special inpainting code are required; the same policy_forward() and token bookkeeping used in standard discrete diffusion are reused, with only the initial mask construction and early-stop criterion altered (Wang et al., 27 Apr 2026).

This native continuation property is also presented as the source of adaptive guidance. In continuous RTC, prefix attraction is governed by a hand-designed weight schedule $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$7. In DiscreteRTC, the guidance pattern is simply the current mask state produced by early stopping. A plausible implication is that the method aligns the execution semantics with the generative semantics of the action head more tightly than correction-based continuous RTC, because the partial plan passed between consecutive chunks is already a legal intermediate state of the same generative process.

4. Computational properties and implementation

The computational argument for DiscreteRTC is comparative rather than asymptotic. Generating a full chunk from scratch requires $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$8 reverse steps and one full forward pass per step. DiscreteRTC begins with $A_t=(a_t,a_{t+1},\ldots,a_{t+H-1})$9 tokens already unmasked and often terminates after $d$0 steps once the next $d$1 actions are ready. The paper reports that, on a single RTX 4090, continuous flow-matching with IIGDM takes approximately $d$2 ms per chunk, corresponding to $d$3 overhead versus a $d$4 ms continuous base policy, whereas discrete diffusion RTC takes approximately $d$5 ms, corresponding to $d$6 overhead versus a $d$7 ms base discrete policy (Wang et al., 27 Apr 2026).

The real-robot implementation uses a UR5e arm with a Robotiq gripper and a wrist-mounted RGB camera at $d$8 Hz control. Demonstrations are recorded at $d$9 Hz. Actions are a $d$0-D vector,

$d$1

with translational dimensions normalized to $d$2 and gripper values in $d$3. Images are center-cropped to $d$4. The VLM is Qwen2.5-VL-3B-Instruct, and the action head is a $d$5-layer DiT with layerwise cross-attention to VLM hidden states (Wang et al., 27 Apr 2026).

For the discrete diffusion head, the reported configuration uses $d$6 bins per action dimension, producing $d$7 tokens per chunk, with embedding dimension $d$8, $d$9 unmask steps, and a cosine masking schedule. Training uses AdamW with learning rate $d$0, cosine decay, batch size $d$1, and mixed precision with bfloat16 for the VLM. At deployment, camera capture and inference run in a background thread to overlap with servo execution, and servo control runs at $d$2 Hz via $d$3 linear interpolation of $d$4 Hz commands. MaskGIT unmasking uses decode temperature $d$5 and choice temperature $d$6. The default RTC parameters are $d$7 and $d$8, and $d$9 is reported as a stable compute-quality trade-off, with $H-d$0 (Wang et al., 27 Apr 2026).

The paper also makes two practical claims about training. First, no special dataset is required beyond standard VLA demonstrations; discrete diffusion pre-training is said to suffice for RTC. Second, small ablations show that naive fine-tuning hurts performance, motivating the recommendation to scale pre-training instead of adding an RTC-specific fine-tuning stage (Wang et al., 27 Apr 2026).

5. Empirical performance

The simulation study uses the Kinetix benchmark with $H-d$1 dynamic control tasks and noisy actuation. The reported metrics are solve rate, defined as the fraction of episodes completed, and throughput, defined as tasks per $H-d$2 control steps. Baselines include Continuous-Naive, Continuous-BID, Continuous-RTC, Discrete-Naive, Discrete-BID, and DiscreteRTC. Averaged over tasks and delays, DiscreteRTC achieves a solve rate of approximately $H-d$3, compared with approximately $H-d$4 for ContinuousRTC and below $H-d$5 for Naive and BID strategies; throughput is reported as approximately $H-d$6 for DiscreteRTC versus approximately $H-d$7 for ContinuousRTC. The paper further states that DiscreteRTC outperforms a fine-tuned continuous RTC system labeled Training-time RTC despite requiring zero extra training, and that a fixed-step variant, DiscreteRTC+FixedSteps, yields finer granularity at the same compute (Wang et al., 27 Apr 2026).

The real-world evaluation is conducted on dynamic pick and dynamic place tasks. The platform is the UR5e-based system described above, using the StarVLA codebase, a wrist RGB camera at $H-d$8 Hz, and the Qwen2.5-VL-3B VLM with DiT action head. Each task is evaluated over $H-d$9 trials (Wang et al., 27 Apr 2026).

Method	Success rates	Inference time
Sync (continuous or discrete)	$H$0 on dynamic tasks	not separately emphasized
ContinuousRTC	Place $H$1, Pick $H$2	$H$3 ms $H$4
DiscreteRTC	Place $H$5, Pick $H$6	$H$7 ms $H$8

Two points are emphasized by these results. First, synchronous execution fails entirely in the reported dynamic real-world setting, leading the authors to describe asynchronous execution as indispensable. Second, DiscreteRTC improves both latency and task success relative to continuous RTC: the dynamic pick task improves from $H$9 to $W_i=\exp(-\lambda i)$0, which the paper describes as a $W_i=\exp(-\lambda i)$1 relative boost, while dynamic place improves from $W_i=\exp(-\lambda i)$2 to $W_i=\exp(-\lambda i)$3 (Wang et al., 27 Apr 2026).

6. Relation to neighboring RTC formulations and terminology

Within robot policy learning, DiscreteRTC sits alongside other RTC variants that handle overlap between previously committed and newly generated actions. A nearby line of work, "Action-Prior Denoising for Smooth Real-Time Chunking" (Liu et al., 25 May 2026), describes prior RTC practice as "hard" RTC: a binary prefix mask $W_i=\exp(-\lambda i)$4 clamps the first $W_i=\exp(-\lambda i)$5 actions and leaves the suffix fully unconstrained. That work identifies abrupt suffix jumps, high action delta, high jerk, and asynchronous under-modeling as limitations of binary-mask RTC, then proposes Soft RTC with continuous prior weights $W_i=\exp(-\lambda i)$6. On the $W_i=\exp(-\lambda i)$7 released large Kinetix levels, it reports that a short soft window nearly matches hard training-time RTC in overall solve rate $W_i=\exp(-\lambda i)$8, while a medium window reduces high-delay action delta and jerk by $W_i=\exp(-\lambda i)$9 and $50\%$00 relative to hard RTC, with near-naive runtime (Liu et al., 25 May 2026). This suggests a division of labor in the RTC literature: DiscreteRTC removes external inference-time correction by exploiting native unmasking, while Soft RTC refines the binary clamping assumption used in training-time RTC.

The acronym "RTC" is not unique to this robotics context. In discrete-event systems, RTC denotes run-to-completion control, a distinct formalism in which a controller and environment alternate finite sequences of controllable and uncontrollable events under DLTS and LTL semantics (Alrahman et al., 2020). That notion is unrelated to real-time chunking for robot action generation. The name should likewise not be conflated with discrete time crystals, which belong to periodically driven many-body physics and are defined by robust subharmonic response under Floquet evolution (O'Sullivan et al., 2018).

Within its own intended scope, DiscreteRTC is specifically a method for discrete diffusion action heads. The paper’s concluding formulation is explicit: if a policy already has a discrete diffusion action head, then masking the committed prefix and running standard unmasking with early stopping provides a plug-and-play RTC solution without extra correction code, extra fine-tuning, or a special dataset (Wang et al., 27 Apr 2026).