Literature
Display
← All papers

REACT: Rolling Denoising and Dual Decoupling for Reactive Robot Control with VLA Models

Houlong Xiong · Zhenqi Qiu · Zechen Wang · Suohang Zhang · Yiyu Ren · Wanting Xu · Hongfei Niu · Chengyang He · Ge Sun · Ran Cheng · Qian Zhu

Preprint posted · CoRL 2026 (accepted) ↗

Robotics12 min text · CondensedOriginal paper ↗
Contents

Overview

A rolling action buffer lets a flow-based VLA refine future actions across observations while retaining a long horizon. This edition retains all original figures, equations, tables, failure examples and ablations. Project page.

Figure 1: Overview of REACT. REACT reformulates flow-based action generation into a receding-horizon rolling denoising process. At each control step, the active horizon is refined conditioned on the latest observation embedding; the oldest refined chunk is executed, while the remaining buffer is shifted forward and replenished with fresh noise. The colored borders track the same action chunk as it is progressively refined across consecutive observations before execution. The right panels summarize throughput and overall performance, showing that REACT reaches the high-input, high-output regime while improving success, reactivity, smoothness, and efficiency.
Figure 1: Overview of REACT. REACT reformulates flow-based action generation into a receding-horizon rolling denoising process. At each control step, the active horizon is refined conditioned on the latest observation embedding; the oldest refined chunk is executed, while the remaining buffer is shifted forward and replenished with fresh noise. The colored borders track the same action chunk as it is progressively refined across consecutive observations before execution. The right panels summarize throughput and overall performance, showing that REACT reaches the high-input, high-output regime while improving success, reactivity, smoothness, and efficiency.

At a glance

REACT combines staggered flow times, persistent future-action blocks, schedule-matched training and asynchronous deployment. It improves the tested success–reactivity trade-off over independently replanned and Async+RTC baselines. Full REACT streams actions faster, while its synchronous variant achieves slightly higher general-task success. Evidence covers one VLA backbone, seven simulation tasks and two real bimanual platforms; it does not establish training-seed robustness or seamless switching between schedules.

1 Introduction

Long action chunks preserve coherent motion but delay new visual feedback; short replanning intervals can repeatedly restart an incomplete contact skill or switch between plausible action modes. REACT evaluates both fresh observations consumed per second and executable actions produced per second. Instead of regenerating a chunk, it maintains one long buffer whose future blocks are gradually denoised under newer observations. A separate scheduler overlaps perception and control; matched staircase training supervises the deployed time-position combinations.

2 Related Work

The method builds on chunked imitation and flow-based VLAs, including π0.5. Acceleration reduces inference cost, asynchronous execution hides it, and training-time RTC conditions new chunks on committed actions; these do not necessarily make their conditioning fresh at execution. Rolling diffusion and Diffusion Forcing provide related staggered-generation ideas. REACT adapts them to a VLM/action-expert stack, where perception and action generation can be separately scheduled. The paper compares particular implementations, not every asynchronous or rolling policy.

3 Methodology

Three components work together: rolling flow refinement, a scheduler that decouples observation processing from action dispatch, and training with the same staircase of flow times.

3.1 Rolling Denoising for Flow-Based VLAs

The flow-matching convention is noise at τ=1 and clean action at τ=0. Partition H=KS actions into K blocks; block k starts each update at τ=(k+1)/K. One full-buffer action-expert pass followed by an Euler step of size 1/K makes the front block executable. Emit its S actions, shift the partially refined remainder left, and append fresh Gaussian tail noise. A block therefore receives K refinements before execution, usually under successive observations. The main setting H=50, K=5, S=10 keeps future context while avoiding independent suffix regeneration. Its continuity is empirically supported, not a formal guarantee that modes cannot change.

Equations 1–3
τj=⌊j/S⌋+1K,j=0,1,…,H−1,\tau_{j}=\frac{\lfloor j/S\rfloor+1}{K},\quad j=0,1,\ldots,H{-}1, (1)
𝐱~(i)=𝐱(i)−1K​𝐯(i).\widetilde{\mathbf{x}}^{(i)}=\mathbf{x}^{(i)}-\frac{1}{K}\,\mathbf{v}^{(i)}. (2)
𝐱(i+1)=[B~1(i),B~2(i),…,B~K−1(i),ϵnew],\mathbf{x}^{(i+1)}=\left[\,\widetilde{B}_{1}^{(i)},\,\widetilde{B}_{2}^{(i)},\,\ldots,\,\widetilde{B}_{K-1}^{(i)},\,\boldsymbol{\epsilon}_{\mathrm{new}}\,\right], (3)

3.2 Dual Decoupling for High-Throughput Deployment

