acceptodds
Under review as a conference paper at ICLR 2027

When to Switch: Reliable Action-Chunk Extension for Vision-Language-Action Models

Abstract

Vision-Language-Action (VLA) models serve as unified policies for robotic manipulation, yet their expensive inference forces robots to pause between policy calls, resulting in stop-and-go execution that interrupts smooth motion and prolongs task completion. Extending the action chunk reduces policy calls and hence these pauses, but predicting farther into the future makes long-chunk execution unreliable. To understand where this unreliability arises, we analyze action errors within long chunks and find that they concentrate around transitions between manipulation subskills, growing sharply with chunk length. This suggests the importance of transition timing, i.e., when to switch subskills within a chunk. Motivated by this observation, we introduce RACE (Reliable Action-Chunk Extension), a framework that predicts the transition timing from an auxiliary one-step denoising pass and conditions action generation on it. By learning and conditioning on transition timing, RACE reduces errors at subskill transitions and enables reliable execution of longer action chunks. Across simulation benchmarks, RACE outperforms fine-tuning at the same chunk length; with 2× longer chunks, it surpasses recent state-of-the-art and efficient VLAs in success rate, and with 4× longer chunks, it remains competitive. On a real robot, RACE uses 4× longer chunks, which reduces the idle time caused by stop-and-go execution by about 5×, while achieving a higher success rate than fine-tuning with the same chunk length. Code and a real-robot demo are available at https://anonymous.4open.science/r/RACE-FC70.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Vision-Language-Action Model, Action Chunk, Manipulation, Robotics

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_Hg7gOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

This paper proposes RACE, a method for improving the reliability of long action chunks in vision-language-action (VLA) models by explicitly modeling subskill transition timing. It uses automatic change-point detection to generate transition pseudo-labels and incorporates a transition prior into action generation through an auxiliary denoising pass and token-wise modulation. The method is evaluated primarily on π0.5\pi_{0.5}, with results suggesting improved task success rates compared with standard fine-tuning at comparable chunk lengths and competitive performance with longer chunks. Real-robot experiments further demonstrate its potential to improve execution reliability while reducing idle time relative to shorter-chunk baselines. However, the evidence for reduced transition errors and improved long-horizon reliability remains limited, and the additional computational overhead and generalizability to other VLA architectures require further investigation.

Critical strengths
  • Valuable research perspective: The paper identifies subskill transition timing within action chunks as a potentially important factor affecting the reliability of long-chunk action prediction.
  • Intuitive method design: The method uses automatic change-point detection to generate transition labels and then leverages a transition prior to guide action generation.
  • Clear writing and presentation: The paper is well organized, and the figures are generally clear and informative.
Critical weaknesses
  1. Insufficient experimental evidence for the core motivation. The paper argues that action errors are concentrated around subskill transitions. However, the reduction in transition error reported in Figure 4 appears modest, providing insufficient evidence that the proposed method substantially improves action prediction at transition points.

  2. Insufficient long-horizon evaluation. Although π0.5\pi_{0.5} supports predictions of up to 50 steps, the experiments primarily focus on shorter execution horizons (e.g., 10 or 20 steps). This is insufficient to establish whether the method effectively mitigates error accumulation in long action chunks.

  3. Potentially misleading claims regarding inference speedup. The speedup appears to come primarily from increasing the action chunk length rather than from RACE itself. Moreover, the additional transition-timing prediction and denoising pass introduce computational overhead. The paper should therefore emphasize improvements in action quality rather than inference speedup.

  4. Lack of adaptive action chunk length selection. The transition prior only guides action generation; it does not dynamically adjust chunk length or determine when to switch chunks based on predicted subskill transitions. Consequently, the method does not explicitly balance execution efficiency and action accuracy through adaptive chunking.

  5. Unclear reliability of transition-timing predictions. The transition labels are generated through automatic change-point detection, which may itself be inaccurate. The paper lacks sufficient quantitative evaluation and qualitative visualizations to establish the reliability of the predicted transition timings.

  6. Lack of cross-model validation. The experiments use π0.5\pi_{0.5} as the sole backbone, leaving the generalizability of the method to other VLA architectures and action-generation mechanisms unclear.

Questions for authors
  • How accurate is the transition-timing prediction? How do prediction errors, missed transitions, and temporal misalignment affect the final performance?
  • Can the method consistently reduce action errors around transition points over longer execution horizons? Are the improvements statistically significant, and can the authors provide more comprehensive qualitative analyses?
  • How sensitive is the method to the transition loss coefficient and pseudo-label quality? What is the additional training overhead compared with standard fine-tuning?
  • Can the method be extended to other VLA frameworks? Which types of VLA architectures are suitable or unsuitable for this approach?
11 comments
AuthorsOpenReview ↗

Response to Reviewer Hg7g(1/8): W1

We thank Reviewer Hg7g for the constructive feedback and for recognizing the value of our perspective on transition timing, the intuitive design of our method, and the clear writing and presentation. We address each concern and question below. Table, figure, section, and line numbers below refer to the revised version.


