[Paper Notes] PACE: Phase-Aware Chunk Execution for Robot Policies with Action Chunking
Published:
This post supports English / 中文 switching via the site language toggle in the top navigation.
TL;DR
PACE treats the execution horizon of an action-chunking robot policy as a test-time decision. The base policy may always predict a fixed-length chunk of (L) actions, while PACE dynamically chooses how many actions (h_i) to execute before observing the scene and querying the policy again. It analyzes the predicted arm-motion speed profile, smooths short-range fluctuations, finds prominent low-speed valleys, and uses the earliest accepted valley as a replanning boundary. The remaining suffix is discarded.
This distinction is the center of the paper: PACE does not dynamically change the policy’s prediction length; it dynamically changes the executed prefix length. Long horizons preserve coherent approach or transport motion. Short horizons add feedback near alignment, contact, grasping, release, and stabilization. PACE is applied after the policy has produced a chunk, requires no retraining or access to policy internals, and was evaluated with the same (\pi_{0.5}) checkpoints as the fixed-horizon baselines.
On 50 RoboTwin2.0 tasks, PACE reaches 64.2% average success, compared with 57.8% for the strongest global fixed horizon. Across three real-robot settings on bimanual ALOHA and single-arm Franka, average full-completion success rises from 50.7% to 70.4%. These results support adaptive replanning timing. They do not establish formal trajectory smoothness: the paper reports task success and selected horizons, without jerk or acceleration-continuity metrics.
Paper Info
“PACE: Phase-Aware Chunk Execution for Robot Policies with Action Chunking” is by Junnan Nie, Jiayi Li, Jiachen Zhang, Junyi Lao, Chenghao Liu, Tianle Zhang, Liang Lin, and Songfang Huang, with affiliations at Peking University and JD Explore Academy. This note covers arXiv:2606.00537v2, revised July 29, 2026. The current release is a 21-page preprint.
1. An Action Chunk Has Two Horizons
Suppose the policy receives observation (o_{\tau_i}) and language instruction (\ell) at its (i)-th query. It predicts
[ A_i=\pi_\theta(o_{\tau_i},\ell) =(a_{i,1},\ldots,a_{i,L})\in\mathbb{R}^{L\times d_a}. ]
The prediction horizon (L) is the number of actions generated by the policy. The execution horizon (h_i) is the number actually sent to the robot before the next query:
[ \tau_{i+1}=\tau_i+h_i, \qquad h_i\in{1,\ldots,L}. ]
These two quantities are easy to conflate.
| Quantity | Meaning | Fixed or dynamic in PACE? |
|---|---|---|
| Prediction horizon (L) | Number of actions output by the policy | Fixed by the trained policy |
| Execution horizon (h_i) | Length of the prefix executed before replanning | Selected dynamically at every query |
| Discarded suffix | Predicted actions after (h_i) | Replaced by the next prediction |
A conventional fixed rule sets (h_i=H) at every query. A small (H) obtains feedback frequently, but can repeatedly interrupt a coherent local motion. A large (H) preserves within-chunk continuity, but commits longer to a prediction made from an old observation. PACE changes this fixed schedule into a chunk-conditioned rule,
[ h_i=g(A_i), ]
where (g) is deterministic and contains no learned component.
2. Why One Fixed Horizon Is Unreliable
The success landscape over (H) is task-dependent and often non-monotonic. In the paper’s sweep over (H=1,\ldots,50), some tasks prefer short intervals, some prefer long intervals, and several have multiple separated high-success regions. For example, Click bell peaks around a short horizon, loses nearly 40 success points around the middle of the range, and rises again near a longer horizon.
This behavior comes from a genuine execution trade-off. Coarse approach and transport can tolerate longer open-loop prefixes. Contact preparation, alignment, grasping, release, and stabilization benefit from a fresh observation. A constant interval ignores this phase structure, even when different phases occur inside a single rollout.
An offline horizon sweep is also a weak deployment solution. The hindsight-best (H) differs across tasks and requires evaluation on the target task. The paper therefore asks a more useful question: can the predicted chunk itself reveal a suitable moment to replan?
3. PACE as a Test-Time Execution Layer
PACE uses kinematic deceleration as a phase-boundary cue. A typical manipulation trajectory contains locally coherent segments separated by slower transitions. Imitation-trained policies often preserve this structure in their predicted chunks.
flowchart TD
A["Observation + instruction"] --> B["Base policy predicts L actions"]
B --> C["Build arm-speed profile"]
C --> D["Smooth short-range fluctuations"]
D --> E["Detect prominent low-speed valleys"]
E --> F{"Accepted boundary?"}
F -->|Yes| G["Choose earliest valley as h_i"]
F -->|No| H["Use maximum allowed horizon"]
G --> I["Execute prefix and discard suffix"]
H --> I
I --> J["Acquire a new observation and replan"]
J --> B
For every executed arm group (b), PACE maps the predicted chunk to a one-dimensional speed profile,
[ v_i^b=\psi_b(A_i), \qquad \widetilde v_i^b=\mathcal S(v_i^b), ]
where (\psi_b) extracts joint-space or Cartesian motion speed and (\mathcal S) smooths the profile. Local low-speed valleys form the candidate set (V_i^b). Each valley (r) receives a prominence score (\Phi_i^b(r)), which tests whether the deceleration stands out from its neighborhood. This avoids replanning at every small fluctuation in an already slow segment.
Accepted candidates from all executed arms are pooled:
[ R_i=\bigcup_{b\in\mathcal B} {r\in V_i^b:\Phi_i^b(r)\geq\delta_T}. ]
The selected horizon is
[ h_i= \begin{cases} \min R_i,&R_i\neq\varnothing,
H_{\max},&R_i=\varnothing. \end{cases} ]
Taking the earliest boundary across arms is conservative in a useful way: a bimanual system replans before either arm crosses a predicted phase transition using stale visual context. If no sufficiently prominent valley appears, PACE preserves a longer coherent segment up to (H_{\max}).
4. Calibration and the Meaning of “Training-Free”
PACE adds no neural network, loss, or policy fine-tuning. It only consumes the predicted action chunk, so it does not require attention maps, confidence scores, denoising states, auxiliary heads, or inference-engine modifications. This is the basis for the paper’s training-free and policy-agnostic descriptions.
There is still a small task-level calibration step. The acceptance threshold (\delta_T) is derived once from training demonstrations. It does not use evaluation rollouts, test success labels, or fixed-horizon sweeps. Candidate valleys also use a minimum temporal spacing (d_{\min}); the sensitivity study controls threshold strictness with a calibration percentile (\rho). The default configuration is (d_{\min}=10), (\rho=5).
The practical interpretation is precise: PACE avoids learning a new model and avoids tuning on test rollouts, while still relying on task demonstrations to set its valley-acceptance scale. “Plug-and-play” here means the base policy remains unchanged; it does not mean completely parameter-free deployment on an unseen task with no calibration data.
5. Does PACE Make Execution Smoother?
PACE can improve motion continuity as observed during deployment. During a coherent approach or transport segment, it preserves a longer prefix and avoids unnecessary policy queries. Near a low-speed transition, it replans when velocity is already small, reducing the visible cost of switching from an old chunk to a newly predicted one. In a successful real ALOHA bowl-stacking rollout, horizons remained long during approach and transport, contracted to 7 actions for contact-sensitive alignment, and expanded to 43 when coherent motion became available again.
The ablation on profile smoothing is also informative. Raw velocity contains short-range oscillations that create false valleys and overly frequent replanning. Smoothing raises success and lengthens the average selected horizon in both joint and Cartesian spaces:
| Profile | Success | Average executed horizon |
|---|---|---|
| Cartesian, raw | 62.2% | 11.3 |
| Cartesian, smoothed | 64.5% | 19.5 |
| Joint, raw | 60.4% | 16.7 |
| Joint, smoothed, default | 64.2% | 24.3 |
The authors use smoothed joint-space speed by default because it nearly matches the best result, matches the policy action space, and avoids forward kinematics at every query.
“Smoother” still needs qualification. PACE does not blend overlapping chunks, minimize jerk, enforce velocity/acceleration continuity, or filter the final commands. Its experiments do not report jerk, acceleration discontinuity, vibration, or tracking-error metrics. For strict smoothness requirements, PACE can be paired with temporal ensembling, cross-chunk blending, low-pass filtering, jerk-constrained trajectory optimization, and a well-tuned low-level controller.
6. Simulation Results
The main simulation study uses 50 bimanual RoboTwin2.0 tasks and one (\pi_{0.5}) checkpoint per task with prediction horizon (L=50). Within a task, every method uses the same checkpoint, observations, and instruction. Only the execution rule changes. Each task-method pair is evaluated over 900 episodes, for 45,000 episodes per method across the benchmark.
| Execution rule | 50-task average success |
|---|---|
| Fixed (H=5) | 48.8% |
| Fixed (H=25) | 57.8% |
| Fixed (H=50) | 53.4% |
| PACE | 64.2% |
The strongest global fixed choice is (H=25). PACE improves it by 6.4 absolute points without changing policy training. It also beats the strongest fixed baseline on all six representative short-, medium-, and long-duration tasks reported in the main table.
One rollout makes the dynamic behavior concrete. On place_shoe, consecutive execution horizons are 32, 14, 37, 25, and 19 steps. Every query still predicts a full 50-action chunk. PACE executes the selected prefix, discards the remaining suffix, and replaces it with a chunk conditioned on the new observation.
The matched-average-horizon diagnostic separates adaptive timing from query frequency. For each representative task, the authors compare PACE with a constant (H) rounded from PACE’s mean executed horizon. PACE wins on all six tasks, by 1.6 to 10.6 points. The average number of queries is similar, so the residual gain points to where replanning happens, not simply how often it happens.
7. Real-Robot Results
The real-robot evaluation includes two RoboChallenge tasks on bimanual ALOHA and a five-object task family on single-arm Franka. Baseline and PACE use the same fine-tuned (\pi_{0.5}) checkpoint within each task.
| Robot and task | Baseline success | PACE success |
|---|---|---|
| ALOHA — stack bowls | 70.0% | 90.0% |
| ALOHA — put pen into pencil case | 10.0% | 33.3% |
| Franka — place object on plate | 72.0% | 88.0% |
| Average | 50.7% | 70.4% |
The two ALOHA tasks use 30 trials per method. The Franka family uses 20 trials for each of five objects, or 100 trials per method. Average task score, which includes partial credit for the RoboChallenge tasks, rises from 60.7 to 77.7.
8. What PACE Can and Cannot Fix
PACE controls feedback timing; it does not repair the base policy’s action distribution. The paper’s failed pencil-case rollout demonstrates this boundary. PACE repeatedly shortens the horizon near insertion and refreshes the plan, yet the left arm never opens the case sufficiently before the right arm moves the pen forward. New observations cannot help when the refreshed chunks still omit the required behavior.
The method also assumes that important decision points appear as low-speed valleys. This works naturally for contact preparation, alignment, grasping, release, and stabilization. It is weaker when a semantic decision occurs at high speed, when a transition has no visible deceleration, or when the predicted speed profile is noisy. Threshold calibration is task-specific, and multi-arm use takes the earliest boundary, which may increase replanning if one arm contains noisy or incidental motion.
Generality remains open. The experiments are broad in task count and include two robot families, but every learned policy comes from the (\pi_{0.5}) family. Evaluation on diffusion policies, other VLAs, action-tokenized policies, and world-action models is future work.
Takeaway
PACE exposes an underappreciated interface in action chunking. A policy answers, “What sequence of actions should follow this observation?” The execution layer must separately answer, “How much of that sequence should the robot trust before looking again?”
The paper’s answer is a compact phase-aware rule: predict a fixed-length chunk, find prominent low-speed valleys, execute up to the earliest accepted boundary, discard the suffix, and replan from a fresh observation. This converts action-chunk execution from a constant clock into an adaptive receding-horizon loop. The gains come from choosing more useful replanning moments, while formal motion smoothness and missing policy capabilities remain separate problems.