PICES：无需重训练，将VLA机器人模型推理提速最高2.3倍

Abstract

Action-chunking vision-language-action (VLA) models predict sequences of future robot actions. Under fixed-horizon execution, the robot executes a fixed-length prefix of each predicted chunk before invoking the policy again, leaving the remaining predictions unused. For a given number of executed actions, short execution horizons require more policy calls. Extending the execution horizon amortizes policy inference cost over more actions. However, uniformly applying long horizons across episodes can limit opportunities for precise corrections. To address this limitation, we propose PICES (Perturbation-Informed Chunk and Execution Horizon Selection), a training-free method that jointly selects an action chunk and the number of actions executed before the next policy call. Within a single policy call, the action expert generates a batch of action chunks from multiple initial noise samples and their locally perturbed counterparts, using the same conditioning features across all samples. PICES exploits differences between corresponding actions in each nominal chunk and its counterpart to determine candidate-specific execution horizons and select a nominal chunk for execution. Experiments on simulation benchmarks and real-world manipulation tasks demonstrate that PICES achieves speedup by up to 2.3\times in wall-clock policy inference time on Jetson Orin and Thor relative to fixed-horizon baselines while improving the success rate. The code is available at : https://anonymous.4open.science/r/PICES_VLA-B1BF

1 Introduction

Vision-language-action (VLA) models generate robot actions conditioned on visual observations, proprioceptive states, and language instructions (Brohan et al., 2022; Kim et al., 2024; Kim et al., 2025). Recent VLA architectures pair a vision-language backbone with a flow-matching action expert that transforms initial noise into an action chunk, a sequence of future actions (Bjorck et al., 2025; Black et al., 2024; Intelligence et al., 2025; Shukor et al., 2025). In conventional action chunking, the robot executes fixed-length actions of each predicted chunk before replanning as illustrated in Figure 1(a). The number of actions executed before update observations defines the execution horizon (Black et al., 2026). The cumulative policy invocations across policy rollout makes task-completion time dependent on both per-call latency and the number of policy calls (Zhou et al., 2026; Jing et al., 2025).

At comparable success rates, shorter task-completion times enable a robot to complete more tasks within a fixed time budget (Shukor et al., 2025; Huang et al., 2025). This makes cumulative inference latency as an important consideration for onboard VLA deployment, where edge platforms such as NVIDIA Jetson Orin and Thor operate under compute and memory-bandwidth constraints (Yang et al., 2026; Jiang et al., 2026). For example, GR00T N1.7 requires 80.4ms per policy call on Jetson Orin and 150.9 ms on Jetson Thor (Li et al., 2026; Bjorck et al., 2025), whereas observation acquisition and actuation can operate up to 60Hz and 1kHz, respectively (Jiang et al., 2026; Ma et al., 2025; Zhang et al., 2020). In observation-inference-execution pipeline, reducing the number of policy calls lowers cumulative inference latency and shorten task-completion time (Jing et al., 2025). For action chunking policies, executing only fraction of each predicted action chunk incurs inefficiency. However, applying long horizons uniformly across task phases delays the incorporation of updated observations when precise control is required. This motivates adapting execution horizons to reduce repeated inference while preserving task success.

Prior works have explored diverse action-chunk execution strategies to balance temporal consistency and reactivity, including temporal ensembling, adaptive chunk updates, and guided candidate selection (Zhao et al., 2023; So et al., 2026; Liu et al., 2025a). AAC estimates action entropy of action candidates to decide a shared exceuction horizon (Liang et al., 2026). AutoHorizon derives the execution horizon from self-attention within a predicted chunk (Wang et al., 2026). A^{3} selects a representative trajectory from multiple candidates and then performs additional flow-matching verification to determine execution horizon (Zhao et al., 2026). Our objective is to reduce wall-clock inference time while achieving comparable success rate by jointly selecting an action chunk and its execution horizon. This raises our key question: Given a bounded set of candidate action chunks generated in a single policy call, how can we select the action chunk and execution horizon to reduce the wall-clock inference time?

We propose PICES (Perturbation-Informed Chunk and Execution Horizon Selection), a training-free inference time method that jointly selects an action chunk and its execution horizon. For each initial-noise sample, PICES constructs a locally perturbed counterpart by adding a small Gaussian perturbation. A single batched policy call generates the corresponding nominal and auxiliary action chunks using shared conditioning features encoded by the vision-language-model (VLM). Based on the arithmetic intensity analysis of action expert and hardware ridge-point in our motivational analysis, we restrict total batch size to a range with negligible incremental latency. For each candidate, the stepwise differences between nominal and auxiliary action chunks yield a local sensitivity value. We exploit these values to retain candidates with low initial sensitivity and estimate execution horizon for each candidate. From the candidate pool, PICES selects and executes the nominal chunk with the longest execution horizon. Figure 1(b) illustrates the reduction in policy calls: two calls execute eight actions, compared with four calls with fixed horizon execution. Savings from fewer policy calls outweigh the additional cost of candidate generation, reducing cumulative inference time as shown in Figure 1(c).

Our key contributions are as follows:

• Through an open-loop study, we show that oracle selection from multiple action chunks can yield lower reference-action error over a longer execution horizon than a single-candidate, short-horizon baseline. We also characterize the cost of generating candidates in a batch.
• We propose PICES, a training-free method to reduce cumulative wall-clock inference time. PICES uses sensitivity to initial-noise perturbations to guide the joint selection of an action chunk and its execution horizon.
• We evaluate PICES across multiple VLA models in simulation and on real-world robot tasks. Compared with fixed-horizon baselines, PICES reduces policy calls by 25.4–60.3% and achieves 1.2–2.3\times speedups in wall-clock inference time on Jetson Orin and Thor, while maintaining higher success rates.

2 Related Work

Action Chunking in VLA Models.

Recent VLAs such as CogACT, \pi, and GR00T series execute only a fixed-length horizon of each predicted chunk (Li et al., 2024a; Black et al., 2024; Bjorck et al., 2025). Executing a long fixed-length actions reduces policy calls but limits the incorporation of new observations, motivating adaptive execution horizons (Liang et al., 2026; Wang et al., 2026; Chen et al., 2026) (see Appendix G for full discussion). In contrast, our method instead estimates a horizon for each candidate and uses the estimated execution length to choose the reliable action chunk to shorten cumulative inference time without training.

Acceleration for VLA Models.

Efficient VLA inference seeks to reduce task completion time using various methods. To reduce inference overhead, previous work exploits redundancy in visual inputs and model computation through token pruning, channel pruning, and model scheduling (Chen et al., 2024; Shukor et al., 2025; Xu et al., 2026; Feng et al., 2026) (see Appendix G for full discussion). Our method is orthogonal to token pruning, which reduces computation within individual policy calls. PICES examines how candidate-specific horizon selection can reduce policy calls, while explicitly accounting for the additional cost of generating and assessing multiple action candidates.

3 Proposed Approach

3.1 Background