Dual Decoupling separates sensing, VLM encoding, action-expert denoising and execution without changing the trained REACT weights. Select one frame every S camera periods; asynchronous VLM workers publish to a cache ordered by capture time, and each denoising update consumes the freshest completed embedding. Worker count is not GPU count. With adequate effective VLM service rate, input throughput is min(f_camera/S, 1/T_DiT), and output throughput is S times that rate, capped at the camera cadence. At S=10 and a 30 Hz camera, this means 3 selected observations/s and 30 actions/s—not 30 fresh observations/s. Measured embedding age is 233 ms mean, 383 ms at the 95th percentile and 416 ms maximum; asynchronous conditioning remains stale. No out-of-order completion was observed, and timestamp ordering prevents regression to an older cache entry.

Equation 4
Φin=min⁡(fcamS,1TDiT),Φout=min⁡(fcam,STDiT).\Phi_{\mathrm{in}}=\min\!\left(\frac{f_{\mathrm{cam}}}{S},\frac{1}{T_{\mathrm{DiT}}}\right),\qquad\Phi_{\mathrm{out}}=\min\!\left(f_{\mathrm{cam}},\frac{S}{T_{\mathrm{DiT}}}\right). (4)

3.3 Staircase Training for Rolling Denoising

The action expert is retrained for its fixed rolling schedule. Deployment-only dual decoupling is distinct from this change to the training objective.

Staircase training procedure.

For every demonstration chunk, corrupt each block at its deterministic staircase time and predict all flow velocities jointly. The loss covers all K time stages in one forward pass, paired with their deployed positions, rather than sampling a single common time for the entire chunk. This matches the schedule of each rolling update. Training uses demonstration actions and observations; correspondence of time-position pairs alone does not prove equality between the learned rolling state distribution and training samples.

Equation 5
ℒREACT=1K​∑k=0K−11S​D​∑j∈Bk‖vθ(j)−uτj(j)‖2,\mathcal{L}_{\text{REACT}}=\frac{1}{K}\sum_{k=0}^{K-1}\frac{1}{SD}\sum_{j\in B_{k}}\|v_{\theta}^{(j)}-u_{\tau_{j}}^{(j)}\|^{2}, (5)

4 Experiments

Experiments compare success, executed motion smoothness, specialized dynamic behavior and optimization-step efficiency. They also separate rolling denoising from the added asynchronous scheduler.

4.1 Experimental Setup

All variants use π0.5. H50E50 predicts and executes 50 actions; H50E10 executes only 10 from a 50-action model; H10E10 trains and executes a 10-action horizon. Async+Training RTC uses a 10-action interval. REACT and REACT without Dual Decoupling use K=5, S=10. Seven RoboTwin 2.0 tasks receive 50 clean demonstrations each and 100 evaluation rollouts per task/condition. Six real platform-task pairs receive 30 trials each with matched randomized placements. Mean jerk is calculated only on successful episodes, so it compares different successful subsets across methods.

4.2 General Task Results

Without Dual Decoupling, REACT reaches 49.71%/20.86% clean/randomized simulation success and 65.7% real-task success, versus H50E50 at 37.43%/11.43% and 58.7%. Full REACT reaches 44.86%/19.86% and 64.8%, versus Async+RTC at 33.29%/10.57% and 17.7%. Full REACT lowers mean jerk relative to Async+RTC from 2022.2 to 1219.0 in simulation, 284.1 to 90.1 on ARX and 31.6 to 28.6 on Franka. H50E50 remains smoother overall; REACT improves the trade-off rather than every metric. H50E10 and especially H10E10 lose success despite more frequent replanning. Full REACT slightly trails its synchronous variant on these general tasks, consistent with residual cached-observation staleness. Reported two-proportion tests concern rollout sampling, not independent training seeds.

