PACT-VLA: Speculative Action-Chunk Verification with Pre-Commit Observations

Yixiang Zhu; Ruilong Wu; Yonghao Chen; Jiaxiang Zou; Yusong Hu; Xinyu Chen

cs.ROOct 20, 2026

PACT-VLA: Speculative Action-Chunk Verification with Pre-Commit Observations

Authors: Yixiang Zhu, Ruilong Wu, Yonghao Chen, Jiaxiang Zou, Yusong Hu, Xinyu Chen

Organizations: The Hong Kong University of Science and Technology (Guangzhou) · One Robotics

Abstract

Vision-language-action (VLA) policies are commonly deployed with asynchronous inference in real-world settings, where the next action chunk is generated while the robot is still executing the previous one. By the time the new chunk is committed, the robot and scene have changed, so the chunk is conditioned on a stale observation and task success drops sharply as this inference delay grows. Generating multiple candidate chunks could let newer observations inform the final choice, but existing multi-candidate methods either rank candidates with the stale inference-start observation or repeatedly switch between candidates during execution, which can make the executed action sequence discontinuous. Our key insight is that inference delay can be used as decision time. While candidate generation is still underway, candidate selection can reuse the VLA itself to choose the complete action chunk that best fits a later observation. We propose PACT-VLA, a training-free framework that generates candidates from the inference-start observation and selects one using this pre-commit observation. Its scoring function, FlowRes, measures the residual between each candidate's implied flow direction and the velocity predicted by the frozen policy under the pre-commit observation, requiring no separate verifier. A pipelined implementation overlaps observation processing with candidate generation and batches scoring, so selection adds no control-step delay on the evaluated hardware. At a four-step delay, PACT-VLA improves average success by 15.0 percentage points over RTC on Kinetix and by 5.2 points over single-candidate asynchronous execution with GR00T N1.7 on LIBERO, and it further improves existing delay-robust methods. On three real-robot tasks, it raises average success from 60% to 82% over naive asynchronous execution with the same frozen $π_{0.5}$ checkpoint.

Figures & tables

Panel of Figure 1 — Figure 1: Candidate-selection paradigms under delayed execution. (a) Candidates are generated and ranked using the same observation $o_{t}$ . (b) A learned predictive model predicts a trajectory for each candidate and repeatedly compares these trajectories with later observations during execution. $n_{1}^{\star}$ , $n_{2}^{\star}$ , and $n_{3}^{\star}$ denote the candidate indices selected at successive reselection points and may differ as new observations arrive. (c) PACT-VLA uses the original flow policy to rank the fixed candidate pool under the pre-commit observation $o_{t+d-1}$ before the planned chunk switch.

Figure 2: Overview of PACT-VLA. At control step $t$ , PACT-VLA uses the policy’s original generation procedure to produce a fixed pool of candidate action chunks from the information available at inference start. Before the planned chunk switch at $t+d$ , the pre-commit observation $o_{t+d-1}$ is used to evaluate the fixed candidates with FlowRes. The candidate with the lowest score is selected, and the controller switches to this chunk at $t+d$ . The lower branch illustrates how pre-commit observation processing can overlap with candidate generation, while the resulting representation is reused for batched candidate scoring.

Figure 3: FlowRes verification of one candidate. PACT-VLA constructs flow-time inputs from the fixed candidate and shared verification noise, queries the frozen policy under the pre-commit observation, computes the resulting velocity residuals, and aggregates them into candidate score

E_{n}

Method	$d{=}1$	$d{=}2$	$d{=}3$	$d{=}4$	Avg
Naive asynchronous	75.1	71.1	58.7	48.9	63.5
BID ( Liu et al., 2025b )	87.9	81.2	68.7	55.8	73.4
RTC ( Black et al., 2026 )	89.3	84.8	75.0	62.2	77.8
RTC, hard mask ( Black et al., 2026 )	85.0	81.8	73.2	62.0	75.5
PAINT-Euler ( Ho et al., 2026 )	85.0	80.4	73.2	63.8	75.6
Training-time RTC ( Black et al., 2025 )	88.5	86.0	80.0	72.1	81.7