W1. Error reduction at transitions.

Thank you for raising this important point. In Fig. 4, the reduction may appear modest because the errors at early positions are small for both models. The reduction is larger near the end of the chunk, where the errors at transitions are the largest. To make this clearer, we quantify the reduction on VLABench training demonstrations with Hexec=20H_{\text{exec}}=20 and 1010. As in Fig. 4, we compare errors at transitions with those of non-transition actions at the same chunk position. We report the errors over all positions (All) and over the early, middle, and late positions within the chunk.

Results with Hexec=20H_{\text{exec}}=20.

ActionsModelAll0–9 (early)10–14 (middle)15–19 (late)
Transitionsπ0.5\pi_{0.5} fine-tuning1.7940.5601.5284.764
TransitionsRACE (ours)1.4520.5231.2393.702
TransitionsReduction0.3420.0370.2891.062
Non-transitionsπ0.5\pi_{0.5} fine-tuning0.9720.3951.2761.850
Non-transitionsRACE (ours)0.8260.3101.0501.666
Non-transitionsReduction0.1460.0850.2270.184
Transitions − Non-transitionsReduction gap0.196−0.0480.0620.878

Results with Hexec=10H_{\text{exec}}=10.

ActionsModelAll0–3 (early)4–6 (middle)7–9 (late)
Transitionsπ0.5\pi_{0.5} fine-tuning1.2220.2561.1762.541
TransitionsRACE (ours)0.8170.2510.7421.643
TransitionsReduction0.4050.0050.4340.898
Non-transitionsπ0.5\pi_{0.5} fine-tuning0.9120.1770.8751.917
Non-transitionsRACE (ours)0.6660.1290.3341.732
Non-transitionsReduction0.2460.0480.5410.185
Transitions − Non-transitionsReduction gap0.159−0.043−0.1070.713

RACE reduces the errors at transitions over all positions, and this reduction is statistically significant at both lengths (see our response to Q2). The reduction at transitions is also larger than that at non-transitions; their difference (i.e., reduction gap) is 0.196 at Hexec=20H_{\text{exec}}=20 and 0.159 at Hexec=10H_{\text{exec}}=10 (All). At both lengths, the gap is largest at the late positions (0.878 and 0.713), which are the least reliable part of a long chunk, since their actions are predicted farthest ahead in open loop. Accordingly, RACE achieves a higher success rate than fine-tuning at both lengths (33.0 vs. 28.1 and 34.4 vs. 32.2; Tab. 1).

As complementary evidence on held-out demonstrations, we measure when the generated gripper command switches (Tab. 31 in Appendix D.4). At Hexec=20H_{\text{exec}}=20, RACE switches within ±1 step of the demonstrated step more often than the fine-tuned π0.5\pi_{0.5} (91.5% vs. 86.9%). It also misses fewer switches (3.9% vs. 6.3%).

We have added these results to Appendix D.6 of the revised version (Tab. 33; highlighted in red).


AuthorsOpenReview ↗

Response to Reviewer Hg7g(2/8): W2


W2. Evaluation with longer action chunks.

Thank you for the suggestion. As suggested, we evaluate chunks longer than Hexec=20H_{\text{exec}}=20 and report the results below.

(1) Results beyond Hexec=20H_{\text{exec}}=20. We compare RACE with the fine-tuned π0.5\pi_{0.5} at Hexec=30H_{\text{exec}}=30 and 4040 on VLABench. The results of RACE are from Tab. 11 (Appendix B.2), and those of the fine-tuned π0.5\pi_{0.5} are newly added. We report the average success rate, with Hexec=20H_{\text{exec}}=20 from Tab. 1 for reference.

HexecH_{\text{exec}}π0.5\pi_{0.5} fine-tuningRACE (ours)Gain
2028.133.0+4.9
3026.128.5+2.4
4023.824.0+0.2

RACE achieves a higher success rate than the fine-tuned π0.5\pi_{0.5} up to Hexec=30H_{\text{exec}}=30. However, the gain becomes smaller as the chunk grows, and the two models are comparable at Hexec=40H_{\text{exec}}=40. Thus, RACE makes longer chunks more reliable up to a moderate length, but not at very long ones.

(2) Why the gain becomes small at Hexec=40H_{\text{exec}}=40. To understand this, we analyze the action errors at Hexec=40H_{\text{exec}}=40 by position within the chunk, as in W1.

ActionsModelAll0–910–1415–1920–2425–2930–3435–39
Transitionsπ0.5\pi_{0.5} fine-tuning4.5721.0922.4842.9533.0133.1717.49619.421
TransitionsRACE (ours)3.0441.0041.8231.7971.6121.2304.72415.001
TransitionsReduction1.5290.0880.6611.1561.4001.9412.7724.420
Non-transitionsπ0.5\pi_{0.5} fine-tuning1.7570.6561.4361.6741.8302.0202.5852.993
Non-transitionsRACE (ours)1.0440.5401.1191.1611.0191.3491.3200.934
Non-transitionsReduction0.7130.1170.3170.5130.8110.6711.2652.060
Transitions − Non-transitionsReduction gap0.816−0.0290.3440.6430.5891.2701.5072.360

