NEW METHOD TO TRAIN ROBOTS: Physical Intelligence is at it again! Not so new actually, but worth mentioning because its impact is still going strong today. Called Real-Time Action Chunking (RTC), it is an inference-time method from Physical Intelligence @physical_int for running flow and diffusion-based vision-language-action models in real time. A few definitions: - Action chunk: a short block of future actions (say the next 50 motor commands) predicted in one shot instead of one step at a time. - Flow matching: a faster cousin of diffusion -> the model learns a straight-line path from noise to the target action trajectory, so it needs only a few integration steps instead of many denoising ones. - Diffusion: a generative method that starts from pure noise and iteratively denoises it into structured output. Here, the output is a trajectory of robot actions rather than an image. - Inpainting: the image-editing trick where a generative model fills in a masked region so it's consistent with the pixels around it. Diffusion and flow models can do this natively. RTC's insight is that a chunk of robot actions can be "inpainted" the same way: freeze the part already committed, generate the rest to match. - Inference-time method: a change to how the trained model is used, not how it's trained: no new data, no fine-tuning, no architecture change. - Closed-loop control: act, observe the result, correct, continuously. The opposite of executing a pre-planned motion blind. "Synchronous closed-loop at 10 Hz" means the robot would have to pause and wait for each new decision, which is exactly the stutter RTC removes. A chunked VLA predicts a block of future actions, then has to compute the next block while still executing the current one. Naively switching to the freshly computed chunk mid-motion results in disaster because the new actions conflict with the trajectory in progress, producing jerks and pauses that aren't in the training data. RTC frames the handoff as an inpainting problem: the actions that will execute before the next inference arrives are frozen to the previous chunk's values, and the model inpaints the remaining actions under partial attention, using the native inpainting ability of flow/diffusion samplers. It requires no training-time changes and runs on existing models (π0, π0.5, π0-FAST), demonstrated on match-striking, Ethernet-cable insertion and clothing folding. The whole method is a reframe: treat real-time control as inpainting. Diffusion and flow VLAs can already inpaint (fill masked outputs conditioned on known ones), so RTC just freezes the actions that will execute before the next inference lands and lets the model inpaint the rest without any training-time changes. That means any existing flow/diffusion VLA gets smooth async execution for free: no new data, no fine-tune, no architecture change. The latency problem is solved entirely at sampling time by borrowing a capability the models already had. Typical remote inference is 108ms (static) to 139ms (mobile) total, including 97ms of model inference. Roughly 100ms per decision is about 10Hz, far too slow for smooth synchronous closed-loop control, so a big VLA physically cannot "stop, think, act" without visible pauses. The evaluation metric is throughput: proportion of substeps completed successfully divided by duration, and the tasks are ones where a mistimed pause is catastrophic. Match-striking needs a continuous stroke, cable insertion needs steady precision, folding needs uninterrupted motion. PI chose tasks where discontinuity ruins the attempt, which is exactly where RTC's benefit is most visible. The metric rewards both success and speed at once.