Input Condition and Action Chunk. Let \bm{c}:=\bigl(\bm{o},\bm{q},\ell\bigr)\in\mathcal{C} denote the conditioning input, comprising the current observation \bm{o}, the proprioceptive state \bm{q}, and the language instruction \ell. Let V_{\theta} denote a pretrained VLA action generator parameterized by \theta, V_{\theta}:\mathcal{C}\times\mathbb{R}^{d\times H}\longrightarrow\mathbb{R}^{d\times H}. Here, d is the dimension of each action and H is the number of action steps generated in one action chunk. Given an initial noise sample \bm{Z}\in\mathbb{R}^{d\times H}, the model generates \bm{A}=\left[\bm{a}_{0},\bm{a}_{1},\ldots,\bm{a}_{H-1}\right]\in\mathbb{R}^{d\times H} To generate N candidate action chunks from the same current input, sample N independent initial noise matrices \bm{Z}^{(n)}\in\mathbb{R}^{d\times H}. The n indicates the candidate index. All candidates share the same conditioning prefix \bm{c} and differ only in their initial noise samples:

\bm{A}^{(n)}=V_{\theta}\!\left(\bm{c},\bm{Z}^{(n)}\right)=\left[\bm{a}^{(n)}_{0},\bm{a}^{(n)}_{1},\ldots,\bm{a}^{(n)}_{H-1}\right]\in\mathbb{R}^{d\times H},\qquad n=1,\ldots,N.

Equivalently, conditioned on the same current visual observation, proprioceptive state, and language instruction, N independent source samples are mapped into N candidate action chunks with H number of actions in single action chunk, whereas h\in\{1,\ldots,H\} denotes the execution horizon.

3.2 Motivational Study

We analyze whether sampling multiple action chunks under identical conditioning inputs can provide suitable candidates for longer execution horizon than fixed-length execution. To limit the latency overhead of this additional sampling, we explore affordable batch size during chunk generation. This motivates two questions: (1) Can multiple sampled chunks provide a lower reference-action error at a longer fixed execution horizon candidate than a single sampled chunk? (2) Under consideration of action expert’s arithmetic intensity, how many candidate chunks can we expect to be generated in a batch with modest additional latency?

Selection by minimum reference-action RMSE.

We first compare reference action root-mean-square-error (RMSE) across fixed execution horizons and candidate counts. We conduct the analysis with the RT-1 Fractal dataset and GR00T N1.7 (Bjorck et al., 2025; Brohan et al., 2022). For each condition \bm{c}, we generate N\in{1,\ldots,10} candidate action chunks using independent initial noise and evaluate horizons h\in\{1,\ldots,8\}. For each input and (N,h) pair, an oracle selects the candidate with the lowest RMSE over its first h actions relative to the corresponding reference actions. The RMSE metric is explained in Appendix C. Figure 3 shows that selection from four candidates at an eight-step horizon (N=4, h=8) achieves an RMSE of 0.1795, compared with 0.1900 for the single-candidate action chunk at one-step horizon (N=1, h=1). This result demonstrates that chunk selection from multiple candidates can yield lower reference-action error even when evaluated over a longer execution horizon, motivating an inference-time method for joint action chunk and execution horizon selection.

Operation Characteristics of Action Expert.

Cumulative inference-time saving for the longer execution horizons requires generating action chunks with limited additional latency. Prior studies identify low arithmetic intensity (AI) of action generation in action expert (Jiang et al., 2026; Zhou et al., 2026). The roofline in Figure 3 shows the AI of the \pi_{0.5}, GR00T N1.5, and GR00T N1.7 action experts at batch sizes B\in\{1,2,5,10,15,20\}. At single batch, the AI of all three action experts lies below the ridge points of both Jetson Orin and Thor, indicating memory-bound operation under the roofline model. When AI remains below the device’s ridge point, the operation latency depends primarily on memory transfer latency. In such a case, the additional computation can be accommodated without a proportional increase in latency. On Orin, all three models approach the ridge point at a batch size of 6. On Thor, the action experts remain memory-bound even at a batch size of 20; however, beyond a batch size of 10, growing activation traffic incurs latency overhead. We therefore set the total generation batch-size limits to 6 on Orin and 10 on Thor to balance candidate diversity against per-call latency. Appendix B provides the further analysis of arithmetic intensity and measured latency on GPUs.

Together, these analyses suggest that a bounded set of action chunks can contain candidates suitable for longer execution horizons with modest cost for the batched generation of candidates. This raises the central question: how can we assess the reliability of each candidate’s future action steps and jointly select a chunk and its execution horizon?

3.3 Perturbation-Informed Candidate Assessment

For each nominal action chunk, we measure changes in the action expert output under local perturbations of the corresponding initial noise. Local sensitivity quantifies output variation under small input changes, and exploiting this sensitivity has been used to encourage invariant representations (Rifai, 2011). In image generation, per-image perceptual path length quantifies how much the generated image changes perceptually under small perturbations of its latent code (Karras et al., 2020). Motivated by these observations, we use local stability under initial-noise perturbations as a proxy for reliability of each nominal action. We estimate sensitivity at each action timestep within a chunk and use these estimates to favor nominal candidates with lower sensitivity.

Step 1 & 2. Local perturbations of the initial noise and multiple action chunks.

Comparing generator outputs at neighboring latent inputs provides a practical way to probe local sensitivity (Odena et al., 2018). Related analyses of diffusion sampling connect initial-noise perturbations to changes in the final generated output (Song et al., 2026). These analyses motivate our use of initial-noise perturbations to assess the local stability of nominal action chunks. For each nominal candidate \bm{A}_{t}^{(n)}=V_{\theta}(\bm{c},\bm{Z}^{(n)}), we sample perturbation matrices \bm{\epsilon}^{(n,r)}\in\mathbb{R}^{d\times H} with i.i.d. \mathcal{N}(0,1) entries. All perturbation matrices are mutually independent and independent of the nominal initial noises.

\widetilde{\bm{Z}}^{(n)}=\bm{Z}^{(n)}+\sigma\bm{\epsilon}^{(n)},\qquad\widetilde{\bm{A}}_{t}^{(n)}=V_{\theta}\!\left(\bm{c},\widetilde{\bm{Z}}^{(n)}\right),

where \sigma>0 controls the perturbation scale. Perturbations are applied only to the initial noise before flow integration. We stack all nominal initial noises \bm{Z}^{(n)} and their perturbed counterparts \widetilde{\bm{Z}}^{(n)} into a single batch. All nominal and perturbed initial-noise samples are processed in a single batched policy call with a shared conditioning input \bm{c}. For each candidate n, we estimate sensitivity at each action timestep by comparing the nominal chunk \bm{A}^{(n)} with its auxiliary chunk \widetilde{\bm{A}}^{(n)}. Only actions from the unmodified nominal chunks are used for execution.

Step 3. Stepwise action sensitivity score.

