World Action Models in Real Time:
An Empirical Study of Smooth Execution
via Asynchronous Deployment

2026/08/03

Tech Report GitHub

Overview

World Action Models (WAMs) can take seconds to run inference. When deployed naively, this latency causes the robot to stall at every action chunk boundary, preventing it from responding to changes in the environment in real time. In this work, we systematically evaluate six deployment strategies. Our main findings are:

With proper temporal alignment, simple output-level blending (async+blend) already provides an effective baseline—and forms the foundation for every other fusion method.
Velocity-field guidance (infer) changes only the direction of denoising and therefore cannot guarantee action continuity for WAMs.
Directly modifying the actions (simple) improves smoothness, but introduces a substantial loss of precision in fine-grained manipulation.
Injecting prefix conditioning during training (train) teaches the model to continue actions naturally. It achieves both smoothness and accuracy across dynamic, precision-critical, and long-horizon tasks, outperforming all other strategies on WAMs.

The Problem

Why are WAMs difficult to deploy on real robots?

WAMs use flow matching as their generative backbone. At each inference call, the model produces a fixed-length action sequence—an action chunk—through iterative denoising. Under conventional synchronous execution (sync), the system executes the entire predicted action chunk before starting the next inference call. Because WAM generation has non-negligible end-to-end latency, the robot must pause and wait whenever an action chunk finishes. This creates two problems:

The robot’s motion becomes discontinuous.
The robot cannot react to moving targets or unexpected obstacles in the scene.

The idea behind asynchronous inference (async) is to launch the next inference call early, when the current action chunk reaches frame s, so that computation and execution run in parallel. However, the old and new chunks are predicted from observations captured at different times, so their actions may disagree in the overlapping region. This leads to the central question of asynchronous deployment: how can we preserve both smoothness and accuracy when switching between chunks?

Temporal Structure

Before introducing the individual methods, we first establish a unified description of the timing.

Suppose the next inference call is triggered when chunk n reaches frame s. Let the actual inference delay be d frames. Because d is not known in advance at deployment time, the controller uses an estimate d_est to determine where to switch into the new chunk. The temporal relationship between chunks n and n+1 is illustrated below.

Figure 1. Timing diagrams for synchronous and asynchronous chunk execution. Under asynchronous execution, the new chunk is divided into the delay region (yellow), remaining overlap (green), and non-overlap region (blue).

The new chunk contains three regions:

Table 1. Definitions of the regions within a new chunk.

Choosing the switch point. The controller switches at frame d_est of the new chunk. This frame should correspond to the robot’s current real-time state.

For asynchronous deployment to work correctly, two conditions must be met:

Timestamp-based temporal alignment. Every command frame must correspond to the correct observation time. We achieve this using hardware timestamps. Without alignment, the model receives a temporally mismatched state and generates fundamentally incorrect actions; no smoothing method can reliably repair them afterward.
An accurate delay estimate d_est. We set d_est to the median measured end-to-end latency. This is only a rough approximation, not an exact estimate. If the true latency satisfies d > d_est, the controller switches at the wrong frame, causing an unrecoverable position jump. Accurate online latency estimation remains an open problem.

Approaches

We group the existing approaches into five categories and implement six strategies in total. sync and async are the two basic scheduling modes. On top of async, we evaluate four ways to fuse consecutive chunks, illustrated in Figure 2.

Table 2. Method categories and their core mechanisms.

1. sync: Synchronous execution (baseline)

The controller waits for inference to finish before switching, with no blending. This preserves prediction accuracy, but the robot stalls at every chunk boundary and fails completely on dynamic tasks.

2. async: Pure asynchronous switching

Inference is triggered early. Once the new chunk arrives, the controller switches directly to frame d_est, without any blending. This eliminates the waiting pause but does not resolve disagreement between consecutive chunks. It is also the scheduling foundation for all subsequent fusion methods.

3. async+blend: Asynchronous execution with weighted blending

