Skip to content

PACT-VLA

They said choosing among several motion chunks with the newest camera frame adds no delay. On recorded runs we tested the choice, and on the robot's computer the delay. The choice helped, but a full cycle took 1,200 ms, 37 control ticks instead of 8.

Delay in control ticks (lower is better): naive async 8 ticks; PACT 37 ticks; bar ≤ naivenaive async8 ticksPACT37 ticksbar ≤ naive

Papers tested · 20 of 22

Goal (the paper's): Under asynchronous execution, sample several candidate chunks and keep the one the frozen policy finds most consistent with the newest observation before the switch, with no verifier to train and no added control-step delay; shown on Kinetix, LIBERO and a bimanual PiperX.

Its hypotheses:

  • Selecting by flow residual under the pre-commit observation picks better chunks than a random pick or the stale observation. (Appendix D.2; Fig. 4) reproduces
  • The selection adds no control-step delay, because the extra pass overlaps with execution. (§3 (pipelining), Table 4) fail

Verdict: fail · Claim tested: Picking among N sampled chunks by their flow residual under the pre-commit observation fits what happens next better than a random or stale pick, with no added control-step delay. · Bar: PACT beats a random pick and the stale-observation residual at d = 8 (CIs < 0); its delay on the Orin ≤ the naive delay; at that delay it still beats a single sample. · n: 20 episodes, 254 boundaries per delay

Theirs vs ours: bimanual PiperX 82.0 % vs naive async 60.0 %; no added control-step delay on the evaluated GPUs (generation 35–49 ms, with verification 59–65 ms, both d = 2 at 30 Hz, Table 4) vs offline −0.27° vs random and vs the stale residual (both CIs < 0); on the Orin 1,200 ms per cycle, 37 control ticks vs 8 · Not proven: The verification time is projected (vla.cpp has no velocity query); at the measured delay a 50-step chunk cannot fill the executed window, so the transfer clause is not computable; no arm run.

Paper: arXiv 2610.28019 · Code: no code link found

Claims:

  • reproduces PACT selection below random pick on executed-window error — theirs +0.44 points over random (Kinetix); 82.0 vs 60.0 % (PiperX) · ours −0.27° error vs a random pick (CI −0.44 to −0.09) (paper Appendix D and Fig. 4)
  • fail PACT cycle equals naive async cycle on control-step delay — theirs no added delay · ours 37 ticks vs 8 (paper ("no added control-step delay" on the evaluated hardware; Table 4: generation 35–49 ms, with verification 59–65 ms, both d = 2))
  • reproduces PACT cycle above naive async cycle on control-step delay · ours 37 ticks vs 8 (our measured comparison)

Compute: External GPU: no. Gate B on the Orin NX at 25 W (PyTorch); gate A on the Orin at MAXN_SUPER + jetson_clocks. Cost: $0. · Reproduce: 2026-10-30-paper-vs-hardware-pact · First published: 2026-10-30 · Updated: 2026-10-30

PACT-VLA: Speculative Action-Chunk Verification with Pre-Commit Observations (Zhu et al., arXiv 2610.28019) samples several chunks and keeps the one the policy itself finds most consistent with the latest frame before the switch, "with no added control-step delay". The selection works on my recorded episodes. The delay is where it breaks on a Jetson.

What the paper claims, and how it measures it

Under asynchronous execution the robot keeps moving while the next chunk is computed, so the chunk is planned from a stale frame. PACT generates N = 4 candidates, then scores each with the policy's own flow residual (FlowRes) under the pre-commit observation, the frame one control step before the switch, and keeps the lowest. On a bimanual AgileX PiperX with π0.5 it reaches 82.0 % against 60.0 % for naive async, at 35–49 ms per chunk on an RTX 5090 or H100, and the extra pass is hidden by overlap.

What I ran

SmolVLA on the same 20 recorded bowls episodes, 254 chunk boundaries per delay, four candidates per boundary. Bars frozen before any number:

  • B-P1 / B-P2: at a delay of 8 steps (238 ms at 30 Hz, this rig's real delay), PACT's chunk is closer to what was actually executed than a random pick, and than the same residual under the stale frame (episode bootstrap, CI entirely below 0).
  • A: on the Orin at full power, PACT's cycle adds no control step: d_PACT ≤ d_naive (fail if two or more).
  • B-P3: at the delay PACT actually costs on the Orin, it still beats a single sample.

Checks before reading any number: candidate 0 bit-identical to a single sample, the recorded future scored below the median candidate on 68 % of boundaries (bar 60 %), and a shuffled observation does not pass B-P1.

Their number, my number

Paper This rig
selection vs random pick +0.44 points (Kinetix, one decision); 82.0 vs 60.0 % on the robot −0.27° error (CI −0.44 to −0.09)
selection vs stale-frame residual stale = random (Kinetix) −0.27° (CI −0.48 to −0.09); stale = random here too
cycle time 35–49 ms per chunk, extra pass overlapped 1,200 ms vs 237 ms
control-step delay none added 37 ticks vs 8

B-P1 and B-P2 pass: choosing with the fresher frame picks better chunks, and the residual under the stale frame is no better than chance, as the paper's own appendix found. The fresher observation does the work.

A fails by 29 ticks. vla.cpp has no batched sampler, so the four candidates are four chunk inferences (950 ms), plus a second vision and prefill pass on the pre-commit frame (166 ms) and the verification (85 ms, projected from a PyTorch ratio because vla.cpp has no velocity query). The Orin's GPU is already 94–98 % busy during a chunk, so nothing overlaps. B-P3 cannot be computed as written: at a 37-step delay, a 50-step chunk holds only 13 of the 25 steps PACT would have to execute.

What the gap means

The idea is sound and the selection signal is real on a 450M policy and a ≈ €1,350 rig. "No added delay" is a property of a desktop GPU with spare capacity: on an edge GPU running at capacity, every candidate and the second pass are paid in sequence.

Verdict: the selection replicates offline; the paper's no-delay claim fails on the Orin, so PACT does not transfer to this rig.

What would change it: batched sampling and a velocity query in vla.cpp, which would make the cycle closer to one chunk plus a pass.

Compute. External GPU: no. Gate B on the Orin NX at 25 W (PyTorch); gate A on the Orin at MAXN_SUPER + jetson_clocks. Cost: $0.
Reproduce this: 2026-10-30-paper-vs-hardware-pact

Papers tested, 20 of 22. ← Papers tested 19: Adaptive Action Chunking (AAC) · Papers tested 21: Horizon × depth (Euler steps vs execution horizon) →