Write the nominal action chunk as \bm{A}^{(n)}=[\bm{a}_{0}^{(n)},\ldots,\bm{a}_{H-1}^{(n)}]\in\mathbb{R}^{d\times H}, where \bm{a}_{k}^{(n)}\in\mathbb{R}^{d} is the action at offset k\in\{0,\ldots,H-1\}. Define \widetilde{\bm{a}}_{k}^{(n)} analogously from the auxiliary chunk \widetilde{\bm{A}}^{(n)}. The execution horizon h denotes the number of leading actions executed from the selected chunk. With the conditioning input \bm{c} fixed, we define

G_{k}^{(n)}=\frac{\left\|\widetilde{\bm{a}}_{k}^{(n)}-\bm{a}_{k}^{(n)}\right\|^{2}}{\sigma^{2}\left\|\bm{\epsilon}^{(n)}\right\|_{F}^{2}}.

The score normalizes the action difference between the nominal and auxiliary actions by the squared displacement of the initial-noise perturbation. Appendix D provides the connection between squared norm of the directional derivative of the action at offset k for sufficiently small perturbations.

We use the resulting stepwise scores \{G_{k}^{(n)}\}_{k=0}^{H-1} to guide joint nominal action chunk and its execution horizon selection. The scores are computed from the paired outputs generated in Steps 1 and 2, without explicitly constructing Jacobians or training a separate evaluator.

3.4 Joint Action Chunk and Execution Horizon Selection

Step 4. Candidate filtering and horizon selection. We filter nominal candidates by their initial-window sensitivity, then select the candidate with the longest execution horizon among those retained. For each candidate n, define

S_{n}=\frac{1}{W}\sum_{k=0}^{W-1}G_{k}^{(n)},

where W is the number of initial action timesteps included in the average, with 1\leq W\leq H. The same averaging window is used for all candidates. We retain all candidates whose scores do not exceed the median across the N nominal candidates:

\mathcal{K}=\left\{n\in\{1,\ldots,N\}:S_{n}\leq\operatorname{median}(S_{1},\ldots,S_{N})\right\}.

For each retained candidate, we determine an execution horizon using its initial-window average S_{n} as a sensitivity threshold. Let H denote the maximum execution length, we define

\displaystyle h_{n}=\min\bigl(\{k\in\{W,\ldots,H-1\}:G_{k}^{(n)}>S_{n}\}\cup\{H\}\bigr)

If k is the first offset in \{W,\ldots,H-1\} satisfying G_{k}^{(n)}>S_{n}, we set h_{n}=k. If no crossing occurs before the execution cap, h_{n}=H. The selected nominal chunk is \bm{A}^{(n^{\star})}, and its execution horizon is h^{\star}=h_{n^{\star}}. We use the first h^{\star} actions of the chunk, [\bm{a}_{0}^{(n^{\star})},\ldots,\bm{a}_{h^{\star}-1}^{(n^{\star})}], as the control sequence. After executing the action sequence, we obtain an updated observation and repeat the candidate generation, assessment, and selection procedure. Each policy call thus provides h^{\star} actions before replanning.

3.5 Open-loop Analysis of Chunk and Horizon Selection

Effect of the candidate selection rule.

We evaluate open-loop action prediction error across methods with fixed and adaptive execution horizons. For each method, we compute RMSE between the first h predicted actions and the corresponding recorded actions, following the evaluation protocol of the motivational study. The fixed-step baseline uses a prescribed horizon with single action chunk. Figure 5 reports action prediction RMSE against the average execution horizon. The lowest-S_{i} method obtains reference-action RMSE close to the single-step baseline while selecting approximately 1.9 actions on average. This observation supports the usefulness of sensitivity-guided candidate assessment for identifying action chunks with low reference-action error. PICES retains candidates with low initial sensitivity and selects the candidate with the longest estimated execution horizon. The resulting average horizon increases to 3.3 actions, while the observed RMSE remains below that of the single-candidate, two-step execution horizon baseline.

4 Experiments

4.1 Experimental Setups

Models and benchmarks. In simulation, we evaluate PICES with GR00T N1.7 on SimplerEnv–Fractal, \pi_{0.5} and GR00T N1.5 on LIBERO. For each model–benchmark configuration, we retain the action dimensionality specified by the corresponding official repository and use default execution horizon for the fixed-horizon baseline. We further evaluate \pi_{0.5} on three real-world manipulation tasks using a UR10e robot arm.

Baselines and PICES configuration. We compare PICES with fixed-horizon execution, AAC, and A^{3} based on each official repository. We also evaluate AAC∗ and A^{3*}, whose generation budgets match PICES’s total number of nominal and perturbed action chunks. Unless otherwise specified, PICES uses N=3 nominal candidates, perturbation scale of \sigma=0.25 and reference-window W as default execution horizon specified by each model’s official repository for the corresponding benchmark. Full model configurations, benchmark descriptions, evaluation protocols, and real-world task settings are provided in Appendix E.

4.2 Quantitative Analyses

PICES improves task success while reducing total inference time. On SimplerEnv–Fractal with GR00T N1.7, PICES (N=3) achieves 68.7\% success with 60.3\% fewer policy calls, yielding inference-time speedups of 2.2\times on Jetson Orin and 2.2\times on Jetson Thor relative to the single-step baseline (Table 1). The reported speedups account for each method’s measured per-call GPU latency. Increasing the fixed execution horizon to h=8, success rate falls to 45.3\%, a decrease of 23.2\% from the single-step baseline. Compared with the fixed-horizon baseline (h=2), PICES achieves inference-time speedups of 1.3\times on both Jetson Orin and Thor. These results demonstrate PICES improves the trade-off between task success and inference time relative to the fixed-horizon baselines.

Comparison with dynamic execution baselines. PICES also achieves higher task success than the competing adaptive execution methods. AAC and A^{3} reduce the average number of policy calls to 10.1 and 18.8, respectively. However, their success rates are 47.3\% and 58.3\%, compared with 68.7\% for PICES (N=3). The success-rate gap persists under matching sampling action budgets to PICES (including nominal and auxiliary chunks). AAC∗ and A^{3*} achieve success rates of 50.0\% and 61.5\%, respectively, remaining 18.7\% and 7.2\% below PICES.

Evaluation on LIBERO. On LIBERO, PICES improves success over Fixed (h=5) from 96.5% to 97.3% with \pi_{0.5} and from 92.9% to 94.5% with GR00T N1.5 (Table 2). Average policy calls decrease by 34.1% and 28.9%, respectively. These reductions yield estimated inference-time speedups of 1.5\times on both devices with \pi_{0.5}, and 1.2\times with GR00T N1.5. With \pi_{0.5}, A^{3} achieves the lowest policy calls, but additional flow-matching computations for verification increase per-call latency 110 ms on Orin and 58 ms on Thor. This overhead limits inference-time speedup to 1.3\times on both devices, below the 1.5\times achieved by PICES. With GR00T N1.5 AAC achieves a slightly higher success rate than fixed-horizon baseline, but requires higher per-call latency, resulting in 0.7\times speedup on Orin and Thor. PICES improves success rate while achiving speedup on both devices.