RACE reduces the errors in every position range, even at Hexec=40H_{\text{exec}}=40. However, the errors at transitions grow sharply over the last ten positions for both models. At positions 35–39, the error of RACE (15.001) is about four times its largest error at Hexec=20H_{\text{exec}}=20 (3.702; W1). This observation is in line with our analysis in Sec. 4.4 (Fig. 4). Errors grow with the prediction horizon, and transitions add further difficulty on top. RACE reduces the errors at transitions, but it cannot fully compensate for the errors that grow with the chunk length (Appendix B.2). We believe that this is why the two models achieve comparable success rates at Hexec=40H_{\text{exec}}=40.

The gain returns when only the first 20 of the 40 predicted actions are executed. Below, the same models predict H=40H=40 actions and execute either all of them or only the first 20 (Tab. 14 in Appendix B.4).

HHHexecH_{\text{exec}}π0.5\pi_{0.5} fine-tuningRACE (ours)Gain
404023.824.0+0.2
402031.235.2+4.0

In this setting, the last positions are not executed and the policy also replans more often, so both may contribute to the gain.

(Continued in the next comment: (3) chunk length of 50 and (4) why we focus on Hexec=20H_{\text{exec}}=20.)


AuthorsOpenReview ↗

Response to Reviewer Hg7g(3/8): W2 (continued)


W2. Evaluation with longer action chunks (continued).

(3) Chunk length of 50. As the reviewer notes, π0.5\pi_{0.5} can predict up to 50 actions. However, the official checkpoints for LIBERO and VLABench are trained with H=10H=10 and execute only the first 5 actions (Sec. 4.1). Without additional training, the official checkpoint fails when run with H=50H=50 (0.4% success rate). To examine this setting, we train both π0.5\pi_{0.5} and RACE on VLABench to predict H=50H=50 actions and execute all of them, with the same training setup as in our main experiments (Sec. 4.1).

ModelHHHexecH_{\text{exec}}Avg. SR
π0.5\pi_{0.5} baseline10524.6
π0.5\pi_{0.5} trained with H=50H=50505015.8
RACE trained with H=50H=50505016.2

Both models fall far below the baseline at this length, and they are comparable, as at Hexec=40H_{\text{exec}}=40. This is in line with (1) and (2): the gain of RACE becomes smaller as the chunk grows and disappears at very long chunks.

(4) Why we focus on Hexec=20H_{\text{exec}}=20. The main goal of extending the chunk is to remove stop-and-go execution while keeping the execution reliable. Hexec=20H_{\text{exec}}=20, four times the execution length of the official checkpoints, already meets this goal. On our real robot, it removes all pauses after the first policy call (Appendix D.5), and the gain of RACE over fine-tuning is largest at this length (Fig. 5b). An even longer chunk has no pauses left to remove on our robot. It only lowers the success rate of RACE, from 33.0 at Hexec=20H_{\text{exec}}=20 to 28.5 at 30 and 24.0 at 40, since the errors at the end of the chunk grow sharply, as shown in (2).

In summary, RACE does not remove all errors of long-horizon prediction; at very long chunks, the errors that grow with the chunk length remain large. By reducing the errors at transitions, however, it makes chunk extension reliable up to the length needed in practice (i.e., Hexec=20H_{\text{exec}}=20), which already removes stop-and-go execution on our robot.

We have added the results in (1) to Appendix B.2 (Tab. 11) and the error analysis in (2) to Appendix D.6 (Tab. 34) of the revised version (highlighted in red). We have also revised Sec. 4.4 and extended Fig. 5b to Hexec=40H_{\text{exec}}=40, and discuss the smaller gain with very long chunks in Appendix F.1 (Limitations) of the revised version (highlighted in red).


Reviewer_SisyOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes RACE, a framework that predicts VLA's subskill transition timing through an extra auxiliary denoising step and conditions action chunk generation on the predicted timing. Such transition-timing-conditioned action chunking further reduces errors around the transition and improves task success at each chunk length, thus enabling reliable longer action chunk execution. Empirical results show that RACE consistently outperforms fine-tuning at the same chunk length on benchmarks, demonstrating higher success than state-of-the-art VLAs and efficient VLA approaches.

Critical strengths

The proposed method is a cheap but effective addition to flow-matching VLAs. It adds one denoising step and a small head, with negligible latency and modest training time, while beating fine-tuning with the same recipe at every chunk length on three benchmarks and two additional backbones, with evident margins above the baselines.