Table 1: Kinetix success rate (%) across inference delays. Avg. denotes the mean over

d\in\{1,2,3,4\}

Proposal / + selection	$d{=}1$	$d{=}2$	$d{=}3$	$d{=}4$	Avg
VLASH ( Tang et al., 2025 )	88.3	86.1	84.0	80.4	84.7
+ PACT-VLA	89.4	88.6	87.3	85.0	87.5 ( $\uparrow$ 2.8)
DEFLECT ( Zhu et al., 2026 )	90.8	89.0	88.5	86.1	88.6
+ PACT-VLA	91.3	90.3	90.1	88.7	90.1 ( $\uparrow$ 1.5)
REMAC ( Wang et al., 2026 )	88.6	86.0	83.7	76.4	83.7
+ PACT-VLA	89.8	87.1	85.3	78.4	85.2 ( $\uparrow$ 1.5)

Table 2: PACT-VLA combined with existing delay-robust methods on Kinetix. Each pair shows the success rates (%) of a method with and without PACT-VLA.

$\pi_{0.5}$
	Goal		Spatial		Object		LIBERO-10		Average
Delay	Single	PACT-VLA	Single	PACT-VLA	Single	PACT-VLA	Single	PACT-VLA	Single	PACT-VLA
$d{=}1$	92.8	94.6	96.0	94.2	97.0	96.4	91.2	90.4	94.2	93.9 ( $\downarrow$ 0.3)
$d{=}2$	91.4	91.6	85.6	86.4	93.8	95.0	80.2	86.0	87.8	89.8 ( $\uparrow$ 2.0)
$d{=}3$	80.2	85.8	59.0	64.8	89.0	90.0	77.0	78.2	76.3	79.7 ( $\uparrow$ 3.4)
$d{=}4$	68.2	70.0	43.8	47.8	65.0	70.8	62.8	65.2	60.0	63.5 ( $\uparrow$ 3.5)

Table 3: LIBERO success rate (%) for

\pi_{0.5}

and GR00T N1.7. Each block compares single-candidate asynchronous execution with PACT-VLA.

Figure 4: Real-world evaluation. Example task stages and full-task success rates (%) for $\pi_{0.5}$ with Naive Async execution, VLASH, Old-FlowRes, and PACT-VLA. Old-FlowRes scores candidates using the generation observation, while PACT-VLA uses the pre-commit observation.

GPU	Generation ( $N=1$ )		Generation + Verification ( $N=4$ )
	Latency (ms)	$d$	Latency (ms)	$d$
RTX 5090	35.4	2	60.2	2
H100	42.5	2	58.8	2
RTX Pro 6000	48.7	2	64.8	2

Table 4: Generation and verification latency across GPUs. Each entry is the P99 latency measured on that GPU. The control-step delay

d

is calculated from the listed latency at 30 Hz.

Appendix figures & tables7 assets

Supplementary material from the paper’s appendix.

Appendix

Result	Protocol	Ckpt	Proposal	$N$	Evaluation count	$\sigma$
Table 1	continuous, $H{=}8$ , $d{\leq}4$	bc/31	RTC-guided	4	2048	0.1
Table 2 , VLASH	continuous, $H{=}8$ , $d{\leq}4$	async5	speculative	1 / 4	2048	0.1
Table 2 , DEFLECT	continuous, $H{=}8$ , $d{\leq}4$	DEFLECT	speculative	1 / 4	2048	0.1
Table 2 , REMAC	continuous, $H{=}8$ , $d{\leq}4$	REMAC LoRA	warm-start refine	1 / 4	2048	0.1
Table 3 , $\pi_{0.5}$	predict 50, execute 5, $d{\leq}4$	$\pi_{0.5}$ LIBERO	policy sampling	1 / 8	500	0
Table 3 , GR00T	predict 16, execute 8, $d{\leq}4$	GR00T N1.7 per suite	policy sampling	1 / 8	500	0