Evaluation on Real-world tasks. We evaluate PICES with \pi_{0.5} on three manipulation tasks using a UR10e robot arm. Among the tested fixed-horizon baselines, h=8 achieves the highest average success rate of 90.7\%, as shown in Table 3. We set the reference-window length of PICES to W=8 and use Fixed (h=8) as the baseline for comparisons. PICES increases the average success rate to 93.5\%, an improvement of 2.8 percentage points. PICES also reduces the average number of policy calls per episode from 174.9 to 118.7, a reduction of 32.1\%. Consequently, the reduction in policy calls yields the speedups of 1.39\times and 1.36\times on Orin and Thor, respectively, relative to Fixed (h=8). These results demonstrate that the reduction at inference demand extends across the evaluated VLA backbones and manipulation benchmarks.

4.3 Additional Analyses

Effect of the number of nominal candidates.

Table 4 evaluates PICES with N\in\{1,3,5,7,9\} on SimplerEnv–Fractal using GR00T N1.7. Each policy call generates 2N chunks, comprising N nominal and N auxiliary chunks. As N increases from 1 to 9, the average number of policy calls per successful episode decreases from 23.4 to 16.1, a reduction of 31.1\%. On Orin, N=3 adds 5.1 ms per action sample generation. At N=9, increased per action sample costs (10.7 ms) outweigh further policy-call savings, consistent with the compute-bound behavior on Orin. Consequently, N=3 achieves 2.2\times speedup on Orin and 2.3\times on Thor.

Compatibility with VLA Acceleration Methods

We evaluate PICES combined with FastV and GridS on LIBERO using \pi_{0.5} with a fixed-horizon h=5 as the baseline. Both methods reduce per-call policy inference latency through visual token compression, using attention-based pruning for FastV and differentiable grid sampling for GridS. For FastV, we evaluate pruning ratios of 40\% and 50\%; For GridS, we use GridS16, which samples 16 visual tokens per image.

All speedups are relative to the fixed-horizon baseline without token pruning. Table 5 shows that PICES further reduces policy calls while maintaining or improving average success rates across all configurations. Combined with FastV (40\%), PICES achieves cumulative inference-time speedups of up to 1.8\times on Jetson Orin and 1.7\times on Jetson Thor; combined with GridS16, the speedups reach 2.8\times and 2.5\times, respectively. These results demonstrate that PICES provides additional efficiency gains on top of visual token compression.

4.4 Qualitative Analyses

Sensitivity-guided chunk selection from action candidates.

Figure 7 compares Fixed (h=5) and PICES using GR00T N1.5 on the LIBERO–Long task put both moka pots on the stove. The fixed-horizon baseline executes five actions from each sampled chunk, but the resulting motion fails to place the moka pot on the stove. PICES evaluates three nominal chunks N=3 using the initial-window sensitivity scores, filtering out \bm{A}^{(1)} with S_{1} above the median. Between \bm{A}^{(2)} and \bm{A}^{(3)}, PICES selects \bm{A}^{(2)} with longer execution horizon (h_{2}=10). PICES executes the first ten actions of this nominal chunk, resulting in successful placement in the shown rollout.

Execution horizons across phases.

Figure 7 compares fixed-horizon execution and PICES on stack the red cube on the green cube using \pi_{0.5} with the UR10e arm. Given a prediction horizon of H=16, the baseline uses h=8 throughout execution, whereas PICES selects h=12 during the initial approach and h=16 while transporting the red cube. During fine-grained phases such as near grasping and placement, PICES selects h=8, allowing replanning after fewer actions than coarse movement phases. Adaptive horizon execution beyond the baseline allows reducing the policy calls to shorten task completion relative to the fixed horizon.

5 Conclusion

We presented PICES, a training-free inference method for flow-matching VLA policies that jointly selects an action chunk and execution horizon. PICES estimates stepwise action sensitivity by comparing outputs generated from each initial noise and locally perturbed counterpart. PICES exploits these scores to filter candidates, determine execution horizon, and select the nominal chunk with the longest execution horizon. Experiments across multiple VLA backbones, simulation benchmarks, and real-world robot tasks show that PICES achieves higher task success rates while reducing cumulative inference time relative to the fixed-horizon baselines.

AI use statement

The research objectives, core ideas, and proposed method were developed by the authors without the use of generative AI tools. After independently formulating the research ideas, we used generative AI tools to help identify relevant prior work. We also used these tools to refine the manuscript’s language and clarity and to assist with code implementation.

The authors reviewed and verified all AI-generated outputs. In particular, AI-assisted code was reviewed and checked for correctness by at least two authors. We take full responsibility for the final content of this work, including all text, claims, code, and other artifacts produced with the assistance of generative AI.

Reproducibility statement

The source code is available at https://anonymous.4open.science/r/PICES_VLA-B1BF. The joint action chunk and execution horizon selection procedure is described in Section 3.4. Model configurations, baseline settings, and benchmark evaluation protocols are documented in Appendix E. The open-loop evaluation procedure and reference-action error metric are detailed in Appendix C. GPU profiling settings and latency measurements are provided in Appendix B. The real-world platform, manipulation tasks, demonstration collection, policy fine-tuning, and evaluation protocol are described in Appendix F.

References