Figure 2: Real-world general manipulation tasks. ARX X5 (top) and Franka R3 (bottom) perform two shared tasks, Bowl Stacking by Size and Bottle Cap Unscrewing, plus robot-specific hanging tasks: Cable Hanging and Keyring Hanging, respectively.
Figure 2: Real-world general manipulation tasks. ARX X5 (top) and Franka R3 (bottom) perform two shared tasks, Bowl Stacking by Size and Bottle Cap Unscrewing, plus robot-specific hanging tasks: Cable Hanging and Keyring Hanging, respectively.
Table 1: Simulation results on RoboTwin 2.0 benchmark. Success rate (%) under clean and randomized settings. Best in bold, second best underlined.
π0.5\pi_{0.5} H50E50 π0.5\pi_{0.5} H50E10 π0.5\pi_{0.5} H10E10 Async+RTC REACT w/o DD REACT
Task Clean Rand Clean Rand Clean Rand Clean Rand Clean Rand Clean Rand
beat_block_hammer 17 1 8 0 0 0 13 4 15 2 14 4
click_bell 61 6 71 18 35 0 64 8 89 32 61 22
move_playingcard_away 59 26 71 13 7 1 64 11 71 25 66 22
pick_diverse_bottles 20 3 9 0 0 1 10 6 27 9 33 6
press_stapler 58 23 22 3 9 4 37 13 67 42 63 39
rotate_qrcode 30 3 21 3 4 1 12 8 52 6 46 11
turn_switch 17 18 34 24 21 10 33 24 27 30 31 35
Average 37.43 11.43 33.71 8.71 10.86 2.43 33.29 10.57 49.71 20.86 44.86 19.86
Table 2: Real-world results on general manipulation tasks. Success rate (%) across ARX X5 and Franka platforms. Best in bold, second best underlined.
Robot Task π 0.5 \pi_{0.5} H50E50 π 0.5 \pi_{0.5} H50E10 π 0.5 \pi_{0.5} H10E10 Async+RTC REACT w/o DD REACT ARX X5 Bowl Stacking by Size 73 66 70 36 86 76 Bottle Cap Unscrewing 36 0 0 0 56 47 Cable Hanging 56 66 56 3 63 80 ARX X5 Avg. 55.0 44.0 42.0 13.0 68.3 67.7 Franka Bowl Stacking by Size 60 50 0 47 66 63 Bottle Cap Unscrewing 57 0 0 3 63 70 Keyring Hanging 70 33 0 17 60 53 Franka Avg. 62.3 27.8 0.0 22.3 63.0 62.0 Overall Avg. 58.7 35.9 21.0 17.7 65.7 64.8
Original figure
Figure 3: Trajectory smoothness comparison. Mean jerk norm averaged over successful episodes in simulation, ARX X5, and Franka settings. Demos (GT) applies the same metric to the imitation-learning demonstrations as a reference. Full per-task values are reported in Appendix D.

4.3 Specialized Task Results

Pour Rice requires stopping a continuous pour at the target level. Full REACT succeeds in 63% of trials, versus 57% without decoupling, 3% for H50E50 and 0% for Async+RTC. Reaction Game measures stimulus-to-keypress latency: full REACT is 734±94 ms, Async+RTC 747±123 ms, the synchronous REACT variant 754±127 ms, and human teleoperation 705±73 ms. The 13 ms difference from Async+RTC is small relative to reported variability and is not shown statistically significant. Full REACT is 29 ms above the human mean under the shared apparatus; this is not a direct measurement of model computation time. Main text/caption calls the response a mouse click, whereas the detailed apparatus specifies a keyboard keypress.

Figure 4: Specialized dynamic closed-loop control tasks. (a) Pour Rice requires the robot to pour rice into a vessel and stop at the target state, testing whether the policy can react to continuously changing flow while maintaining smooth motion. (b) Reaction Game requires the robot to click the mouse when the on-screen signal turns green, directly measuring visual-to-motor reaction latency.
(a) Pour Rice on ARX X5 (b) Reaction Game on Franka R3
Table 3: Specialized task results. Pour Rice reports success rate (%) (higher is better). Reaction Game reports mean ±\pm standard deviation latency in milliseconds (lower is better).
Task Metric π0.5\pi_{0.5} H50E50 π0.5\pi_{0.5} H50E10 π0.5\pi_{0.5} H10E10 Async+RTC REACT w/o DD REACT Human Avg.
Pour Rice (ARX X5) Success (%) ↑\uparrow 3 33 0 0 57 63 –
Reaction Game (Franka R3) Latency (ms) ↓\downarrow 1505 ±\pm 502 768 ±\pm 113 772 ±\pm 119 747 ±\pm 123 754 ±\pm 127 734 ±\pm 94 705 ±\pm 73

4.4 Training Efficiency Analysis

On Click Bell, Move Playing Card Away and Press Stapler, REACT reaches 52.7% average success at 3,000 updates versus 25.0% for π0.5, and matches the baseline’s 30,000-update performance after 15,000 updates. Training-loss curves and closed-loop success support efficiency measured in optimization steps. Shading denotes the range across tasks, not independent-seed uncertainty. The compared training objectives differ; lower loss and fewer steps do not establish proportional wall-clock or energy savings.

Original figure

(a) Training loss over optimization steps

Original figure

(b) Success vs. training steps

Figure 5: Training efficiency test. (a) Training loss over optimization steps. (b) Average closed-loop success rate as a function of training steps; shaded bands show the task-wise range.

5 Conclusion

Persistent future actions refined across observations can preserve useful temporal context while permitting more frequent correction. The results motivate measuring observation consumption, action dispatch, task success and motion quality together, alongside raw inference latency.

6 Limitations

