PYTHON · NUMPY

Action Chunking and the Two Systems

Show why predicting a short horizon of actions from one observation tracks a moving goal better than a purely reactive policy, the idea behind pi-0 and Figure's Helix.

01Challenge

A reactive policy only sees the target every few steps and lags behind it. Give the chunked policy a velocity estimate so it rolls actions forward between observations, and it tracks the moving goal instead of chasing a stale one.

Predict firstA policy that sees the target only every few steps lags behind a moving goal. What lets a chunked policy TRACK it instead of chasing it?

02Model

The best manipulation policies do not decide one action at a time. Diffusion-policy and pi-0 style models predict a chunk, a short sequence of future actions, from a single observation, and Figure's Helix splits the job into two systems: a slow vision-language model that reasons about the task and a fast policy that emits smooth, high-rate motion. Both moves solve the same problem you meet here. Observations are expensive and arrive slowly, so a policy that only reacts to the latest frame lags a moving target. A policy that predicts where things are going and acts open-loop for a few steps stays locked on. You are building the intuition that action chunking buys smoothness and beats latency.

03Guided practice

1. See the lag. The reactive policy chases seen, sampled only every H steps. 2. Estimate velocity. In the chunk block, set vhat = (tgt[t] - last) / H (the two-observation velocity). 3. Roll forward. vhat is added every step, so the policy predicts between observations. 4. Confirm. Chunked mean error should be under half the reactive error.

04Feedback

PASS WHEN PASS when the chunked policy's mean tracking error is less than half the reactive policy's: prediction beats reaction under latency.

If your run fails, check:

No improvement: `vhat` is still 0. Estimate it as `(tgt[t] - last) / H` at each observation.
Worse than reactive: make sure `last` is updated to `tgt[t]` inside the observation block, after computing vhat.
Marginal: confirm `vhat` is added every step (`pos += 0.6*(seen-pos) + vhat`), not only at observations.

05Retrieve & space

What is action chunking, and what problem does it solve? (predict a horizon; beat observation latency).
What are the two systems in a Helix-style policy? (a slow VLM reasoner and a fast motion policy).
Why does predicting velocity help track a moving goal between observations?

06Mastery & project

Show that predicting a short action horizon tracks a moving goal better than reacting step by step: the chunking behind modern policies.

The control-frequency insight that lets a slow reasoning model still drive smooth, real-time humanoid motion.

← The Bridge, Not From Scratch Dance: Style and the Beat →

PYTHON · NUMPY

Action Chunking and the Two Systems

Track a moving target with a reactive vs a chunked policy under sparse observations.

You read

the arrays and values already in scope

You change

the code you write in each cell

Fixed

the dataset and the checks that grade you