1. Bishop (1995) C. M. Bishop Training with noise is equivalent to tikhonov regularization. Neural computation 7 (1), pp. 108–116.
2. Bjorck et al. (2025) J. Bjorck, F. Castañeda, N. Cherniadev, X. Da, R. Ding, L. Fan, Y. Fang, D. Fox, F. Hu, S. Huang, et al. Gr00t n1: an open foundation model for generalist humanoid robots. arXiv preprint arXiv:2503.14734.
3. Black et al. (2024) K. Black, N. Brown, D. Driess, A. Esmail, M. Equi, C. Finn, N. Fusai, L. Groom, K. Hausman, B. Ichter, et al. \pi\_0: a vision-language-action flow model for general robot control. arXiv preprint arXiv:2410.24164.
4. Black et al. (2026) K. Black, M. Galliker, and S. Levine Real-time execution of action chunking flow policies. Advances in Neural Information Processing Systems 38, pp. 33383–33407.
5. Brohan et al. (2022) A. Brohan, N. Brown, J. Carbajal, Y. Chebotar, J. Dabis, C. Finn, K. Gopalakrishnan, K. Hausman, A. Herzog, J. Hsu, et al. Rt-1: robotics transformer for real-world control at scale. arXiv preprint arXiv:2212.06817.
6. Chen et al. (2026) F. Chen, X. Wang, Y. Chen, B. Li, Y. He, Z. Zhang, and Y. Wu Dynamic execution commitment of vision-language-action models. arXiv preprint arXiv:2605.11567.
7. Chen et al. (2024) L. Chen, H. Zhao, T. Liu, S. Bai, J. Lin, C. Zhou, and B. Chang An image is worth 1/2 tokens after layer 2: plug-and-play inference acceleration for large vision-language models. In European Conference on Computer Vision, pp. 19–35.
8. Feng et al. (2026) Y. Feng, Z. Zhao, Y. Ma, C. Xia, C. Du, Y. Wang, and C. Xu See what matters: differentiable grid sample pruning for generalizable vision-language-action model. arXiv preprint arXiv:2605.11817.
9. Huang et al. (2025) Y. Huang, Y. Hao, B. Yu, F. Yan, Y. Yang, F. Min, Y. Han, L. Ma, S. Liu, Q. Liu, et al. Dadu-corki: algorithm-architecture co-design for embodied ai-powered robotic manipulation. In Proceedings of the 52nd Annual International Symposium on Computer Architecture, pp. 327–343.
10. Huang et al. (2026) Y. Huang, L. Ding, Z. Tang, Z. Zhu, J. Deng, X. Lin, S. Liu, H. Ren, J. Ji, and Y. Zhang Environment-aware adaptive pruning with interleaved inference orchestration for vision-language-action models. arXiv preprint arXiv:2602.00780.
11. Intelligence et al. (2025) P. Intelligence, K. Black, N. Brown, J. Darpinian, K. Dhabalia, D. Driess, A. Esmail, M. Equi, C. Finn, N. Fusai, et al. \pi\_{0.5}: A vision-language-action model with open-world generalization. arXiv preprint arXiv:2504.16054.
12. Jiang et al. (2026) W. Jiang, J. Clemons, K. Sankaralingam, and C. Kozyrakis How fast can i run my vla? demystifying vla inference performance with vla-perf. arXiv preprint arXiv:2602.18397.
13. Jing et al. (2025) D. Jing, G. Wang, J. Liu, W. Tang, Z. Sun, Y. Yao, Z. Wei, Y. Liu, Z. Lu, and M. Ding Mixture of horizons in action chunking. arXiv preprint arXiv:2511.19433.
14. Karras et al. (2020) T. Karras, S. Laine, M. Aittala, J. Hellsten, J. Lehtinen, and T. Aila Analyzing and improving the image quality of stylegan. In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 8107–8116.
15. Kim et al. (2025) M. J. Kim, C. Finn, and P. Liang Fine-tuning vision-language-action models: optimizing speed and success. arXiv preprint arXiv:2502.19645.
16. Kim et al. (2024) M. J. Kim, K. Pertsch, S. Karamcheti, T. Xiao, A. Balakrishna, S. Nair, R. Rafailov, E. Foster, G. Lam, P. Sanketi, et al. Openvla: an open-source vision-language-action model. arXiv preprint arXiv:2406.09246.
17. Li et al. (2024a) Q. Li, Y. Liang, Z. Wang, L. Luo, X. Chen, M. Liao, F. Wei, Y. Deng, S. Xu, Y. Zhang, et al. Cogact: a foundational vision-language-action model for synergizing cognition and action in robotic manipulation. arXiv preprint arXiv:2411.19650.
18. Li et al. (2024b) X. Li, K. Hsu, J. Gu, K. Pertsch, O. Mees, H. R. Walke, C. Fu, I. Lunawat, I. Sieh, S. Kirmani, et al. Evaluating real-world robot manipulation policies in simulation. arXiv preprint arXiv:2405.05941.
19. Li et al. (2025) Y. Li, Y. Meng, Z. Sun, K. Ji, C. Tang, J. Fan, X. Ma, S. Xia, Z. Wang, and W. Zhu Sp-vla: a joint model scheduling and token pruning approach for vla model acceleration. In The Fourteenth International Conference on Learning Representations,
20. Li et al. (2026) FluxVLA Engine: A One-Stop VLA Engineering Platform for Embodied Intelligence External Links: Document, Link
21. Liang et al. (2026) Y. Liang, X. Wang, K. Wang, S. Wang, X. Peng, H. Chen, D. K. H. Chua, and P. Vadakkepat Adaptive action chunking at inference-time for vision-language-action models. arXiv preprint arXiv:2604.04161.
22. Liu et al. (2023) B. Liu, Y. Zhu, C. Gao, Y. Feng, Q. Liu, Y. Zhu, and P. Stone Libero: benchmarking knowledge transfer for lifelong robot learning. Advances in Neural Information Processing Systems 36, pp. 44776–44791.
23. Liu et al. (2025a) Y. Liu, J. Hamid, A. Xie, Y. Lee, M. Du, and C. Finn Bidirectional decoding: improving action chunking via guided test-time sampling. In International Conference on Learning Representations, Vol. 2025, pp. 4594–4627.
24. Liu et al. (2025b) Z. Liu, Y. Chen, H. Cai, T. Lin, S. Yang, Z. Liu, and B. Zhao Vla-pruner: temporal-aware dual-level visual token pruning for efficient vision-language-action inference. arXiv e-prints, pp. arXiv–2511.
25. Ma et al. (2025) Y. Ma, Y. Zhou, Y. Yang, T. Wang, and H. Fan Running vlas at real-time speed. arXiv preprint arXiv:2510.26742.
26. Odena et al. (2018) A. Odena, J. Buckman, C. Olsson, T. Brown, C. Olah, C. Raffel, and I. Goodfellow Is generator conditioning causally related to gan performance?. In International conference on machine learning, pp. 3849–3858.
27. Physical Intelligence (2024) Physical Intelligence OpenPI: open-source infrastructure for vision-language-action models. Note: https://github.com/Physical-Intelligence/openpi
28. Rifai (2011) S. Rifai Contractive auto-encoders: explicit invariance during feature extraction.
29. Shukor et al. (2025) M. Shukor, D. Aubakirova, F. Capuano, P. Kooijmans, S. Palma, A. Zouitine, M. Aractingi, C. Pascal, M. Russi, A. Marafioti, et al. Smolvla: a vision-language-action model for affordable and efficient robotics. arXiv preprint arXiv:2506.01844.
30. So et al. (2026) J. So, C. Lee, S. Lee, J. Ok, and E. Park Improving generative behavior cloning via self-guidance and adaptive chunking. Advances in Neural Information Processing Systems 38, pp. 84432–84456.
31. Song et al. (2026) B. Song, Z. Zhang, Z. Luo, J. Hu, W. Yuan, J. Jia, Z. Tang, G. Wang, and L. Shen Ccs: controllable and constrained sampling with diffusion models via initial noise perturbation. Advances in Neural Information Processing Systems 38, pp. 70516–70552.
32. Wang et al. (2025) H. Wang, J. Xu, Y. Xiang, J. Pan, Y. Zhou, Y. Li, and G. Dai Specprune-vla: accelerating vision-language-action models via action-aware self-speculative pruning. arXiv preprint arXiv:2509.05614.
33. Wang et al. (2026) H. Wang, G. Zhang, Y. Yan, R. R. Kompella, and G. Liu VLA knows its limits: adaptive execution horizons for robot policies. arXiv preprint arXiv:2602.21445.
34. Wu et al. (2023) P. Wu, Y. Shentu, Z. Yi, X. Lin, and P. Abbeel GELLO: a general, low-cost, and intuitive teleoperation framework for robot manipulators.
35. Xu et al. (2026) S. Xu, Y. Wang, C. Xia, D. Zhu, T. Huang, and C. Xu Vla-cache: efficient vision-language-action manipulation via adaptive token caching. Advances in Neural Information Processing Systems 38, pp. 164448–164473.
36. Yang et al. (2026) Z. Yang, Q. Wang, Y. Wang, X. Guo, B. Yu, S. Liu, J. Xu, H. Dong, and M. Li Jetson-pi: towards onboard real-time robot control via foresight-aligned asynchronous inference. arXiv preprint arXiv:2607.12659.
37. Zhang et al. (2026) J. Zhang, Z. Han, J. Wang, X. Wu, S. Lin, J. Li, H. Fan, R. Wu, D. Li, and H. Dong Hipolicy: hierarchical multi-frequency action chunking for policy learning. arXiv preprint arXiv:2604.06067.
38. Zhang et al. (2020) K. Zhang, M. Sharma, J. Liang, and O. Kroemer A modular robotic arm control stack for research: franka-interface and frankapy. arXiv preprint arXiv:2011.02398.
39. Zhao et al. (2023) T. Z. Zhao, V. Kumar, S. Levine, and C. Finn Learning fine-grained bimanual manipulation with low-cost hardware. arXiv preprint arXiv:2304.13705.
40. Zhao et al. (2026) Y. Zhao, M. Bogdanovic, A. Sohal, L. Tao, K. Darvish, A. Aspuru-Guzik, F. Shkurti, and A. Garg Dynamic execution horizon prediction for chunk-based robot policies. arXiv preprint arXiv:2606.11408.
41. Zhou et al. (2026) K. Zhou, Q. Chen, D. Peng, Z. Li, X. Li, and J. Gu Characterizing vision-language-action models across xpus: constraints and acceleration for on-robot deployment. arXiv preprint arXiv:2604.24447.