Validation uses only π0.5; other dual-system VLAs and video-action models remain proposed extensions. Each policy is trained for one fixed (K,S) schedule, with no evaluated zero-shot schedule switching. The authors suggest choosing S for the reaction/compute budget and a large K within the pretrained horizon, but schedule-conditioned adaptive control is future work. No independent training seeds were run. Success remains limited on randomized simulation, and asynchronous embedding age, rollout-conditioned jerk comparisons and small latency differences constrain broader claims.

Appendix A Failure Case Analysis

Failure examples distinguish three mechanisms. H50E50 stays smooth but can continue pouring or reaching toward an obsolete target. H50E10 may execute the approach without completing grasp–twist–release, repeatedly revisit the same contact state, or resample inconsistent intents; it has zero bottle-opening success on both robots. H10E10 additionally loses long-horizon training context and has zero success on all three Franka general tasks, so its Franka jerk is undefined. Async+RTC hides computation but still predicts from delayed state and stitches chunks; it spills rice and has high ARX jerk. Figures 6–8 retain the qualitative sequences. These examples support the authors’ interpretation, but they do not isolate action-mode switching as the sole causal explanation for every failure.

Figure 6: Over-pouring under long open-loop execution in Pour Rice. Consecutive frames from the H50E50 baseline show the policy continuing the pouring motion even after the rice level exceeds the target mark, illustrating how stale open-loop execution can overshoot the target state before the next observation update.
Figure 6: Over-pouring under long open-loop execution in Pour Rice. Consecutive frames from the H50E50 baseline show the policy continuing the pouring motion even after the rice level exceeds the target mark, illustrating how stale open-loop execution can overshoot the target state before the next observation update.
Figure 7: Trajectory response in Bowl Stacking by Size when the bowl is suddenly moved during grasping. Left: the original π0.5\pi_{0.5} full-chunk policy reacts slowly because it continues executing a stale action chunk. Middle: the shortened action-chunk baseline updates more frequently but produces discontinuous stop-and-replan motion. Right: REACT w/o DD adapts to the moved bowl while maintaining a smoother approach trajectory.
Figure 7: Trajectory response in Bowl Stacking by Size when the bowl is suddenly moved during grasping. Left: the original π 0.5 \pi_{0.5} full-chunk policy reacts slowly because it continues executing a stale action chunk.
Middle: the shortened action-chunk baseline updates more frequently but produces discontinuous stop-and-replan motion.
Right: REACT w/o DD adapts to the moved bowl while maintaining a smoother approach trajectory.
Refer to caption
Figure 8: Repeated cap-contact retries under shortened execution in Bottle Cap Unscrewing. Representative frames from the H50E10 baseline show the policy repeatedly returning to the cap-contact region instead of sustaining the continuous grasp–twist–release sequence required to open the bottle.

Appendix B Throughput Comparison

Throughput is counted at the policy interface: selected fresh observations consumed and executable actions dispatched. H is the prediction horizon, H_e the execution horizon, and inference cost is VLM encoding plus N action-expert steps. A high action rate can coexist with infrequent observation updates.

B.1 Qualitative Analysis

Synchronous inference adds computation time to H_e/f_control; asynchronous inference uses the larger of those times. Speeding inference helps only until execution becomes the asynchronous bottleneck. Synchronous REACT replaces N denoising steps with one per update, but still serializes VLM, DiT and S-action execution. Full REACT removes those waits through independent streams. Its rate formulas require the effective VLM pool and DiT to sustain the selected frame stream. For colocated workers, effective service rate must be measured rather than assuming worker count gives linear GPU speedup. Smaller S raises the demanded observation-processing rate.