Critical weaknesses
  1. The transition timing prior is slightly oversold. The labels are pseudo-labels from change-point detection, with precision of 0.820.82 and recall of 0.700.70 against the generator’s true subskill boundaries. Moreover, the head that predicts them during inference localizes held-out transitions with a relatively low rate, as shown in Table 23. Hence, the action expert is conditioned on a rough guess of a rough label. Adding the head and its loss without conditioning already lifts success substantially, and zeroing the prior during inference accounts for only a small part of the gain. Therefore, the method works mainly as an auxiliary training loss, and the transition-conditioning story is overstated.
  2. The adaptive-chunking comparison is not conducted under matched conditions. AutoHorizon and PACE operate on the original short chunks, limiting them to at most 10 actions per execution, and in practice they execute nearly all 10. In contrast, RACE is retrained to predict and execute chunks twice as long. This confounds the benefits of adaptive execution with those of increasing chunk length. A more meaningful comparison would apply adaptive execution to both the long-chunk fine-tuned baselines and RACE. Similarly, the real-robot reduction in idle time seems to come primarily from longer chunks rather than RACE's proposed mechanism, since fine-tuning with the same chunk length achieves a comparable reduction.
Questions for authors
  1. What do AutoHorizon and PACE reach when applied to the Hexec=20H_{\text{exec}} = 20 fine-tuned and RACE models, and are their thresholds configured for the 10-step chunk they run on?
  2. A training-free prior would isolate what the learned head adds. What if the change-point detector runs on the one-step coarse estimate At0+vtaux\mathbf{A}_t^0 + \mathbf{v}_t^{\text{aux}}, or on a first full-pass chunk, and RACE is conditioned on that instead?
  3. Please discuss the progress-score gap to ACoT-VLA in Table 1, and report RACE’s progress score at H=40H = 40, Hexec=20H_{\text{exec}} = 20 against ACoT-VLA at 20.
  4. Can the real-robot evaluation be extended to a second task or more trials? One task with 50 trials per method is a thin basis for the headline real-robot claim.
7 comments
AuthorsOpenReview ↗

Response to Reviewer Sisy(1/4): W1

We thank Reviewer Sisy for the constructive feedback and for recognizing RACE as a cheap but effective addition to flow-matching VLAs, with low overhead and consistent gains over fine-tuning across benchmarks and backbones. We address each concern and question below. Table, figure, section, and line numbers below refer to the revised version.


W1. Contribution of transition-timing conditioning.

Thank you for the insightful comment. Our results indicate that conditioning also contributes to the gain of RACE, even with an imperfect prior.

(1) Isolating the effect of transition-timing conditioning. First, we examine the effect of conditioning when the timing loss does not train the action expert. For this experiment, we stop the gradients of the timing loss at the head input, so that this loss trains only the head and not the action expert. This removes the direct gradient of the timing loss from the action expert, while keeping the conditioning. The table below extends Tab. 4 with this variant (VLABench, Hexec=20H_{\text{exec}}=20, without Laux\mathcal{L}_{\mathrm{aux}} as in Tab. 4 of the main manuscript).

Timing loss on the action expertConditioningAvg. SR
--28.1
✓-30.6
- (stop-gradient)✓31.1
✓✓32.4

Each component alone improves the success rate over fine-tuning, by a similar amount. Thus, conditioning contributes to the gain even without the timing loss on the action expert. As the reviewer notes, the timing loss alone also accounts for a large part of the gain, and combining the two achieves the highest success rate.

(2) Role of the prior at inference. The small drop with the zero prior (Tab. 6) does not mean that conditioning contributes little. Replacing the prior with zeros at inference does not undo what the model has learned with conditioning during training. It thus measures how much the trained model relies on the prior at inference. The effect of conditioning in both training and inference is measured in (1): with the timing loss kept and without Laux\mathcal{L}_{\mathrm{aux}}, adding conditioning improves the success rate from 30.6 to 32.4.

Moreover, the trained model uses the prior at inference (Tab. 29 in Appendix D.3). When we shift only the prior and keep the observation, noise, and model weights fixed, the generated gripper switch moves in the same direction. On held-out chunks with one demonstrated gripper switch, replacing the predicted prior with zeros increases the missed switches from 4.1% to 15.6%.

(3) Effect of an imperfect prior. Although the predicted prior is imperfect, it still helps RACE. (i) The predicted transitions are mostly accurate, although some transitions are missed. On held-out demonstrations at Hexec=20H_{\text{exec}}=20, 80.9% of the predicted transitions lie within one step of the PELT labels, and 94.1% within three steps (Tab. 27 in Appendix D.1). As the reviewer notes, the recall is lower: the head captures about half of the transitions on held-out demonstrations (50.0% within one step). Thus, the prior is incomplete, but the transitions it predicts are mostly accurate. (ii) Even the imperfect prior reduces the action error at transitions. We compare RACE under the zero, predicted, and oracle (PELT labels) priors at inference. Since the oracle prior requires the demonstrated actions, we measure the action error on 300 VLABench training demonstrations instead of the success rate (Hexec=20H_{\text{exec}}=20).

Prior at inferenceError at transitions ↓Error at non-transitions ↓
Zero prior1.7020.872
Predicted prior (ours)1.4520.826
Oracle prior (PELT labels)1.1040.770

The predicted prior lowers the error at transitions compared with the zero prior, even though it misses some transitions. The oracle prior lowers it further, so conditioning becomes more effective as the prior becomes more accurate.