Appendix A Horizon Distributions and Perturbation Sensitivity

Distribution of execution horizons.

To examine how PICES selects action chunks and execution horizons, we analyze the policy call records collected during closed-loop evaluation of GR00T N1.7 on SimplerEnv–Fractal with three N=3 nominal candidates. We group tasks by manipulation objective into three categories: Pick Coke/Object (Pick Coke Can and Pick Object), Open/Close (Open Drawer and Close Drawer), and Move/Place (Move Near and Place in Closed Drawer).

Figure 9 compares the execution horizons assigned to all nominal candidates with those of the chunks selected by PICES at the same recorded policy calls. For this analysis, we apply the horizon-estimation rule to all three nominal candidates, including those excluded by the initial-sensitivity filter. Each call contributes three candidate horizons (left) and one selected horizon (right). Across all groups, the selected distribution exhibits a lower proportion of one-step horizons and a higher proportion of intermediate horizons, particularly two to four steps. The proportion of one-step horizons decreases from 59.07\% among nominal candidates to 34.93\% among PICES selections. The corresponding average horizon increases from 2.49 to 3.01 actions. The consistent shift across the three groups shows that candidate selection increases the execution length on average across different manipulation objectives. The resulting distribution includes both short and long horizons, reflecting that PICES makes candidate-specific decisions during rollout.

Effect of the perturbation scale.

We examine the sensitivity of PICES’s task performance to the perturbation scale \sigma on LIBERO. With N=3, we evaluate \sigma\in\{0.05,0.10,0.25,0.50\} across the four task suites. As shown in Figure 9, the average success rate across suites ranges from 97.15\% to 97.55\%, a difference of 0.40 percentage points. Although individual suites exhibit variation, the average success rate changes little across the sigmas.

Appendix B GPU Inference Cost Analysis

Operation Characteristics of Action Expert.

Realizing benefits of multi-action chunks requires generating multiple candidate chunks without a proportional increase in inference latency in GPUs. At the single batch, the arithmetic intensities (AI) of the \pi_{0.5}, GR00T N1.5, and GR00T N1.7 action experts are 59, 63, and 43 FLOP/byte, respectively. When AI remains smaller than ridge-point of each GPU, inference remains on the memory-bound condition. The single-batch AI of VLA models lies in the memory-bound region of the roofline models for Jetson Orin and Thor, indicating that single-candidate generation does not fully utilize their compute throughput.

However, for the mulit-action chunk generation, B initial-noise tensors are stacked along the batch dimension and processed by the action expert at each flow-matching step, avoiding repeated execution of the full VLA inference pipeline. At a batch size of 6, the AI of \pi_{0.5}, GR00T N1.5, and GR00T N1.7 increases to 205.6, 190.6, and 182.4 FLOP/byte, respectively. Increasing the batch size to 8 further raises these values to 239.9, 222.1, and 223.0 FLOP/byte, exceeding the ridge point 207.5 FLOP/byte of Jetson Orin. Once the AI exceeds the ridge point, the operation turns into a compute-bound characteristic, where additional computation increases latency.

Accordingly, for Jetson Orin, all three models approach the ridge point at a batch size of 6, without increasing latency due to additional computation. For Jetson Thor, the operations remain memory-bound even at a batch size of 20, indicating that the available compute throughput is still not fully utilized. However, beyond a batch size of 10, the growing cost of loading activations, in addition to the cost of loading action expert weights, leads to a smooth increase in latency. Considering both hardware constraints and operation AI, these observations support setting the maximum batch size to 6 for Jetson Orin and 10 for Jetson Thor.

B.1 Inference latency and batching overhead

Total inference latency and additional latency per batch.

Table 6 reports measured total inference latency. On Jetson Orin, increasing the batch size B=1 to 5 results in latency increases of 3.5\%, 8.6\%, 12.1\% for \pi_{0.5}, GR00T N1.5, and GR00T N1.7, respectively. Batch size between B=10 to 20, total latency increases by 10.9\%, 42.2\%, and 33.0\% relative to B=10, respectively. Table 7 reports additional latency per batch, to quantify the cost of adding single action chunk. Specifically, increasing the baseline batch size from B=5 to B=10 raises the incremental latency from 10.25 to 15.37ms for \pi_{0.5}, from 2.56 to 4.29 ms for GR00T N1.5, and from 5.10 to 9.17ms for GR00T N1.7. Together with the roofline analysis, the measurements provide analytical and empirical support for the chosen generation budget.

B.2 GPU Profiling Setup

Environment setup.

VLA inference on edge device can become a latency bottleneck for responsive robot control, motivating inference acceleration. We therefore evaluate NVIDIA Jetson AGX Orin and Jetson AGX Thor as representative edge deployment platforms. Software environments and operating settings are listed in Table 8.

Inference Configurations

All models use bfloat16 without quantization. For each model-device pair, PICES and all baselines, including AAC and A^{3}, are evaluated on the same optimized model implementation. The \pi_{0.5} action expert uses device-tuned Triton kernels with CUDA graphs. GR00T System 1 uses the TensorRT deployment path provided by the official GR00T repository, while System 2 uses eager PyTorch with SDPA. We use 10 flow-matching steps for \pi_{0.5} and 4 for both GR00T models. We evaluate \pi_{0.5}/GR00T inference latency after a 90 s burn-in and 5/10 warm-up calls. Timing covers backbone inference and action generation from GPU-resident inputs, excluding input reprocessing, observation host-to-device transfer, environment interaction, and one-time initialization. PICES latency additionally includes probe construction and associated transfers, sensitivity computation, and candidate selection. Each PICES call generates N nominal and N perturbed chunks, with conditioning features computed once per call.

