Real-time chunking (RTC) enables vision-language-action models (VLAs) to generate smooth, reactive robot trajectories by asynchronously predicting action chunks and conditioning on previously committed actions via inference-time inpainting. However, this inpainting method introduces computational overhead that increases inference latency. In this work, we propose a simple alternative: simulating inference delay at training time and conditioning on action prefixes directly, eliminating any inference-time overhead. Our method requires no modifications to the model architecture or robot runtime, and can be implemented with only a few additional lines of code. In simulated experiments, we find that training-time RTC outperforms inference-time RTC at higher inference delays. In real-world experiments on box building and espresso making tasks with the \pi_{0.6} VLA, we demonstrate that training-time RTC maintains both task performance and speed parity with inference-time RTC while being computationally cheaper. Our results suggest that training-time action conditioning is a practical drop-in replacement for inference-time inpainting in real-time robot control.

Unlike chatbots or search engines, embodied agents must operate in real time. The feedback loop between an agent's actions and its environment necessitates reactivity — like a human athlete, an agent cannot simply “stop and think” while the outside world changes. However, the ever-increasing size of frontier models makes this more and more difficult. Nowhere is this more evident than in the domain of robot learning, where vision-language-action models (VLAs) consisting of billions of parameters have increasingly been used to control robots at high frequencies to accomplish dexterous tasks. Producing smooth yet reactive trajectories when the model inference latency is in the tens to hundreds of milliseconds is no small challenge.

Real-time chunking (RTC; [5]) presents an approach to this problem that combines action chunking [9, 27], flow matching [13], and inference-time inpainting [18, 21]. In RTC, action chunks are predicted asynchronously — the next chunk is generated while the current one is still executing. To ensure continuity between chunks, each generation is conditioned on a frozen prefix of previously predicted actions, inpainting the rest. However, the inference-time inpainting method used by RTC introduces additional computational overhead — and hence latency — that somewhat defeats the purpose of a real-time execution framework. Empirically, we also find that inference-time inpainting is fundamentally limited in its ability to handle high inference delays.

In this work, we augment RTC with an inpainting method that simulates inference delay at training time and eliminates any inference-time computational overhead. Our method works as a drop-in replacement for inference-time RTC: it requires no modifications to the model architecture or the robot runtime, and can be implemented with only a few additional lines of code. On simulated benchmarks, we find that training-time RTC outperforms inference-time RTC at higher inference delays. In the real world, we demonstrate that training-time RTC can be successfully added by fine-tuning a base model that was not pre-trained with action prefix conditioning. By applying training-time RTC to the \pi_{0.6} VLA [24], we show improved performance over inference-time RTC on two highly complex tasks: box building and espresso making.

Action chunking and VLAs. Action chunking [9, 26] is the de facto standard in end-to-end imitation learning for visuomotor control. Recently, augmenting vision-language models (VLMs) to produce action chunks has demonstrated great success in robot manipulation, giving rise to vision-language-action models (VLAs) [4, 6–8, 10–12, 14, 17, 28, 29]. Subsequently, a plethora of methods have emerged to address the tension between large VLAs and high-frequency control. For example, Gemini Robotics [23] and GR00T [3] employ hierarchical VLA designs where the model is split into a heavyweight System 2 (high-level planning) and lightweight System 1 (low-level action generation) component. MiniVLA [2] and SmolVLA [20] present VLA architectures that are altogether faster and more efficient than most designs, making inference at the edge more feasible. These contributions are orthogonal to ours, and come with their own tradeoffs (e.g., modified network architectures and training recipes).

Real-time execution of VLAs. The most closely related prior work is real-time chunking (RTC; [5]), which introduces an asynchronous execution framework that serves as a foundation for this work. Also related is SmolVLA [20], which presents an asynchronous execution algorithm that is similar to that of RTC; however, SmolVLA does not solve the inter-chunk discontinuity problem, which leads to out-of-distribution “jerks” between chunks. Concurrently to this work, A2C2 [19] and VLASH [22] both solve the discontinuity problem by adding a lightweight correction head and by conditioning on a single future action, respectively. In contrast to VLASH, we condition on a full prefix of future actions.

We use the same problem formulation as RTC [5]: we begin with an action chunking policy denoted by p(\mathbf{A}_t\mid\mathbf{o}_t), where \mathbf{A}_t=[\mathbf{a}_t,\mathbf{a}_{t+1},\dots,\mathbf{a}_{t+H-1}] is a chunk of future actions, \mathbf{o}_t is an observation, and t indicates a controller timestep. We call H the prediction horizon, and at inference time, we roll out each chunk for s\le H timesteps, where s is the execution horizon.