Real-Time Robot Execution with Masked Action Chunking

AI summary

Overview

Research area: Robotics / Vision-Language-Action (VLA) policies — specifically real-time execution of action-chunking policies under asynchronous inference.

Technical level: Advanced. The paper assumes familiarity with flow-matching generative policies, action chunking, vision-language-action models, LoRA finetuning, and cyber-physical control latency.

Scope: The paper identifies and addresses intra-chunk inconsistency in asynchronous robot execution, proposing a training-time adaptation (REMAC) that makes pretrained chunking policies resilient to the perception–action mismatch caused by inference delay, evaluated on 12 simulated tasks and three real-world tasks.

What This Paper Is About

Robots running VLA models cannot predict actions fast enough to keep up with their control loops, so asynchronous inference predicts the next action chunk while the current one executes. The authors observe that this setup fails in a way prior work overlooked: the early actions the robot actually executes come from an old chunk conditioned on an old observation, creating a mismatch between what the robot perceives and what it is doing (intra-chunk inconsistency). The goal is to teach the pretrained policy to correct for this mismatch without adding any inference latency.

Key Contributions

1. Identification of intra-chunk inconsistency. The paper names and formalizes a failure mode distinct from the widely studied inter-chunk discontinuity: under inference delay d with execution horizon h, the first d executed actions are inherited from the previous chunk A_{t-h}, conditioned on o_{t-h} rather than o_t, producing a perception–action mismatch inside a single chunk.

2. REMAC (Real-time Execution with Masked Action Chunking). A training-time method that learns corrective adjustments to a pretrained policy through three components: delay-conditioned prefix masking, a self-conditioned curriculum, and residual alignment. It targets the train–test mismatch rather than applying test-time smoothing.

3. Prefix-preserved sampling. A modified sampling pipeline in which the initial action state is initialized from previously executed/predicted actions and the already-committed overlapping prefix is preserved during integration, reinforcing inter-chunk continuity.

4. A latency-free, composable method. REMAC introduces no additional inference delay compared to the pretrained policy, uses LoRA (at most 1.5% additional parameters relative to the original model), can be merged into the backbone, and can be combined with existing test-time methods (BID, RTC) and with non-flow-matching architectures such as ACT.

Main Findings

Asynchronous inference degrades with delay. Across all evaluated methods in the Kinetix simulation, performance declines as inference delay increases, which the authors attribute to growing action–observation mismatch (intra-chunk inconsistency) and greater influence of the previous chunk (inter-chunk discontinuity).

Full REMAC achieves the highest simulated success rates. Averaged over execution horizons, the complete method reaches 0.888 at d=0, 0.879 at d=1, 0.859 at d=2, 0.817 at d=3, and 0.779 at d=4, compared with Naive Async at 0.828, 0.702, 0.639, 0.525, and 0.451.

Each added component improves results, and LoRA alone does not. Naive Async with LoRA alone is 0.825, 0.710, 0.630, 0.510, 0.428 — essentially unchanged or slightly worse. Adding prefix masking gives 0.863, 0.825, 0.752, 0.729, 0.636; adding the self-conditioned curriculum gives 0.848, 0.837, 0.805, 0.762, 0.710; adding the residual alignment term (L_Delta) yields the final 0.888, 0.879, 0.859, 0.817, 0.779.

The method also helps at zero delay. The authors attribute the improvement at d=0 to masked action chunking encouraging stronger coherence and temporal dependencies even with no inference delay.

Composition with test-time methods gives small additional gains. Starting from REMAC (0.888, 0.879, 0.859, 0.817, 0.779), adding BID yields 0.888, 0.880, 0.862, 0.821, 0.781, and adding RTC yields 0.888, 0.879, 0.864, 0.826, 0.791 — larger improvements at higher delays.

Curriculum schedule beats both extremes. Comparing the piecewise-linear self-conditioned schedule against pure ground-truth inputs (σ=1) and pure self-conditioned inputs (σ=0), the curriculum improves both performance and training stability; pure ground truth suffers exposure bias, while pure self-conditioning destabilizes early learning.

Hyperparameter sensitivity is low. Ablating q_max and q_min changes performance only marginally; larger values, particularly a larger q_min, produce slightly worse results. The paper uses q_max = 4 and q_min = 0.

Real-world completion progress improves on all three tasks. On Grasp-Easy, Grasp-Medium, and Grasp-Hard, REMAC scores 0.903, 0.943, and 0.812, versus Synchronous 0.805, 0.718, 0.670; Naive Async 0.825, 0.825, 0.460; Temporal Ensembling 0.825, 0.868, 0.717; and RTC 0.823, 0.848, 0.753.

Robustness under injected delay. With additional latency injections of 75 ms and 150 ms (total inference delays of 3–5), REMAC consistently outperforms all baselines. Naive Async performs comparatively better under larger delays (which the authors link to longer execution horizons and less frequent chunk switching), while RTC degrades significantly because its test-time adjustments become counterproductive.

Qualitative behavior. Synchronous inference produces frequent pauses, often causing unintended object drops and inaccurate localization. Naive Async and Temporal Ensembling remain prone to premature or delayed grasping and placement. RTC suffers from the additional inference latency it introduces. Under a 150 ms injected delay, REMAC shows smoother kinematics and faster completion.

Temporal Ensembling is excluded from simulation comparison. Both this work and Black et al. (2025) find TE substantially underperforms the other baselines in the Kinetix benchmark, even falling behind Naive Async.

Methodology in Plain English