Equations 6–15
Tcyclesync\displaystyle T_{\text{cycle}}^{\text{sync}} =TVLM+N⋅TDiT+Hefctrl,\displaystyle=T_{\text{VLM}}+N\cdot T_{\text{DiT}}+\frac{H_{e}}{f_{\text{ctrl}}}, (6)
Φinsync\displaystyle\Phi_{\text{in}}^{\text{sync}} =1Tcyclesync,Φoutsync=HeTcyclesync.\displaystyle=\frac{1}{T_{\text{cycle}}^{\text{sync}}},\qquad\Phi_{\text{out}}^{\text{sync}}=\frac{H_{e}}{T_{\text{cycle}}^{\text{sync}}}. (7)
Tcycleasync\displaystyle T_{\text{cycle}}^{\text{async}} =max⁡(TVLM+N⋅TDiT,Hefctrl),\displaystyle=\max\left(T_{\text{VLM}}+N\cdot T_{\text{DiT}},\;\frac{H_{e}}{f_{\text{ctrl}}}\right), (8)
Φinasync\displaystyle\Phi_{\text{in}}^{\text{async}} =1Tcycleasync,Φoutasync=HeTcycleasync.\displaystyle=\frac{1}{T_{\text{cycle}}^{\text{async}}},\qquad\Phi_{\text{out}}^{\text{async}}=\frac{H_{e}}{T_{\text{cycle}}^{\text{async}}}. (9)
Tcycleaccel\displaystyle T_{\text{cycle}}^{\text{accel}} =α⋅Tinfer+Hefctrl,\displaystyle=\alpha\cdot T_{\text{infer}}+\frac{H_{e}}{f_{\text{ctrl}}}, (10)
Φinaccel\displaystyle\Phi_{\text{in}}^{\text{accel}} =1Tcycleaccel,Φoutaccel=HeTcycleaccel.\displaystyle=\frac{1}{T_{\text{cycle}}^{\text{accel}}},\qquad\Phi_{\text{out}}^{\text{accel}}=\frac{H_{e}}{T_{\text{cycle}}^{\text{accel}}}. (11)
TcycleREACT-w/o-DD\displaystyle T_{\text{cycle}}^{\text{REACT-w/o-DD}} =TVLM+TDiT+Sfctrl,\displaystyle=T_{\text{VLM}}+T_{\text{DiT}}+\frac{S}{f_{\text{ctrl}}}, (12)
ΦinREACT-w/o-DD\displaystyle\Phi_{\text{in}}^{\text{REACT-w/o-DD}} =1TcycleREACT-w/o-DD,ΦoutREACT-w/o-DD=STcycleREACT-w/o-DD.\displaystyle=\frac{1}{T_{\text{cycle}}^{\text{REACT-w/o-DD}}},\qquad\Phi_{\text{out}}^{\text{REACT-w/o-DD}}=\frac{S}{T_{\text{cycle}}^{\text{REACT-w/o-DD}}}. (13)
ΦinREACT\displaystyle\Phi_{\text{in}}^{\text{REACT}} =min⁡(fcamS,1TDiT),\displaystyle=\min\left(\frac{f_{\text{cam}}}{S},\;\frac{1}{T_{\text{DiT}}}\right), (14)
ΦoutREACT\displaystyle\Phi_{\text{out}}^{\text{REACT}} =min⁡(fcam,STDiT).\displaystyle=\min\left(f_{\text{cam}},\;\frac{S}{T_{\text{DiT}}}\right). (15)
Figure 9: Dual Decoupling timing diagram. Sensing, VLM encoding, DiT denoising, and action execution run as separate streams. The scheduler selects observations every ΔS=S/fcam\Delta_{S}=S/f_{\mathrm{cam}} from the camera stream, and parallel VLM workers encode them into a latest-ready embedding cache; each update consumes the freshest completed embedding and the rolling action buffer, then commits the next SS executable actions. The architecture removes both the execution wait and the VLM wait from the DiT critical path: camera-rate input occurs in the S=1S=1 setting, while output action throughput reaches the camera cadence whenever the VLM pool and DiT keep up.
Figure 9: Dual Decoupling timing diagram. Sensing, VLM encoding, DiT denoising, and action execution run as separate streams. The scheduler selects observations every Δ S = S / f cam \Delta_{S}=S/f_{\mathrm{cam}} from the camera stream, and parallel VLM workers encode them into a latest-ready embedding cache; each update consumes the freshest completed embedding and the rolling action buffer, then commits the next S S executable actions. The architecture removes both the execution wait and the VLM wait from the DiT critical path: camera-rate input occurs in the S = 1 S=1 setting, while output action throughput reaches the camera cadence whenever the VLM pool and DiT keep up.

B.2 Summary of Throughput Formulas

The original formula table retains synchronous, accelerated, asynchronous and both REACT variants. Full REACT’s camera-rate output is conditional on provisioned perception and denoising throughput; input remains camera rate divided by block length.

Table 4: Throughput formulas for different inference schemes. Tinfer=TVLM+N⋅TDiTT_{\text{infer}}=T_{\text{VLM}}+N\cdot T_{\text{DiT}}.
Method Φin\Phi_{\text{in}} (obs/sec) Φout\Phi_{\text{out}} (act/sec)
Synchronous 1Tinfer+He/fctrl\dfrac{1}{T_{\text{infer}}+H_{e}/f_{\text{ctrl}}} HeTinfer+He/fctrl\dfrac{H_{e}}{T_{\text{infer}}+H_{e}/f_{\text{ctrl}}}
Sync + Accel (α\alpha) 1α​Tinfer+He/fctrl\dfrac{1}{\alpha T_{\text{infer}}+H_{e}/f_{\text{ctrl}}} Heα​Tinfer+He/fctrl\dfrac{H_{e}}{\alpha T_{\text{infer}}+H_{e}/f_{\text{ctrl}}}
Asynchronous 1max⁡(Tinfer,He/fctrl)\dfrac{1}{\max(T_{\text{infer}},H_{e}/f_{\text{ctrl}})} Hemax⁡(Tinfer,He/fctrl)\dfrac{H_{e}}{\max(T_{\text{infer}},H_{e}/f_{\text{ctrl}})}
REACT w/o DD 1TVLM+TDiT+S/fctrl\dfrac{1}{T_{\text{VLM}}+T_{\text{DiT}}+S/f_{\text{ctrl}}} STVLM+TDiT+S/fctrl\dfrac{S}{T_{\text{VLM}}+T_{\text{DiT}}+S/f_{\text{ctrl}}}
REACT min⁡(fcamS,1TDiT)\min\left(\frac{f_{\text{cam}}}{S},\frac{1}{T_{\text{DiT}}}\right), if RVLM≥fcam/SR_{\text{VLM}}\!\geq\!f_{\text{cam}}/S min⁡(fcam,STDiT)\min\left(f_{\text{cam}},\frac{S}{T_{\text{DiT}}}\right)