Appendix

Table 5: What differs between experiments. “Proposal” is where the

N

candidates come from. The main PACT-VLA configuration verifies candidates under the pre-commit observation

o_{t+d-1}

; alternative selectors and verification observations are specified in Appendix D . Evaluation counts are per Kinetix level or LIBERO suite for each method and delay.

Model	$\mathcal{T}$	Scored steps	$w_{j}$	Effective dims
Kinetix flow policy	$0.2,0.4,0.6,0.8$	all 8 predicted	$0.5^{\,j}$	all
$\pi_{0.5}$ (LIBERO)	$0.2,0.4,0.6,0.8$	first 5 (the executed ones)	uniform	7 of 32
GR00T N1.7	$0.1,0.3,0.5,0.7$	all 16 predicted	$0.5^{\,j}$	7 of 132

Appendix

Table 6: FlowRes settings for the simulation experiments. “Scored steps” is the range of

j

entering the sum, “weights” the

w_{j}

over that range, and “effective dims” the entries kept by

\mathbf{m}

Figure 5: One decision cycle on an RTX 5090 with

\pi_{0.5}

and

N{=}4

. Generation and verification share the same GPU. Encoding the pre-commit observation overlaps with candidate generation. Once the candidates are ready, scoring waits for this encoding to finish and then takes

1.7

ms. The full cycle takes

60.19

ms.

Suite	Baseline	Random pick	FlowRes on $o_{t}$	PACT-VLA
Goal	52.2	55.8	54.2	58.2
Spatial	53.6	53.2	52.8	56.8
Object	62.6	64.8	64.6	67.8
LIBERO-10	36.4	35.0	38.6	42.6
Average	51.2	52.2	52.6	56.4

Appendix

Table 7: Selector comparison on GR00T N1.7 at

d{=}4

, with success rates reported in percent. All methods use the same evaluation protocol and initial-state set. The baseline generates one candidate, while the three multi-candidate methods each generate eight. Each method runs separately without sharing candidate pools.

Suite	$d{=}1$	$d{=}2$	$d{=}3$	$d{=}4$
Goal	$-2.8$	$+1.2$	$+3.0$	$+4.0$
Spatial	$+1.0$	$+1.8$	$+5.0$	$+4.0$
Object	$+0.4$	$+0.4$	$+2.6$	$+3.2$
LIBERO-10	$-0.6$	$+0.8$	$+6.8$	$+4.0$
Average	$-0.5$	$+1.1$	$+4.3$	$+3.8$

Appendix

Table 8: PACT-VLA minus FlowRes on

o_{t}

for GR00T N1.7 , percentage points, by inference delay. At

d{=}1

both arms score under the same observation.

$d$	$\sigma$	Old ( $o_{t}$ )	PACT-VLA ( $o_{t+d-1}$ )
2	0.1	85.44	89.40
3	0.1	75.04	85.56
4	0.1	62.02	77.16
4	0.0	64.69	79.64
4	0.2	52.07	64.35

Appendix

Table 9: Episode success (%) on Kinetix when changing only the observation used for FlowRes scoring. Results are averaged over 12 levels.

Task	Demonstrations	Duration (h)	Mean length (s)
Toasting Bread	349	3.24	33.4
Loading Dishwasher	110	3.41	111.7
Pouring Coffee Beans	216	2.54	42.4
Total	675	9.19

Appendix

Table 10: Task-specific real-robot demonstration datasets.

Vision-Language-Action Models

Vision-language-action models turn visual observations and natural-language instructions into actions for robots and other embodied agents.

See all 1,190 papers

May 4, 2026

Understanding Asynchronous Inference Methods for Vision-Language-Action Models