The starting point is a pretrained flow-matching policy that predicts a chunk of P future actions from the current observation; the robot executes only the first h of them. The authors finetune this policy into a delay-aware version with LoRA, then merge the LoRA weights back so nothing is added at run time.

Three training changes do the work. First, prefix masking: because asynchronous execution means the first d actions of a chunk are already inherited from the previous chunk, supervision during training is restricted to the not-yet-committed portion of the chunk using a mask m_d = 1[τ ≥ d], with d sampled uniformly from 0 to P-1. This matches the loss to what the robot can actually still control. Second, a self-conditioned curriculum: instead of interpolating only between noise and ground-truth actions, the training input mixes in the pretrained policy's own prediction, with a Bernoulli parameter σ annealed from 1 (pure ground truth) to 0 (pure self-conditioned), so the model gradually learns to correct its own outputs rather than only clean targets. Third, residual alignment: an extra loss term explicitly pushes the induced correction to match the residual between the pretrained backbone's prediction and the ground truth.

At sampling time, the initial action state is no longer Gaussian noise but is seeded with the recently executed/predicted actions, and the overlapping prefix is preserved while only the remaining portion is regenerated by integrating the learned velocity field. A special case handles the very first chunk, where there is no prior and standard integration is used.

For training, d is drawn from a gradually shrinking interval [q, q_max] where q anneals from q_max down to q_min; the authors stress these are perturbation-strength hyperparameters, not limits on the delays the model can handle. Loss weights are λ_m = 0.01 and λ_Δ = 0.01.

In simulation, the authors follow the protocol of deliberately segmenting and concatenating predicted actions according to predefined delays and execution horizons. In the real world, actions are predicted on a remote server and transmitted to the robot over gRPC, with the robot and server each maintaining queues, and the inference delay estimated client-side as the maximum of the most recent measured delays.

Why This Matters

Impact on research. The paper reframes asynchronous inference failure: rather than treating chunk boundaries as the problem to be smoothed at test time, it points at the mismatch inside a chunk and fixes it during training. That shifts the design space toward training-time adaptation that costs nothing at inference, and it positions such policies as stronger backbones onto which test-time methods can be stacked.

Real-world applications:

• Warehouse and logistics picking, where a robot must keep moving while a large VLA model runs on a remote server.
• Household and service manipulation of small, delicate objects (the real-world tasks include a Rubik's cube only 1 cm narrower than the gripper jaw gap).
• Manufacturing or lab automation requiring fine-grained control under fixed control frequencies where model latency exceeds the control period.
• Any teleoperation or cloud-hosted robot fleet where network transmission delay varies with deployment conditions.

Industry relevance. The method is explicitly designed to avoid new latency: LoRA adds at most 1.5% parameters, merges into the backbone, and requires no separate policy per delay value. Deployment uses a client-server split with gRPC and delay estimation on the robot side, matching how commercial robot fleets are likely to host large models remotely. The measured real-world delay budget — 76–80 ms of VLA processing on a remote server, 34–40 ms of LAN communication, and 10–20 ms of data processing and disk writing, totaling 122–140 ms against a 67 ms control period — is a realistic picture of why synchronous inference cannot hold.

Future Directions

• Extending beyond flow matching. The paper reports integration into the Transformer-based ACT framework in Sec. E.5, where REMAC beats both Naive Async and LoRA-only baselines. Broader evaluation across other action-chunking architectures and larger VLA backbones is a natural next step.
• Handling delay beyond the trained range. The authors distinguish training hyperparameters q_max and q_min from the range of delays the model can handle, but the paper does not report the limits of that generalization; characterizing behavior under delays outside the training distribution remains open.
• Combining training-time and test-time adaptation more tightly. Integration with BID and RTC yields only modest gains in the reported results, so how to jointly design these two families of methods is unresolved.
• Delay estimation quality. Real-world deployment estimates delay as the maximum of recent measurements; the paper does not report sensitivity to errors in that estimate, which matters for variable networks and shared servers.

Target Audience

Robotics researchers and engineers working on real-time VLA deployment, asynchronous inference, and action-chunking policies; practitioners building cloud-hosted or remotely served robot control stacks; and readers interested in training-time adaptation techniques (masking, self-conditioning, residual learning, LoRA) applied to generative control policies. Readers without background in flow matching or visuomotor policy learning will find the system-level framing accessible, but the methodology section requires prior familiarity with these models.

Authors’ abstract

Real-time execution is essential for cyber-physical systems such as robots. These systems operate in dynamic real-world environments where even small delays can undermine responsiveness and compromise performance. Asynchronous inference has recently emerged as a system-level paradigm for real-time robot manipulation, enabling the next action chunk to be predicted while the current one is being executed. While this approach achieves real-time responsiveness, naive integration often results in execution failure. Previous methods attributed this failure to inter-chunk discontinuity and developed test-time algorithms to smooth chunk boundaries. In contrast, we identify another critical yet overlooked factor: intra-chunk inconsistency, where the robot's executed action chunk partially misaligns with its current perception. To address this, we propose REMAC, which learns corrective adjustments on the pretrained policy through masked action chunking, enabling the policy to remain resilient under mismatches between intended actions and actual execution during asynchronous inference. In addition, we introduce a prefix-preserved sampling procedure to reinforce inter-chunk continuity. Overall, our method delivers more reliable policies without incurring additional latency. Extensive experiments in both simulation and real-world settings demonstrate that our method enables faster task execution, maintains robustness across varying delays, and consistently achieves higher completion rates.