B.3 Comparison with Typical Values

Reference measurements on a compiled RTX 4090 give VLM≈37 ms and DiT≈3 ms per step; ten-step π0.5 therefore costs about 67 ms. With H_e=50 and 30 Hz control, synchronous input is only 0.58 Hz although output is 28.8 Hz; halving inference time barely changes input to 0.59 Hz. At H_e=10, synchronous rates are 2.50/25.0 Hz and asynchronous rates 3.00/30.0 Hz. Synchronous REACT with S=10 reaches about 2.68/26.8 Hz; full REACT reaches 3/30 Hz under the stated service conditions. These schedule calculations do not measure closed-loop reaction latency or guarantee each cached embedding is current.

Table 5: Throughput comparison based on π0.5\pi_{0.5} (H=50H{=}50, fcam=30f_{\text{cam}}{=}30 Hz, fctrl=30f_{\text{ctrl}}{=}30 Hz, TVLM=37T_{\text{VLM}}{=}37 ms, TDiT=3T_{\text{DiT}}{=}3 ms, N=10N{=}10).
Method HeH_{e} or SS TcycleT_{\text{cycle}} (ms) Φin\Phi_{\text{in}} (Hz) Φout\Phi_{\text{out}} (Hz)
Synchronous He=50H_{e}{=}50 17341734 0.580.58 28.828.8
Synchronous He=25H_{e}{=}25 900900 1.111.11 27.827.8
Synchronous He=10H_{e}{=}10 400400 2.502.50 25.025.0
Synchronous He=5H_{e}{=}5 234234 4.284.28 21.421.4
Sync + Accel (α=0.5\alpha{=}0.5) He=50H_{e}{=}50 17001700 0.590.59 29.429.4
Sync + Accel (α=0.5\alpha{=}0.5) He=25H_{e}{=}25 867867 1.151.15 28.828.8
Sync + Accel (α=0.5\alpha{=}0.5) He=10H_{e}{=}10 367367 2.732.73 27.327.3
Sync + Accel (α=0.5\alpha{=}0.5) He=5H_{e}{=}5 200200 5.005.00 25.025.0
Asynchronous He=50H_{e}{=}50 16671667 0.600.60 30.030.0
Asynchronous He=25H_{e}{=}25 833833 1.201.20 30.030.0
Asynchronous He=10H_{e}{=}10 333333 3.003.00 30.030.0
Asynchronous He=5H_{e}{=}5 167167 6.006.00 30.030.0
REACT w/o DD (K=10K{=}10) S=5S{=}5 207207 4.844.84 24.224.2
REACT w/o DD (K=5K{=}5) S=10S{=}10 373373 2.682.68 26.826.8
REACT (main) S=10S{=}10 — 3.03.0 30.030.0
REACT (faster input) S=5S{=}5 — 6.06.0 30.030.0
REACT (upper bound) S=1S{=}1 — 30.030.0 30.030.0

Throughputs are computed from unrounded cycle times; TcycleT_{\text{cycle}} is rounded to the nearest millisecond for display. For full REACT, TcycleT_{\text{cycle}} is not listed because the serialized inference–execution cycle is removed; after the one-time warm-up, the steady-state update period is S/fcamS/f_{\text{cam}}.

Appendix C Implementation Details

Implementation details specify the robots, shared model family, training hyperparameters, initialization, scheduling assumptions and evaluation metrics.

C.1 Hardware Platforms

ARX X5 has two six-joint arms with parallel grippers; dual Franka Research 3 has two seven-joint arms with grippers and Cartesian impedance control. Both use front and two wrist RGB cameras and 30 Hz commands. Every evaluated deployment uses one 24 GB RTX 4090. Full REACT colocates two asynchronous VLM workers with the action expert; at the main 3 Hz selected-frame rate, the cited single-worker capacity is already sufficient. Multi-GPU deployment is supported conceptually but is not needed for the reported main configuration.

