robot-atlas

Manipulation & Learned Policies

Action Chunking (ACT and ALOHA)

Predicting action sequences instead of single steps: the CVAE structure, the chunk-size tradeoff, and temporal ensembling.

Last reviewed 2026-08-08

Behavior cloning fails in closed loop for a precise reason: a policy with per-step error ε on the expert's state distribution can accumulate cost that grows quadratically with episode length, because each mistake carries the robot into states the expert never visited Ross 2011. Over a T-step episode the worst-case cost scales as

O(εT2)behavior cloningO(εT)DAgger\underbrace{O(\varepsilon T^2)}_{\text{behavior cloning}} \qquad \underbrace{O(\varepsilon T)}_{\text{DAgger}}

where the second bound is what DAgger buys by repeatedly relabeling the states the policy actually visits Ross 2011. Action chunking attacks the same bound from a different side: it shrinks the effective horizon. Instead of predicting one action per inference, the policy predicts a sequence of k actions at once, so the number of sequential decisions in an episode drops by a factor of k.

ACT: chunking with a CVAE

Action Chunking with Transformers (ACT), introduced together with the ALOHA bimanual teleoperation hardware, wraps chunking in a conditional variational autoencoder Zhao 2023. During training, an encoder reads the demonstration's action sequence and produces a latent style variable. At test time the policy decodes a chunk conditioned on camera images, joint positions, and the latent clamped to zero.

100
chunk size k
2 s of motion per inference
50 Hz
control rate
~80M
policy parameters
ResNet-18 backbones plus transformer
44%
success at k=100
1% at k=1, same tasks

ACT reference configuration

observations
4 RGB cameras plus joint positions
action space
14-dim continuous, two 7-DoF arms
training objective
L1 reconstruction plus KL on the style latent
test-time latent
z fixed to zero (deterministic decode)
execution
temporal ensembling over overlapping chunks

The chunk-size dial

Chunk size is a real bias/variance dial, not a hyperparameter footnote. On the ALOHA insertion and transfer tasks, ACT measures roughly 1% success at k=1, 44% at k=100, and a decline at k=200 and k=400 as the policy becomes effectively open-loop Zhao 2023. Too small and compounding error returns; too large and the policy stops reacting to the world mid-chunk.

10%20%30%40%50%1100200300400chunk size k1%44%

k = 100: 44% success, 4 decisions per 400-step episode

Solid points are the measured ACT ablation values (1% at k=1, 44% at k=100). The dashed region past k=100 is interpolated: the paper reports a slight decline at k=200 and k=400 without exact numbers.

Note

Chunking does not reduce the per-decision error ε. It reduces the number of decisions, T divided by k, over which that error compounds. The bias you pay is commitment: the world can change inside a chunk, and the policy will not notice until the next inference.

Temporal ensembling and its limits

ACT executes chunks with temporal ensembling: at each timestep, the actions predicted for that step by overlapping chunks are averaged with exponential weights wi=exp(mi)w_i = \exp(-m \cdot i), where i counts how many chunks ago the prediction was issued. This smooths chunk boundaries at the cost of one inference per step instead of one per chunk.

Diagram of temporal ensembling: three overlapping action chunks each contain a prediction for the same action a_t, and exponential weights favor the newest prediction.
Three chunks in flight at time t. Each contains a prediction for the current action; the ensemble averages the predictions with exponential weights that favor the newest chunk. Source: Zhao et al. 2023 (ACT)
temporal_ensembling.py
# Temporal ensembling (ACT, arXiv:2304.13705). preds[i] is the prediction
# for the current action made by the chunk issued i steps ago.
def temporal_ensemble(preds: list[np.ndarray], m: float = 0.01) -> np.ndarray:
    weights = np.exp(-m * np.arange(len(preds)))   # w_i = exp(-m * i)
    weights /= weights.sum()
    return np.tensordot(weights, np.stack(preds), axes=1)

Warning

Temporal ensembling assumes inference is nearly free in wall-clock time. Once inference latency reaches 100 to 200 ms, the newest chunk in the average is always stale by a full round trip, and Physical Intelligence documents the scheme failing outright Physical Intelligence 2025.

Real-Time Chunking (RTC) reframes the hand-off between chunks as an inpainting problem on the flow or diffusion trajectory: actions that will already have executed are frozen, the overlapping middle is partially attended to, and the remainder is generated fresh Black 2025. RTC holds throughput flat out to +200 ms of injected inference delay with no training-time change, which is why later flow-matching policies adopt it over ensembling.

The dial below injects inference delay into both execution strategies. Temporal ensembling holds while inference stays fast, then the averaged action drifts off the committed mode and the strategy fails inside the documented 100 to 200 ms window. RTC freezes the actions that will already have executed and stays on the in-flight mode, so its throughput line does not move Black 2025.

documented TE failure0%25%50%75%100%050100150200240injected delay (ms)temporal ensemblingreal-time chunkingno valid modeleftrightnew chunk arrives081623controller tick

d = 0 ms: temporal ensembling 100% nominal, real-time chunking 100% holding

The curves are a qualitative model of the published results (arXiv:2506.07339): temporal ensembling fails outright at +100 ms and +200 ms of injected delay because the weighted average of disagreeing chunks lands between modes, while real-time chunking holds throughput flat to +200 ms. They are not a re-run of the experiment.

The lineage in numbers

Chunking started as a fix for compounding error and became standard infrastructure. The table sorts the major policies by how far ahead they predict and how fast they run; weights marked open can be downloaded, and the open releases stop at pi0.5. Cells marked n/a are undisclosed or embodiment-dependent, not zero.

Action horizon and control frequency across the policy lineage. n/a marks undisclosed or embodiment-dependent values.
Action representationWeights
RT-1202213256 discrete bins per dimopen
ACT202310050CVAE decoder, continuous k x 14open
Diffusion Policy20231610DDPM over action chunksopen
Octo2024n/an/adiffusion action head (chunked)open
pi020245050flow matching, continuousopen
pi0.520255050flow matching + FAST supervisionopen
pi0.620255050flow matching + FAST tokensclosed
pi0.720265050flow matching, executes 15-25 of 50closed
GR00T N1.7202640n/aflow-matching DiT head, relative EEFopen
Helix 022026n/a200S1 (200 Hz) into S0 (1 kHz) commandsclosed

Where the idea travels next

Mobile ALOHA extends the same recipe to a wheeled whole-body platform and shows that co-training on static ALOHA data lifts mobile manipulation success substantially Fu 2024. Later modules in this domain cover how diffusion policies and flow-matching models generate the chunks themselves, and how vision-language-action models schedule them at high control frequency.