We have added the stop-gradient variant in (1) to Tab. 4 and the prior comparison in (3) to Appendix D.7 of the revised version (Tab. 36). We have also revised the description of Tab. 4 to clarify the contributions of timing supervision and conditioning (all highlighted in red).


AuthorsOpenReview ↗

Response to Reviewer Sisy(2/4): W2


W2. Matched comparison with adaptive chunking, and the source of idle-time reduction.

Thank you for the constructive suggestion and feedback. We address each point below.

(1) Adaptive chunking under matched chunk lengths. We agree that a comparison at the same chunk length is more informative. As suggested, we apply AutoHorizon [A] and PACE [B] to both fine-tuning and RACE on VLABench, where both models predict H=20H=20 actions. The adaptive method decides how many of these actions to execute, and we report the average executed length (Avg. HexecH_{\text{exec}}).

MethodAvg. HexecH_{\text{exec}}SpeedupSuccess rate
π0.5\pi_{0.5} fine-tuning203.82×28.1
π0.5\pi_{0.5} fine-tuning + AutoHorizon [A]14.13.06×30.4
π0.5\pi_{0.5} fine-tuning + PACE [B]12.22.81×30.9
RACE (ours)203.68×33.0
RACE + AutoHorizon [A]11.72.56×36.3
RACE + PACE [B]12.22.68×36.0

With and without adaptive chunking, RACE achieves a higher success rate than fine-tuning. With PACE, both models execute the same average length (12.2), and RACE still achieves a higher success rate (36.0 vs. 30.9). RACE alone even outperforms fine-tuning with adaptive chunking, while requiring fewer policy calls. Adding adaptive chunking further improves RACE, showing that the two approaches are complementary. However, this gain requires more policy calls, as adaptive chunking executes only about 12 of the 20 actions per chunk.

In the original submission, we applied the adaptive methods to the official π0.5\pi_{0.5} checkpoint with H=10H=10, following their original papers (Tab. 1, Tab. 2, and Tab. 10). The table above removes this difference in the predicted chunk length.

We have added these results to Sec. 4.2 of the revised version (Tab. 3; highlighted in red).

(2) Hyperparameter configuration of adaptive chunking methods (Q1). Following their original papers, we apply both methods to the official π0.5\pi_{0.5} with 10-step chunks. Since their thresholds are set for LIBERO in the original papers, we calibrate them for each benchmark. For each method, we run the policy from the initial states of the training demonstrations with several candidate thresholds, and select the threshold with the highest success rate. The evaluation episodes are not used for this selection. Here, AutoHorizon applies the threshold to the attention maps of the model, and PACE applies it to the speed valleys of the actions. The table below compares the configurations of the original papers with our calibrated ones on VLABench.

MethodConfigurationThresholdAvg. HexecH_{\text{exec}}Success rate
AutoHorizon [A]Original paper0.39.3924.7
AutoHorizon [A]Calibrated (used in Tab. 1)0.69.4525.3
PACE [B]Original paper9.5×10⁻⁷5.5323.6
PACE [B]Calibrated (used in Tab. 1)0.0898.5825.4

Our calibrated configurations achieve higher success rates than the original ones for both methods. For the matched comparison in (1), we use the same calibrated thresholds for both fine-tuning and RACE (0.6 for AutoHorizon and 0.089 for PACE). We have added these details to Appendix E.7 of the revised version (Tab. 41; highlighted in red).

(3) Source of the idle-time reduction on the real robot. As the reviewer notes, the idle-time reduction comes from the longer chunk itself, as our paper also states (Lines 96–98 and 526–527 of the revised version). However, some sentences may suggest that RACE itself reduces idle time, so we have revised them to clarify that RACE makes longer chunks reliable (highlighted in red; line numbers refer to the revised version):

  • Abstract (Lines 26–28): "On a real robot, RACE uses 4× longer chunks, which reduces the idle time caused by stop-and-go execution by about 5×, while achieving a higher success rate than fine-tuning with the same chunk length." → "On a real robot, 4× longer chunks reduce idle time by about 5×, and RACE achieves a higher success rate than fine-tuning at this length."
  • Sec. 1 (Line 107): "and enables longer chunks that reduce idle time on a real robot" → "and outperforms fine-tuning on a real robot, where longer chunks reduce idle time"
  • Conclusion (Line 539): "On a real robot, RACE enables longer chunks that reduce idle time, with a higher success rate than fine-tuning at the same chunk length." → "On a real robot, longer chunks reduce idle time, and RACE achieves a higher success rate than fine-tuning at the same chunk length."

[A] Wang et al., VLA Knows Its Limits: Adaptive Execution Horizons for Robot Policies, ECCV 2026.

[B] Nie et al., PACE: Phase-Aware Chunk Execution for Robot Policies with Action Chunking, arXiv 2026.


AuthorsOpenReview ↗

Response to Reviewer Sisy(3/4): Q1+Q2


Q1. Hyperparameter configuration of the adaptive chunking methods.

We calibrate the thresholds of both methods for each benchmark, and select the threshold with the highest success rate when the policy is run from the initial states of the training demonstrations. We kindly refer the reviewer to (2) of our response to W2 for details, including the selected thresholds.