Figure 10: Hardware platforms. Representative views of the Acone/ARX X5 bimanual platform and the Franka Research 3 dual-arm platform used in the real-robot evaluation.
(a) Acone/ARX X5 (b) Franka R3

C.2 Model Architecture

π0.5 combines a PaliGemma-3B VLM/SigLIP vision encoder with a 300-million-parameter action expert. Standard baselines use ten flow steps per generated chunk; REACT uses one per rolling update and five accumulated refinements per emitted block in the main setting. ARX actions contain 12 arm-joint and two gripper coordinates; Franka actions contain two position-plus-6D-rotation poses and two gripper coordinates, totaling 20 dimensions. Main experiments use H=50; Appendix E also evaluates shorter horizons when KS<50.

C.3 Training Configuration

Training uses AdamW, peak/final learning rates 2.5×10⁻⁵/2.5×10⁻⁶, cosine decay with a 10% warm-up, weight decay 10⁻¹⁰, gradient clipping at 1 and bfloat16. Simulation uses batch size 32 for 30,000 updates; robot training uses 20 epochs, with batch 128 on ARX and 256 on Franka except 32 for Reaction Game. The complete source table retains optimizer moments and numerical settings.

Table 6: Training hyperparameters used for simulation and real-robot policies.
Hyperparameter Value
Peak learning rate 2.5×10−52.5\times 10^{-5}
Final decay learning rate 2.5×10−62.5\times 10^{-6}
LR scheduler Cosine decay with linear warmup
Warmup fraction 10%10\% of the total training schedule
Optimizer AdamW
AdamW β1\beta_{1} 0.9
AdamW β2\beta_{2} 0.95
AdamW ϵ\epsilon 1×10−81\times 10^{-8}
Weight decay 1×10−101\times 10^{-10}
Simulation batch size 32
Simulation training length 30,000 optimization steps
Real-robot training length 20 epochs
Acone/ARX X5 batch size 128
Franka R3 batch size 256 for all real-robot tasks except Reaction Game; 32 for Reaction Game
Gradient clipping 1.0
Mixed precision bfloat16

C.4 Inference Configuration

Initialize each block by interpolating the reset-state action with Gaussian noise at its staircase time. Run K−1 rolling updates using the initial observation while holding the robot at its reset or safe pose; discard those front blocks. The next block has traversed all K stages, after which steady-state streaming begins. This one-time warm-up is excluded from evaluated emitted actions. Table 7 reports synchronous update latency of 66.04 ms for standard π0.5 and 39.96 ms for REACT without decoupling, a 1.65× speedup; those numbers are separate from end-to-end reaction latency.

Equation
Bk(0)=(1−τk)𝐬¯0+τkϵk,ϵk∼𝒩(𝟎,𝐈),k=0,…,K−1.B_{k}^{(0)}=(1-\tau_{k})\bar{\mathbf{s}}_{0}+\tau_{k}\boldsymbol{\epsilon}_{k},\qquad\boldsymbol{\epsilon}_{k}\sim\mathcal{N}(\mathbf{0},\mathbf{I}),\quad k=0,\ldots,K{-}1.
Table 7: Real-robot per-update inference latency. Mean synchronous policy-update latency measured with torch.compile enabled.
Policy Latency (ms) ↓\downarrow Speedup Notes
Standard π0.5\pi_{0.5} 66.04 1.00×\times VLM embedding + 10 denoising steps.
REACT w/o DD 39.96 1.65×\times VLM embedding + single denoising step.

C.5 Train-Inference Consistency

The consistency argument is a schedule invariant: advancing every block by 1/K, removing the clean front and shifting the rest returns the same staircase of time-position pairs; fresh tail noise occupies τ=1. Every query therefore uses a supervised pair. A block traverses all K stages across updates. This proves the grid alignment, not that changing observations or model-generated intermediate actions have the same distribution as corrupted demonstrations, nor a guarantee of closed-loop stability.

C.6 Benchmarks and Evaluation Protocol

The seven simulated tasks are hammering a block, clicking a bell, moving a playing card, picking diverse bottles, pressing a stapler, rotating a QR code and turning a switch. Train on demo_clean and evaluate clean plus randomized conditions, 100 rollouts each. Both real platforms perform size-ordered bowl stacking and bottle-cap unscrewing; ARX adds cable hanging and Franka keyring hanging. Each platform-task pair has 30 trials with shared randomized placements across methods. These are selected tasks rather than the full 50-task benchmark.

C.7 Evaluation Metrics

Success is completed trials divided by attempts. Smoothness is the average Euclidean norm of joint jerk, estimated by repeated central differences and averaged over successful episodes only; failed trajectories are not represented in that metric. Reaction Game uses one monotonic-clock script: record the green frame’s commitment to the display buffer, then an operating-system keyboard event when the gripper presses a designated key. The same monitor, keyboard and teleoperated robot provide the human comparison. Shared hardware controls common delays, but subtracting human mean latency does not separately identify every policy-induced delay. Pour Rice reports task success.