Vision-Language-Action (VLA) models offer a promising path to generalist robot control, but their inference latency causes observation staleness when generated actions are executed asynchronously. Several methods have been proposed concurrently to mitigate this problem: inference-time inpainting (IT-RTC), training-time delay simulation (TT-RTC), future-state-aware conditioning (VLASH), and lightweight residual correction (A2C2). Each takes a fundamentally different approach, but they have so far been evaluated independently with different codebases, base policies, and protocols. We present a systematic comparison of these four methods under controlled conditions. We develop two unified codebases that integrate all methods with harmonized library and dataset versions, and we benchmark them on the Kinetix suite with MLPMixer policies and on the LIBERO manipulation benchmark with SmolVLA, sweeping inference delays up to

d=20

control steps. A2C2's per-step residual correction is the most effective method on Kinetix, holding above 90% solve rate up to

d=8

, and also leads on LIBERO from

d=4

onwards. IT-RTC is competitive at low delays but degrades sharply under long chunks (

H=30

) and high delays. TT-RTC is the most robust training-based method: stable across

d_\max

choices, generalizes beyond its training delay distribution, and adds zero inference overhead. VLASH exhibits a clear low-delay vs. high-delay trade-off governed by the fine-tuning delay range

[0,d_\max]

. Code is available at https://github.com/TheAyos/async-vla-inference

Ayoub Agouzoul

École polytechnique · Systems Group, ETH Zürich

Robotic Control Efficient VLM Inference Efficient VLA Model Inference Robotic Manipulation Vision-Language-Action Models

Ask PDF

May 19, 2026

DEFLECT: Temporal Counterfactual Preference Learning for Delay-Robust Asynchronous VLAs

Vision-Language-Action (VLA) policies increasingly rely on asynchronous inference to hide model latency behind ongoing robot motion. During inference, the robot continues executing its current action chunk while the next chunk is generated from the observation available at inference start. By the time the new chunk is executed, the robot or scene may have changed, so an action that fits the prediction-time state can be misaligned with the execution-time state. Training-time methods modify the policy input or supervised target based on the expected execution delay, but do not directly supervise how actions should change as the scene evolves between prediction and execution. Runtime repair methods improve chunk continuity or modify actions during deployment, but can still leave actions aligned with the prediction-time state rather than the execution-time state. Our key insight is that execution-time observations are unavailable when the online prediction is made but are available in recorded trajectories during offline training, making the prediction-execution mismatch observable during training. We propose DEFLECT, an offline post-training framework that turns this temporal contrast into preference supervision for a policy acting from stale inputs. Across Kinetix, LIBERO, and three real-robot tasks, DEFLECT improves delay robustness across the evaluated VLA policies and settings. At the longest supported delay, it improves success by 4.2 percentage points over VLASH on Kinetix and by 22.7 points over naive asynchronous execution with GR00T N1.7 on LIBERO.

Yixiang Zhu, Yonghao Chen, Jiaxiang Zou +2

The Hong Kong University of Science and Technology (Guangzhou) · One Robotics

Robotic Control Visuomotor Policy Learning Vision-Language-Action Models VLMs for Robotics Preference Learning

Ask PDF

Oct 14, 2026

Accelerating VLA Inference with Perturbation Informed Execution

Action-chunking vision-language-action (VLA) models predict sequences of future robot actions. Under fixed-horizon execution, the robot executes a fixedlength 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.3x in wall-clock policy inference time on Jetson Orin and Thor relative to fixed horizon baselines while improving the success rate.

Jehun Lee, Hajun Lee, Jimin Ryu +4

Seoul National University

Efficient VLA Model Inference Vision-Language-Action Models VLMs for Robotics Robot Policy Learning

Ask PDF

Abstract

Vision-Language-Action Models

Explore similar work

Understanding Asynchronous Inference Methods for Vision-Language-Action Models

DEFLECT: Temporal Counterfactual Preference Learning for Delay-Robust Asynchronous VLAs

Accelerating VLA Inference with Perturbation Informed Execution