Q2. Training-free prior from change-point detection.

Thank you for the insightful suggestion, which helps isolate what the learned head adds. As suggested, we replace the learned head with a training-free prior at inference. We obtain this prior by running PELT on (i) the one-step estimate from the auxiliary pass, or (ii) the chunk from a first full denoising pass. The table below compares them with the zero prior and the learned head (VLABench, Hexec=20H_{\text{exec}}=20; precision and recall are measured on training demonstrations, as in the training column of Tab. 27).

Prior at inferenceChunks with detected transitions (%)Precision ±1 (%)Recall ±1 (%)Success rate
Zero prior (Tab. 6)---31.8
(i) PELT on one-step estimate1.783.83.131.6
(ii) PELT on full-pass chunk9.762.29.930.9
Learned head (ours)21.787.562.733.0

With the PELT settings used for our labels, both training-free priors miss most transitions. One possible reason is that these settings are chosen for whole episodes, whereas PELT here sees only the 20 actions within a chunk. With the one-step estimate, PELT detects only a few clear changes, so its prior is almost always empty and its success rate is similar to that of the zero prior. With the full-pass chunk, PELT detects more changes but with lower precision, and its success rate falls below that of the zero prior.

In contrast, the learned head achieves higher precision and recall, and the highest success rate. Unlike PELT on a single chunk, the head predicts the episode-level labels from both the action features and the VLM features of the observation. It also adds only about 0.3 ms per call (Tab. 16 in Appendix B.6), whereas (ii) requires an additional full denoising pass per call. Thus, under these settings, the learned head provides a more accurate prior than the training-free priors.

Furthermore, we describe the implementation details of this experiment below.

  • One-step estimate: A^t=At0+vtaux\hat{\mathbf{A}}_t = \mathbf{A}_t^{0} + \mathbf{v}_t^{\mathrm{aux}}, a single Euler step from the initial noise with the velocity of the auxiliary pass (Sec. 3.2).
  • Full-pass chunk: the chunk generated by a first full denoising pass with the zero prior.
  • PELT settings: the same as for our labels (Appendix A.3).
  • Conversion to the prior: the detected change points are converted with the same soft labels as in training.
  • Detection metrics: the fraction of chunks with detected transitions, the precision, and the recall are measured against the PELT labels on the same training demonstrations for all priors, as in Tab. 27 of Appendix D.1.
  • Success rate: measured by running the policy on the VLABench evaluation episodes, as in Tab. 1.

Reviewer_1yMROpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies the degradation of vision-language-action policies when action chunks are extended. It identifies elevated action prediction errors around automatically detected changes in motion and proposes RACE, which predicts a transition-timing prior using an auxiliary denoising pass and conditions subsequent action generation on it. The authors evaluate success and execution efficiency across chunk lengths in simulation and on a real robot.

Critical strengths
  1. The trade-off between inference overhead and open-loop reliability is important for practical robot deployment.
  2. The method is motivated by an interpretable empirical observation and derives transition supervision automatically from demonstrations.
  3. Comparisons at matched chunk lengths, together with real-robot experiments, help distinguish the proposed method from the effect of simply extending the chunk.
Critical weaknesses
  1. The detected change points are proxies for subskill transitions. The reported error peaks could also reflect contact events, changes in action magnitude, or multimodal demonstrations. Validation against annotated transitions and sensitivity to the change-point detector would strengthen the central claim.
  2. Training conditions on a jittered target prior whereas inference uses a predicted prior. The resulting distribution mismatch deserves closer analysis, including transition prediction accuracy and comparisons with oracle, predicted, and uninformative priors.
  3. The auxiliary pass adds computation. Comparisons should include end-to-end latency, task completion time, and success under matched hardware and control settings, including strong asynchronous and adaptive-chunking alternatives. Reduced idle time alone does not establish a proportional reduction in total task time.
  4. More extensive real-world trials, uncertainty estimates, and tests under dynamic disturbances would clarify the reliability cost of longer open-loop execution.
Questions for authors

See the weakness.

6 comments
AuthorsOpenReview ↗

Response to Reviewer 1yMR(1/4): W1

We thank Reviewer 1yMR for the constructive feedback and for recognizing the practical importance of the problem, our empirically grounded motivation, and the matched-chunk-length and real-robot comparisons. We address each concern below. Table, figure, section, and line numbers below refer to the revised version.


W1. Validating error peaks with other transition sources.

Thank you for the suggestion. We agree that change points are a proxy for subskill transitions, which we adopt following prior subskill-discovery work (CoTPC [A], PRIMT [B]). For this reason, in the original submission, we validated the transition labels against the subskill boundaries recorded by the VLABench demonstration generator (Tab. 9 in Appendix A.5), examined the sensitivity of RACE to different change-point detectors (Tab. 5a and Tab. 22 in Appendix C.1), and analyzed transition errors after matching for local action variation (Tab. 39 in Appendix E.4).