Appendix D Full Trajectory Smoothness Results

All per-task jerk values are retained, including undefined entries when no episode succeeds. Demonstration averages are 570.1 in simulation, 41.9 on ARX and 15.3 on Franka. Full-horizon H50E50 is closest overall, while full REACT substantially improves over Async+RTC. Because each policy contributes its own successful subset, low jerk should be interpreted jointly with success rate rather than as an unconditional motion-quality ranking.

Table 8: Full trajectory smoothness results. Mean jerk norm of executed joint trajectories for each task and platform; lower indicates smoother motion. Best in bold, second best underlined.
Setting Task π0.5\pi_{0.5} H50E50 π0.5\pi_{0.5} H50E10 π0.5\pi_{0.5} H10E10 Async+RTC REACT w/o DD REACT
Simulation beat_block_hammer 463.4 996.7 – 1755.0 664.0 775.9
click_bell 502.4 1087.2 1341.8 1946.4 690.8 712.0
move_playingcard_away 814.3 2012.7 1784.5 1832.2 1165.8 1341.8
pick_diverse_bottles 857.7 1391.2 – 1688.0 1253.4 1621.8
press_stapler 567.9 1295.5 1425.7 3168.2 1136.4 1204.7
rotate_qrcode 965.5 1663.9 1638.8 1944.5 1296.1 1422.3
turn_switch 441.1 1798.8 1153.1 1821.2 1246.7 1454.3
Simulation Avg. 658.9 1463.7 1468.8 2022.2 1064.7 1219.0
ARX X5 Bowl Stacking by Size 55.3 76.8 78.5 189.3 70.9 80.3
Bottle Cap Unscrewing 53.7 – – – 69.4 87.3
Cable Hanging 68.9 95.4 95.0 378.8 87.6 102.7
ARX X5 Avg. 59.3 86.1 86.8 284.1 76.0 90.1
Franka Bowl Stacking by Size 15.1 27.3 – 28.5 24.3 27.6
Bottle Cap Unscrewing 28.1 – – 34.2 29.8 30.4
Keyring Hanging 12.1 29.7 – 32.0 25.5 27.7
Franka Avg. 18.4 28.5 – 31.6 26.5 28.6

Appendix E Ablation Studies

The evaluated grid restricts KS≤50 to retain the released checkpoint’s horizon; larger-horizon retraining is outside scope. The authors use S=10,K=5 throughout the main experiments, the best aggregate clean result and best or tied on six of seven tasks. At S=10, success rises from 13.6% with K=1 to 49.7% with K=5; at K=5, it rises from 6.3% with S=1 to 49.7% with S=10. Smaller blocks increase nominal observation rate but can reduce useful action context. Changing K or S also changes total horizon KS in much of this grid, so refinement count, temporal context and responsiveness are not fully isolated. K=10,S=5 provides more refinements but scores 33.1%; the recommended main configuration is empirical, not a universal optimum. The seven per-task heatmaps retain all evaluated cells, hatched exclusions and the shared color scale.

Figure 11: Ablation on block length and block count. Mean RoboTwin clean success rate for each S×KS{\times}K configuration; hatched cells indicate configurations not evaluated.
Figure 11: Ablation on block length and block count. Mean RoboTwin clean success rate for each S × K S{\times}K configuration; hatched cells indicate configurations not evaluated.
Figure 12: Per-task ablation heatmaps. Success rate for each of the seven RoboTwin tasks as a function of block length SS and block count KK. Hatched cells indicate configurations not evaluated. The color scale is shared across all panels (0–100%).
Figure 12: Per-task ablation heatmaps. Success rate for each of the seven RoboTwin tasks as a function of block length S S and block count K K . Hatched cells indicate configurations not evaluated. The color scale is shared across all panels (0–100%).

Appendix F OOD Dataset Action Prediction Open-Loop MSE

Final-checkpoint open-loop prediction on three randomized-data tasks reduces mean action MSE from 0.272 to 0.048, an 82.4% relative decrease. Task values are 0.312→0.058 for Click Bell, 0.244→0.020 for Move Playing Card Away and 0.259→0.067 for Press Stapler. The two full action-trace panels show one representative playing-card example. These are offline prediction diagnostics, distinct from closed-loop completion or training-seed robustness.

Original figure
Figure 13: OOD open-loop action prediction. Open-loop action-prediction MSE on the demo_randomized OOD dataset for three representative RoboTwin tasks.
Figure 14: Qualitative open-loop predictions on Move Playing Card Away. Two visualizations of the same demo_randomized example show how the predicted action sequence compares with the demonstration trajectory under the baseline and REACT.
(a) Baseline comparison (b) REACT comparison
Concept demonstration

Open image ↗