Appendix C Open-loop Evaluation of Reference-Action Agreement

Evaluation contexts and action chunks.

We evaluate open-loop action prediction error using the GR00T N1.7 SimplerEnv–Fractal checkpoint on the Fractal/RT-1 dataset. Concretely, we uniformly sample 1,000 contexts without replacement from valid windows containing eight consecutive actions within a single episode. Each context consists of the current image, robot state, and language instruction, together with the corresponding recorded action sequence. The recorded actions serve as the reference action chunk for evaluation of one to eight action horizon.

Candidate sampling.

We sample candidate chunks under identical conditioning inputs by drawing independent Gaussian initializations for each context. For PICES and the lowest-S_{n} variant, we generate one auxiliary chunk per candidate by adding Gaussian noise of scale \sigma=0.25 to its initial noise. These auxiliary chunks provide sensitivity estimates, while the action execution uses nominal chunks.

Root-Mean-Square-Error to measure action error.

Let \hat{\bm{a}}_{k} and \bm{a}_{k} denote the normalized prediction and reference vectors at action offset k. For a prefix of length h, the error is

\operatorname{RMSE}(h)=\sqrt{\frac{1}{dh}\sum_{k=0}^{h-1}\left\|\hat{\bm{a}}_{k}-\bm{a}_{k}\right\|^{2}}

where d is the action dimension. All action components and evaluated timesteps receive equal weight. We report means of the per-evaluation RMSEs.

Oracle selected action chunk.

The motivational study varies the number of nominal candidates from one to ten and evaluates fixed horizons of one to eight execution horizon. For each context and candidate set, the oracle selects the candidate with the lowest RMSE at the specified horizon. We then average these minimum errors to obtain the curves in Figure 3. Selection is performed separately at each horizon, so the chosen candidate may change along a curve. The oracle uses reference actions only for this analysis, and the dashed line marks the single-candidate, one-step baseline.

Fixed and adaptive horizon methods evaluation.

The fixed-step baseline evaluates a single nominal chunk at a prescribed horizon. PICES follows the selection procedure in Section 3.4, while the lowest-S_{n} variant selects the candidate with the lowest initial sensitivity and applies the same horizon-estimation rule. Both variants use an initial sensitivity window of one step. For each adaptive method, we compute prefix RMSE at the horizon selected for each context, then average the errors and selected horizons separately. Figure 5 reports the resulting mean RMSE against the mean selected horizon. We refer to Appendix E for the AAC and A^{3} configurations.

Appendix D Interpretation of Stepwise Action Sensitivity

Setup.

We fix the conditioning input \bm{c} and model parameters. Conditional on these fixed quantities, we sample \bm{\epsilon}^{(n)} with independent standard Gaussian entries. Let D=dH denote the dimension of the vectorized initial-noise matrix, and define

\rho^{(n)}=\|\bm{\epsilon}^{(n)}\|_{F},\qquad\bm{u}^{(n)}=\frac{\operatorname{vec}(\bm{\epsilon}^{(n)})}{\rho^{(n)}},\qquad\delta^{(n)}=\sigma\rho^{(n)}.

Here, \bm{u}^{(n)}\in\mathbb{R}^{D} is the unit perturbation direction, and \delta^{(n)} is the perturbation magnitude. Let \bm{J}_{k}^{(n)}\in\mathbb{R}^{d\times D} be the Jacobian of the action at offset k with respect to the vectorized initial noise, evaluated at \bm{Z}^{(n)}. This Jacobian differentiates the complete implemented action generator with respect to all initial-noise entries, including those associated with other action offsets. The index k denotes a future action offset.

Local directional interpretation.

Normalizing output differences by input displacement provides a finite-difference assessment of generator sensitivity, as used in Jacobian Clamping (Odena et al., 2018). Assume that the action-output map is differentiable at the nominal initialization. For a fixed sampled probe, a first-order expansion as \sigma\to 0 gives

\widetilde{\bm{a}}_{k}^{(n)}-\bm{a}_{k}^{(n)}=\delta^{(n)}\bm{J}_{k}^{(n)}\bm{u}^{(n)}+o\!\left(\delta^{(n)}\right).

Such Taylor expansions are standard in analyses of small input perturbations (Bishop, 1995). Substituting into Eq. equation 3 yields

\displaystyle G_{k}^{(n)} \\ \displaystyle=\frac{\|\widetilde{\bm{a}}_{k}^{(n)}-\bm{a}_{k}^{(n)}\|^{2}}{(\delta^{(n)})^{2}} \\ \displaystyle=\|\bm{J}_{k}^{(n)}\bm{u}^{(n)}\|^{2}+o(1).

Thus, for sufficiently small realized perturbations, the score approximates the squared norm of the directional derivative of the action at offset k.

Interpretation at finite perturbation magnitude.

For the finite perturbation used in generation, G_{k}^{(n)} measures the normalized squared action change along the sampled displacement. Its interpretation in terms of a directional derivative applies when the first-order approximation at the realized magnitude \delta^{(n)}=\sigma\|\bm{\epsilon}^{(n)}\|_{F}. The nonlinear remainder can affect the score at finite \delta^{(n)}, and normalization does not remove this effect. All action offsets of a candidate share the same perturbation, so the profile \{G_{k}^{(n)}\}_{k=0}^{H-1} describes how the corresponding actions respond to that perturbation. These scores are computed from the paired outputs without explicitly constructing the Jacobian. This local interpretation does not provide a bound on action prediction error. The usefulness of the profile for joint action-chunk and execution-horizon selection is evaluated empirically in Section 3.5.

Appendix E Detailed Experimental Setup and Benchmarks

Models and implementation. We evaluate PICES with three action-chunking VLA models: \pi_{0.5}, GR00T N1.5, and GR00T N1.7 (Intelligence et al., 2025; Bjorck et al., 2025). We use their official implementations and apply PICES at inference time without additional training. Specifically, we evaluate GR00T N1.7 on SimplerEnv–Fractal (Li et al., 2024b), \pi_{0.5} and GR00T N1.5 on LIBERO (Liu et al., 2023). For each model–benchmark configuration, we retain the action dimensionality specified by the corresponding official repository and use its default execution horizon for the fixed-horizon baseline.

Benchmarks and evaluation protocol. We conduct simulation experiments on SimplerEnv and LIBERO. For SimplerEnv, we evaluate six manipulation tasks in the Fractal (Google Robot) setting, with 100 episodes per task. For LIBERO, we evaluate four task suites: LIBERO-Spatial, LIBERO-Goal, LIBERO-Object, and LIBERO-Long (LIBERO-10), with 10 tasks per suite and 50 evaluation episodes per task.