Building on these existing analyses, we further extend the validation as suggested by the reviewer, examining error peaks at generator-annotated transitions and transitions identified by alternative change-point detectors.

(1) Error peaks at annotated transitions. In the extended validation, we use the generator boundaries, which are defined independently of the action signals, as transition annotations. These are the steps at which the scripted generator that produced the VLABench demonstrations switches between skill targets and gripper primitives (detailed in Appendix A.5).

(2) Error peaks with other PELT costs. We detect change points with PELT using two other segment costs, a cosine kernel and an L1 cost, instead of the Gaussian kernel (Appendix A.3). We also use speed minima, the alternative detector in our label ablation (Tab. 5a in the main manuscript).

The table below reports the action error of π0.5\pi_{0.5}, as in Fig. 2b. We compare the error at transitions with the mean error at non-transitions.

Transition sourceError at transitionsError at non-trans.Ratio
PELT, Gaussian kernel (used)3.751.891.98
(1) Generator boundaries2.851.871.52
(2) PELT, cosine kernel3.331.891.76
(2) PELT, L1 cost2.731.831.49
(2) Speed minima [C]1.902.150.88

The error peak also appears at the generator boundaries, which are defined without the action signals. With the other PELT costs, the peak remains, so it is not specific to the segment cost we use. In contrast, speed minima show no peak, and in the separate validation of Tab. 9 (Appendix A.5), most of them do not match the generator boundaries (40% vs. 82% precision for PELT).

(3) Error peaks after matching the action variation. We agree with the reviewer that the observed error peaks may partly reflect changes in action magnitude. We also investigated this possibility in the original submission (Appendix E.4, Tab. 39), where we compare transition errors with non-transition errors matched for both the position within the action chunk and local action variation. Even after this matching, transition errors remain approximately 1.3× higher (1.34× for π0.5\pi_{0.5} and 1.30× for RACE), suggesting that local action variation alone does not fully explain the elevated errors at transitions.

Together, these results suggest that the error peak is associated with subskill transitions. It is not specific to our detector, and it remains after matching the chunk position and the local action variation. We note that these analyses do not fully separate transitions from contact events or multimodal demonstrations. As stated in Appendix E.4, comparing errors at transition and non-transition actions "indicates where errors concentrate rather than separating the causes of execution failures" (Line 1765 of the revised version).

We have added these results to Appendix E.4 of the revised version (Tab. 40; highlighted in red).

[A] Jia et al., Chain-of-Thought Predictive Control, ICML 2024.

[B] Wang et al., PRIMT: Preference-based Reinforcement Learning with Multimodal Feedback and Trajectory Synthesis from Foundation Models, NeurIPS 2025.

[C] Nie et al., PACE: Phase-Aware Chunk Execution for Robot Policies with Action Chunking, arXiv 2026.

AuthorsOpenReview ↗

Response to Reviewer 1yMR(2/4): W2


W2. Analysis of the training–inference difference in the timing prior.

Thank you for raising this point. Below, we analyze the difference between the jittered target prior used in training and the predicted prior used at inference, which comes from two design choices (i.e., teacher forcing and jittering).

(1) Training without teacher forcing or jittering. As reported in our appendix, training on the predicted prior instead of the target prior (i.e., without teacher forcing) or without jittering barely changes the success rate (Tab. 25 in Appendix C.4). For convenience, we include the table from the appendix below (VLABench, Hexec=20H_{\text{exec}}=20).

Training strategyAvg. SR
w/o teacher forcing32.9
w/o jittering32.8
w/ both (used)33.0

(2) Robustness to timing perturbations. Although jittering barely changes the success rate as shown in (1), it makes RACE robust to perturbations of the predicted timing (Tab. 28 in Appendix D.2). The table below shows the success rate when the predicted prior is intentionally shifted by δ steps at inference.

Trainingδ=−5δ=−3δ=−1δ=0δ=+1δ=+3δ=+5
w/o jittering24.624.830.132.830.826.430.4
w/ jittering (used)29.430.330.233.030.731.230.9

With jittering, the success rate remains more stable when the prior is perturbed by several steps.

(3) Prediction accuracy comparison. As suggested, we report the prediction accuracy of the head for each training strategy (i.e., w/o teacher forcing, w/o jittering, and w/ both) in the table below (VLABench training demonstrations, Hexec=20H_{\text{exec}}=20). We report the precision and recall within ±1 step and also within ±3 steps, since a transition spans several steps (Appendix A.4).

Training strategyPrecision ±1 (%)Precision ±3 (%)Recall ±1 (%)Recall ±3 (%)
w/o teacher forcing87.392.462.766.1
w/o jittering87.292.362.566.3
w/ both (used)87.592.562.766.3

The accuracy is nearly identical across the three strategies.

(4) Comparison with oracle, predicted, and uninformative priors. As suggested, we compare RACE under the oracle, predicted, and uninformative priors. Here, the oracle prior is the PELT labels that condition RACE during training (i.e., teacher forcing). Since it requires the demonstrated actions, we measure the action error on 300 VLABench training demonstrations instead of the success rate (Hexec=20H_{\text{exec}}=20). To match the jittering in training, we also jitter the predicted prior at inference.