This method corresponds to the chunk-fusion idea used in the asynchronous inference framework of SmolVLA: A Vision-Language-Action Model for Affordable and Efficient Robotics [1]. After inference finishes, the controller directly blends the overlapping portions of the old and new chunks.

We use the following blending rule:

â(t) = w(t)·aₙ(t) + (1−w(t))·aₙ₊₁(t)

The weight w(t) is 1 throughout the delay region and decays to 0 toward the end of the overlap. This method requires neither model modifications nor retraining. Once temporal alignment is in place, it is the simplest and most direct solution.

4. simple: Weighted blending during denoising

This method is taken from the HoloBrain-0 Technical Report, where it is called SimpleRTC [2]; we refer to it as simple. At every denoising step, actions from the old chunk are blended into the new chunk’s prediction as a constraint, using the same weight schedule as async+blend. This intervention is more aggressive than post-processing and produces stronger smoothing, but it also introduces a trade-off between precision and smoothness.

5. infer: Inference-time RTC

This method comes from Real-Time Execution of Action Chunking Flow Policies [3], and we refer to it as infer. Rather than modifying the actions directly, it modifies the denoising velocity field: at every denoising step, the velocity is pulled toward the old chunk in the delay region. This is theoretically more elegant because it does not forcibly overwrite the prediction. In our WAM experiments, however, it fails to guarantee action continuity.

6. train: Prefix-conditioned training

This method comes from Training-Time Action Conditioning for Efficient Real-Time Chunking [4], and we refer to it as train. During training, the delay region from the old chunk is injected as a clean conditioning signal, teaching the model to continue naturally from a given prefix. Its weight schedule is a step function: the weight is 1 inside the delay region and 0 afterward. In other words, the prefix is strictly constrained, while the rest of the chunk is left for the model to predict freely.

This method requires retraining, but adds no extra inference-time overhead.

Figure 2. Different action-chunk fusion methods under asynchronous scheduling.

Experiments

Offline evaluation

Before deploying on the real robot, we conduct an offline, open-loop evaluation. We sample two observations s frames apart from the training data and feed them into the model separately to obtain two chunks. We then calculate their positional discrepancy in the overlapping region.

We report two error metrics: mean absolute error (MAE), which reflects overall trajectory quality, and maximum absolute error. A single large jump can push the robot into an abnormal state, so maximum error is particularly relevant to task success.

We report four components separately: arm position error in meters, torso position error in meters, head joint-angle error in radians, and gripper error on a scale of 0–100.

Figure 3. Mean absolute error (MAE) for each component as a function of the overlap step. Lower error indicates that the method constrains the actions more strongly.

Figure 4. Maximum absolute error for each component as a function of the overlap step. Lower error indicates that the method constrains the actions more strongly.

Key Findings

infer fails to constrain the delay region. Velocity-field guidance is a soft constraint: it changes the direction of denoising without directly constraining the output actions. Its MAE and maximum error in the delay region are substantially higher than those of simple and train, making jumps at chunk boundaries unavoidable.
Both simple and train reduce delay-region error to nearly zero. Their difference appears in the remaining overlap. The aggressive blending used by simple keeps error low throughout the overlap, while train constrains only the prefix, after which its error grows with the prediction step. This growth is the price it pays for preserving the model’s original predictive accuracy.
The behavior differs clearly inside and outside the delay region. simple and train impose strong constraints within the delay region. Once the trajectory enters the remaining overlap, error gradually accumulates with the prediction horizon, reflecting the increasing disagreement between adjacent chunks over longer-term predictions.

Real-robot evaluation

We evaluate the methods in three representative real-world scenarios using three metrics: completion score, completion time, and jerk. On a real bimanual robot, we run five trials for every method–task combination and average the corresponding metrics.

Table 3. Overview of the three task scenarios.

All videos below are shown at their original speed (1×), without acceleration or slow motion.

Pick Up Conveyor

Block Into Slot

Food Into Microwave

Results and analysis

Figure 5. Completion score, completion time, and jerk for the six methods across the three tasks.

Dynamic task: Pick Up Conveyor