• \pi_{0.5} on LIBERO. We use the released checkpoint and evaluation code provided by the official openpi repository, available at https://github.com/Physical-Intelligence/openpi.
• GR00T N1.5 on LIBERO. We use the released checkpoints for the four LIBERO suites and the evaluation scripts documented in the n1.5-release branch of the official Isaac-GR00T repository, available at https://github.com/NVIDIA/Isaac-GR00T/tree/n1.5-release.
• GR00T N1.7 on SimplerEnv–Fractal. We use the released Fractal checkpoint and evaluation scripts documented in the official Isaac-GR00T SimplerEnv example, available at https://github.com/NVIDIA/Isaac-GR00T/blob/main.

Real-world setup We evaluate our method across three manipulation tasks using a 6-DoF UR10e robot arm equipped with a Robotiq 2F-85 gripper: Tape, Stapler, and Cube. For each task, we collect 24 teleoperated demonstrations (72 in total) spanning varied initial object configurations. We evaluate each policy over 36 independent trials per task with randomized object placements. To assess both task effectiveness and computational efficiency, we report the Success Rate (%) and the average number of policy calls per episode. See Appendix F for the details.

Baseline and PICES configurations. We reproduce AAC, Autohorizon and A^{3} using the code released in their respective repositories, retaining the action-sampling budgets specified by the released implementations. We additionally evaluate sample-matched variants that generate the same number of action samples per batch as PICES to align the GPU latency of batched action generation. These variants are denoted by AAC∗ and A^{3*}. The matched sampling budget includes all N(1+1) nominal and perturbed action chunks generated by PICES.

Unless specified, PICES uses N=3 nominal candidates and a perturbation scale of \sigma=0.25. We use the default execution horizon specified by each model’s official repository as the reference-window length W. We set the reference-window length W to the default execution horizon specified in each model’s official repository for the corresponding benchmark. For GR00T N1.5 on LIBERO, whose default execution horizon is one step, we use five action steps, matching the default execution horizon of \pi_{0.5} on the same benchmark. This window defines the initial sensitivity reference for candidate assessment, while PICES adaptively selects the execution horizon h between W and the prediction horizon H.

Appendix F Real-World Experimental Setup

Robot platform and control.

As shown in Figure 10, our real-world experimental platform comprises a 6-DoF UR10e arm equipped with a Robotiq 2F-85 gripper. Visual observations are captured using RGB cameras streaming at 30 Hz. The robot is operated in operational space at a control frequency of 30 Hz, with actions parameterized as 7-dimensional vectors [\Delta x,\Delta y,\Delta z,\Delta\text{roll},\Delta\text{pitch},\Delta\text{yaw},g_{t}]\in\mathbb{R}^{7} representing end-effector Cartesian displacements, Euler angle rotations, and continuous gripper commands.

Manipulation Tasks.

We consider three contact-rich and fine-grained manipulation tasks: Tape Hanging, Stapler Pressing, and Cube Stacking, which are abbreviated by their respective object names as Tape, Stapler, and Cube in the main text, as shown in Figure 11. Tape Hanging requires picking up a tape from the table and hanging it onto the bottom branch of a multi-branch stand. Stapler Pressing requires positioning the end-effector over a desktop stapler and applying downward force to depress the top lever and actuate the stapling mechanism. Cube Stacking requires grasping the red cube, precisely stacking it atop the green cube, and retracting the end-effector upward with the gripper open, such that the tower remains stable without toppling.

Fine-tuning Configuration.

All demonstration trajectories are recorded at 30 Hz using a GELLO (Wu et al., 2023). For each task, we collect 24 teleoperated demonstrations (amounting to 72 trajectories in total) across diversified initial object configurations. We initialize our policy from the official \pi_{0.5}\text{-base} checkpoint provided by OpenPI (Physical Intelligence, 2024) and perform full-parameter fine-tuning on 4 \times NVIDIA RTX PRO 6000 Blackwell GPUs. The model is trained for 5,000 steps with an effective batch size of 128 (32 per GPU), corresponding to approximately 17.7 training epochs, using an action chunk prediction horizon of H=16.

Evaluation Protocol.

Each policy is evaluated on 36 independent trials per task (108 rollouts total) with 12 distinct initial object placements. We report the task success rate (%) and the average number of policy calls per episode to measure execution reliability and inference efficiency. Detailed training and deployment configurations are summarized in Table 9.

Appendix G Additional Related Work

Action Chunking in VLA Models.

Action chunking policy predicts a sequence of future actions conditioned on current observation, improving temporal consistency. Recent VLAs such as CogACT, \pi, and GR00T series use transformer-based action experts, implemented as Diffusion Transformers (DiTs), to model multimodal distributions over continuous action chunks (Li et al., 2024a; Black et al., 2024; Bjorck et al., 2025). At inference time, such policies execute only a fixed-length horizon of each predicted chunk. Executing a long fixed-length actions reduces policy calls but limits the incorporation of new observations, motivating adaptive execution horizons (Liang et al., 2026; Wang et al., 2026; Chen et al., 2026; Zhang et al., 2026). MoH requires auxiliary module for multiple horizons and uses cross-horizon agreement to determine an executable actions (Jing et al., 2025). DEHP uses a lightweight predictor trained with online reinforcement learning to adapt the execution horizon of a frozen pretrained action-chunking policy (Zhao et al., 2026). AAC estimates a single execution horizon from cross-sample action entropy (Liang et al., 2026). AutoHorizon estimates an execution horizon for each predicted chunk using the self-attention patterns (Wang et al., 2026). A^{3} selects a representative draft from sampled trajectories and determines execution horizon through an additional batched verification pass (Chen et al., 2026). In contrast, our method instead estimates a horizon for each candidate and uses the estimated execution length to jointly choose the trajectory and its execution extent in inferece time without training.

Acceleration for vision-language-action models

Recent works on efficient VLA inference seek to reduce cumulative inference time using various methods. SmolVLA overlaps action prediction with execution and evaluates efficiency using task-completion time and the number of successful pick-and-place operations within a fixed time budget (Shukor et al., 2025). To reduce inference overhead, prior work exploits redundancy in visual inputs and model computation through token pruning, channel pruning, and model scheduling (Wang et al., 2025; Li et al., 2025; Liu et al., 2025b; Huang et al., 2025; Huang et al., 2026; Feng et al., 2026). FastV, originally developed for vision-language models, prunes visual tokens using attention scores from early layers to reduce computation in subsequent layers (Chen et al., 2024). VLA-Cache exploits temporal redundancy by reusing cached key-value representations of minimally changed visual tokens across adjacent observations (Xu et al., 2026). GridS reduces the computational cost of vision-language-action models by learning task-aware sampling coordinates and extracting pruned visual tokens via differentiable bilinear interpolation (Feng et al., 2026). Our method is orthogonal to token pruning, which reduces computation within individual policy calls. DaDu-Corki predicts future trajectories to reduce expensive model invocations (Huang et al., 2025). PICES examines how candidate-specific horizon selection can reduce policy calls, while explicitly accounting for the additional cost of generating and assessing multiple action candidates.

Appendix H Detailed Simulation Results on LIBERO