Prior at inferenceJitter at inferenceError at transitions ↓Error at non-transitions ↓
Predicted prior (ours)✓1.4610.810
Predicted prior (ours)-1.4520.826
Oracle prior (PELT labels)-1.1040.770
Zero prior (uninformative)-1.7020.872

Applying the same one-step jitter to the predicted prior at inference barely changes the error. The oracle prior gives the lowest error and the zero prior the highest, so the error decreases as the prior becomes more accurate. The gap between the oracle and predicted priors shows that a more accurate prediction could further reduce the error.

Overall, the prior differs between training and inference by design. Training without teacher forcing or without jittering gives a similar success rate, while jittering makes RACE more robust when the predicted timing is shifted by several steps. The lower error with the oracle prior indicates that there is room to improve the predicted timing. We have added these results to Appendix C.4 (Tab. 25) and Appendix D.7 (Tab. 36) of the revised version (highlighted in red).


AuthorsOpenReview ↗

Response to Reviewer 1yMR(3/4): W3


W3. Task time reduction and matched comparisons with asynchronous execution and adaptive chunking.

Thank you for raising these important concerns. We address each point below.

(1) Reduction in task time on a real robot. We agree that reduced idle time does not imply a proportional reduction in total task time. Accordingly, we did not intend to claim such a reduction, and Sec. 4.5 states that "task-completion time decreases only slightly" (Lines 528–529 of the revised version). To make this distinction clearer, we have revised the related sentences as follows (highlighted in red; line numbers refer to the revised version):

  • Abstract (Lines 13–14): "stop-and-go execution that interrupts smooth motion and prolongs task completion" → "stop-and-go execution that interrupts smooth motion and can prolong task completion"
  • Sec. 1 (Lines 39–40): "idle time, which prolongs task completion and interrupts smooth robot motion" → "idle time, which interrupts smooth robot motion and can prolong task completion"

(2) Asynchronous execution on a real robot under matched settings. We would like to clarify that all our real-robot experiments use asynchronous execution with real-time chunking [D], with the same hardware and control rate (30 Hz) for every method. As suggested, the table below reports the end-to-end latency per call (detailed in Tab. 32 of Appendix D.5), together with the success rate, task completion time, and idle time (reported in Tab. 7).

MethodHexecH_{\text{exec}}Success rateTask completion timeIdle timeEnd-to-end latency per call
π0.5\pi_{0.5} fine-tuning536%12.6 s2.11 s271 ms
π0.5\pi_{0.5} fine-tuning2048%11.6 s0.40 s285 ms
RACE (ours)2066%11.8 s0.41 s372 ms

Even with asynchronous execution [D], the short chunk still causes pauses. Extending the chunk removes all pauses after the first policy call, and the remaining idle time (0.41 s) comes only from the first policy call (0.28 s) and the control-loop overhead (0.13 s; Tab. 32 in Appendix D.5). RACE has a higher latency per call than fine-tuning, since our real-robot implementation runs it without CUDA graphs (Appendix D.5). However, the long chunk hides this latency, so RACE has the same idle time as fine-tuning while achieving a higher success rate.

(3) Adaptive chunking in simulation under matched settings. Thank you for the valuable suggestion. Indeed, a comparison at the same chunk length is more informative. Accordingly, we apply AutoHorizon [E] and PACE [C] to both fine-tuning and RACE on VLABench, where both models predict H=20H=20 actions. The adaptive method decides how many of these actions to execute, and we report the average executed length (Avg. HexecH_{\text{exec}}). The table below reports the results.

MethodAvg. HexecH_{\text{exec}}SpeedupSuccess rate
π0.5\pi_{0.5} fine-tuning203.82×28.1
π0.5\pi_{0.5} fine-tuning + AutoHorizon [E]14.13.06×30.4
π0.5\pi_{0.5} fine-tuning + PACE [C]12.22.81×30.9
RACE (ours)203.68×33.0
RACE + AutoHorizon [E]11.72.56×36.3
RACE + PACE [C]12.22.68×36.0

With and without adaptive chunking, RACE achieves a higher success rate than fine-tuning. With PACE, both models execute the same average length (12.2), and RACE still achieves a higher success rate (36.0 vs. 30.9). RACE alone even outperforms fine-tuning with adaptive chunking, while requiring fewer policy calls. Adding adaptive chunking further improves RACE, showing that the two approaches are complementary. However, this gain requires more policy calls, as adaptive chunking executes only about 12 of the 20 actions per chunk.

We have added these results to Sec. 4.2 of the revised version (Tab. 3; highlighted in red).

[C] Nie et al., PACE: Phase-Aware Chunk Execution for Robot Policies with Action Chunking, arXiv 2026.

[D] Black et al., Real-Time Execution of Action Chunking Flow Policies, NeurIPS 2025.

[E] Wang et al., VLA Knows Its Limits: Adaptive Execution Horizons for Robot Policies, ECCV 2026.


From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.