sync scores only 20, which is unsurprising: while the robot is waiting for inference, it cannot track a moving target. async also scores 20. Although it remains responsive, the hard switches between chunks produce extremely high jerk and prevent successful grasping. async+blend reaches a score of 40, showing that temporal alignment plus even the simplest fusion method already improves task completion. train leads with a score of 96, combining responsiveness with smooth motion.

Fine manipulation: Block Into Slot

simple scores only 27.5 on this task. Because insertion requires very high precision, this result demonstrates that aggressive action blending can significantly reduce accuracy. Both sync (72.5) and train (70) retain high precision, but train finishes faster (12.1 s versus 19.4 s) and produces lower jerk.

Long-horizon task: Food Into Microwave

Both train and sync score 96. The key difference is completion time. Pauses at every chunk boundary accumulate, so sync takes 85.2 s, whereas train needs only 68.9 s. Asynchronous methods generally finish within 60–66 s.

Conclusions

With timestamp alignment in place, async+blend is a strong baseline worth considering.
Hardware timestamps establish the correct correspondence between observations and the action chunks produced by the model, and allow different chunks to be aligned with one another. Once this foundation is in place, weighted blending at the output level can significantly reduce jerk without changing the model or the training pipeline. Accurate asynchronous alignment is also a prerequisite for every cross-chunk fusion method.
Velocity-level guidance (infer) cannot guarantee action continuity for WAMs.
We adapt RTC’s velocity-field guidance to world-model deployment. Our experiments show that this soft constraint affects only the denoising direction and does not sufficiently constrain the final actions. Position jumps may therefore remain at chunk boundaries. Both offline analysis and real-robot experiments support this conclusion.
Direct action modification introduces a precision–smoothness trade-off.
simple performs well on the dynamic task, but its score drops substantially on fine manipulation. Directly smoothing the actions can therefore come at the cost of final-task precision.
Injecting a prefix during training performs best across all three task categories, making it the most effective asynchronous fusion strategy for WAMs.
By introducing prefix conditioning during training, train avoids the trade-off above. The model learns to continue naturally from actions that have already been committed, eliminating the need to compromise between precision and smoothness at inference time. It achieves the strongest overall performance across dynamic, fine-manipulation, and long-horizon tasks.

Limitations and Future Work

Responsiveness to abrupt environmental changes. All of the methods studied here assume that the old chunk provides useful guidance. When an unexpected obstacle appears, the new chunk must deviate substantially from the old trajectory. In that situation, the prefix constraint becomes a source of interference rather than useful guidance.

Figure 6. An unexpected-obstacle scenario: the new chunk must deviate from the old trajectory, turning the prefix constraint into interference.

Maintaining smooth motion while remaining sufficiently responsive to abrupt environmental changes is an important direction for future work.

References

[1] Mustafa Shukor, Dana Aubakirova, Francesco Capuano, Pepijn Kooijmans, Steven Palma, Adil Zouitine, Michel Aractingi, Caroline Pascal, Martino Russi, Andres Marafioti, Simon Alibert, Matthieu Cord, Thomas Wolf, and Remi Cadene. SmolVLA: A vision-language-action model for affordable and efficient robotics, 2025
[2] Xuewu Lin, Yun Du, Hongyu Xie, et al. HoloBrain-0 technical report. arXiv:2602.12062, 2026.
[3] Kevin Black, Manuel Y Galliker, and Sergey Levine. Real-time execution of action chunking flow policies. arXiv:2506.07339, 2025.
[4] Kevin Black, Allen Z. Ren, Michael Equi, and Sergey Levine. Training-time action conditioning for efficient real-time chunking, 2025.

Citation

@misc{motubrainteam2026worldactionmodelsreal,
  title={World Action Models in Real Time: An Empirical Study of Smooth Execution via Asynchronous Deployment},
  author={Motubrain Team},
  year={2026},
  eprint={2608.01880},
  archivePrefix={arXiv},
  primaryClass={cs.RO},
  url={https://arxiv.org/abs/2608.01880},
}