Organizations: Institute of Computing Technology, Chinese Academy of Sciences, Beijing, China · University of Chinese Academy of Sciences, Beijing, China · Zhongke Haichuan Intelligent
Vision-language-action (VLA) policies based on flow matching generate action chunks through repeated evaluations of an action expert. Increasing the number of integration steps raises inference cost, but does not necessarily improve closed-loop success. We propose Coda, which reallocates part of this integration budget to a single learned endpoint correction. A frozen policy first completes a few-step noise-to-action trajectory; a lightweight Transformer then predicts a demonstration-supervised residual using the candidate action, source noise, and shared observation-prefix cache. Only the corrector is trained. On 50 RoboTwin Easy tasks, five-step Coda improves success from 71.64% to 74.68% over the matched five-step baseline, while reducing forward latency by 30.2% relative to the default ten-step policy. A two-step configuration achieves 71.88% success with a 2.12× speedup. An independent 13-task control shows a 5.69-percentage-point gain at nearly equal latency, supporting correction as an effective alternative to additional integration. The same design also improves frozen official SmolVLA, raising two-step success from 60.8% to 69.4%. These results show that endpoint correction improves the quality-latency trade-off of frozen flow-matching policies.
Figures & tables
Figure 1: Compute allocation. Ten-step and few-step generation both cover the full noise-to-action interval. Coda reallocates part of the serial integration budget to one learned endpoint correction; the target and offsets are schematic.
Figure 2: Coda inference. A frozen VLM encodes the three camera views and instruction once; in π0.5 , discretized robot state is also included in the text prefix. Both modules reuse the prefix KV cache. The frozen AE completes N Euler steps, and Coda uses the candidate and the same source noise to predict a residual in one forward. The residual is added to the candidate before execution. A line bridge denotes a crossing without a connection. Only Coda is trainable.
AE-NFE
1
2
3
4
5
10
π0.5 -FT
59.76
67.40
71.28
69.96
71.64
71.52
Coda
69.80
71.88
73.64
73.12
74.68
72.60
Table I: Success on 50 Easy tasks (%). Each method has 50 episodes per task at every NFE. Bold indicates the higher mean at each NFE.
Figure 3: Diminishing returns of frozen π0.5 on the 50-task panel. (a) Success versus AE steps. (b) Measured forward latency versus AE steps. The highlighted 5-to-10-step segment changes success by −0.12 percentage points while increasing latency by 61.0%.
Method
AE-NFE
Success (%)
Latency (ms)
π0.5 -FT
5
70.40
193.39
π0.5 -FT
6
71.69
218.14
π0.5 -FT
10
73.02
318.98
Coda-MLP
5
73.63
195.63
Coda-Transformer
5
77.38
218.59
Table II: Independent 13-task compute-allocation panel. Each method has 621 valid episodes; timing uses an A100 40GB.
Figure 4: Where to spend the inference budget. The baseline line connects measured 5-, 6-, and 10-step policies. At approximately 219 ms, Coda improves success by 5.69 points over six-step generation. Upper-left is better; this panel uses the independent 13-task protocol in Table II .
Figure 5: Deployment landscapes on A100 80GB: (a) π0.5 , 50 tasks; (b) frozen official SmolVLA, 10 tasks. Upper-left is better. Point labels (2, 5, 10) indicate the number of AE integration steps (NFE); Coda adds one correction forward at each setting. Lines connect measured points at NFE ≥2 , and arrows highlight improvements over the default ten-step policy. One-step success is retained in Tables I and IV . The panels use separate host policies and evaluation protocols.
GPU
Method
N
P
A
R
Total
Speedup
A100
π0.5 -FT
10
55.8
175.6
0.0
233.0
1.00×
π0.5 -FT
5
55.8
88.0
0.0
144.7
1.61×
Coda
5
55.7
88.0
17.8
162.6
1.43×
π0.5 -FT
3
57.1
54.3
0.0
112.7
2.07×
Coda
2
55.9
35.3
17.9
109.9
2.12×
4090
π0.5 -FT
10
62.7
182.1
0.0
246.5
1.00×
Table III: Measured median forward latency (ms). P/A/R denote prefix, AE, and residual stage times. Speedup is relative to the same-GPU ten-step baseline. Bold highlights Coda deployment points.
AE-NFE
1
2
5
10
Official frozen
35.0
60.8
60.8
64.4
AE-cont
48.2
64.6
70.8
69.2
Coda ( +ε )
55.8
69.4
72.0
72.6
Coda (no ε )
58.2
71.4
75.2
74.8
Table IV: SmolVLA success on 10 Easy tasks (%). Each configuration completes 500 episodes. AE-cont and Coda ( +ε ) use checkpoint 18716; the no- ε variant uses checkpoint 18000.
Figure 6: Endpoint diagnostics. (a) Hanging-mug success with 95% Wilson intervals; the dashed divider separates the privileged GT-mix probe from deployable policies. (b) Reduction in mean open-loop action error relative to FT5; Mix denotes Mix-AE. Direct Coda execution preserves the largest reduction.
Appendix figures & tables3 assets
Supplementary material from the paper’s appendix.
Appendix
Input: observation o , AE-NFE N , recipe ∈{π0.5-FT,Coda,Mix-AE} .
Frozen: fVLM , vθ . On π0.5 , Coda uses residual rϕ at tres=0.1 ; SmolVLA does not use that time conditioning.
1. Encode o once: zo=fVLM(o) . Cache prefix key-value tensors.
2. Draw ε∼N(0,I) (use the host policy’s evaluation noise stream). Set x[0]=ε .
3. For i=0,…,N−1 : x[i+1]=x[i]−N1vθ(x[i],ti,zo) , ti=1−i/N .
4. Set aθ=x[N] .
5. π0.5 -FT: execute aθ and stop.
Appendix
Table V: Inference at AE-NFE N . π0.5 -FT stops at aθ ; Coda adds one residual; Mix-AE is ablation only.
π0.5 -FT
Coda
Cont
SmolRes
Init
π0.5 FT
FT@60k
FT@60k
official
Trainable
VLM + AE
residual only
AE
residual only
Global batch
48
960
48
256
Steps
60 k
3 k
21 k
4 ep
Frames
2.88 M
2.88 M
1.01 M
4 epochs
Peak lr
2.5×10−5
5×10−5
2.5×10−5
1×10−4
Appendix
Table VI: Training hyperparameters. π0.5 -FT / Coda / Cont use the 50 -task RoboTwin clean50 mixture. SmolVLA residual uses the official 10 -task set; official SmolVLA stays frozen.
Easy
Hard
Smol Easy
Suite
RoboTwin 2.0
RoboTwin 2.0
RoboTwin 2.0
Split
demo_clean_50
demo_randomized_50
demo_clean_50
Tasks
50
50
official 10
Shader
default (rt32)
minimal
default
Target n
50
mid- 20 s– 49
50
Seeds
100000+i
100000+i
100000+i
Appendix
Table VII: Environments for every closed-loop and latency number in the main text. Easy and Hard use π0.5 ; Smol Easy uses official SmolVLA.
Reinforcement learning can improve vision-language-action (VLA) policies beyond supervised fine-tuning, although this typically involves further updates to the policy parameters. For flow-matching policies, iterative action generation provides an additional opportunity to incorporate task information during inference. We introduce Guided Action Flow (GAF), which learns a compact, observation-conditioned action-value critic from robot task rollouts and applies its action gradient to steer reverse-time flow sampling. The supervised-fine-tuned VLA remains frozen throughout critic learning and deployment. Physical-robot experiments show an increase in aggregate success from 60.0% to 82.5% across six nominal manipulation tasks. Under six altered-lighting and object-distractor conditions evaluated on three of these tasks, aggregate success improves from 34.2% to 49.2%. Ablations and rollout analyses support the importance of the learned guidance direction and the critic's visual and proprioceptive inputs. With approximately 2.735M trainable critic parameters alongside a 0.45B-parameter VLA, GAF enables task outcomes to inform action generation through a compact inference-time guidance module.
Liuhaichen Yang, Zhuang Jiang, Chenchao Sheng +8
Department of Computer Science, University College London. · Department of Mechanical Engineering, University College London.
Vision-Language-Action (VLA) policies that execute fixed-length action chunks can exhibit multimodal bifurcation: a cross-chunk inconsistency in which adjacent chunks generated from independent Gaussian latents can converge to incompatible trajectory modes, producing abrupt discontinuities at chunk boundaries. Existing remedies either require backpropagation through the policy at each denoising step, rely on rejection sampling, or require retraining, each trading computational cost or task reliability for smoother transitions. We propose SEAM (Smooth Execution of Action-Chunked Motion), a training-free inference-time method for flow matching VLAs. SEAM exploits a simple synchronous-execution insight: after the robot consumes the executed prefix, the previous chunk's unexecuted tail is already available as an analytic consistency reference. Its core mechanism, Velocity-guided Loss Steering (VLS), derives a time-dependent target from this tail and applies a closed-form correction after each Euler step without backpropagating through the policy network. On LIBERO-10 with pi_0.5, SEAM reduces boundary jerk by 28%, reduces chunk transition discontinuity by 27%, preserves baseline-level task success, and keeps denoising-loop cost near the unguided baseline.
Vision-Language-Action (VLA) models based on flow matching -- such as pi0, pi0.5, and SmolVLA -- achieve state-of-the-art generalist robotic manipulation, yet their iterative denoising, typically 10 ODE steps, introduces substantial latency: on a modern GPU, denoising alone accounts for 80% of end-to-end inference time. Naively reducing the step count is unreliable, degrading success on most tasks due to the velocity field being uncalibrated for single-step jumps. We present SnapFlow, a plug-and-play self-distillation method that compresses multi-step denoising into a single forward pass (1-NFE) for flow-matching VLAs. SnapFlow mixes standard flow-matching samples with consistency samples whose targets are two-step Euler shortcut velocities computed from the model's own marginal velocity predictions, avoiding the trajectory drift caused by conditional velocities, as we analyze theoretically. A zero-initialized target-time embedding lets the network switch between local velocity estimation and global one-step generation within a single architecture. SnapFlow requires no external teacher, no architecture changes, and trains in ~12h on a single GPU. We validate on two VLA architectures spanning a 6x parameter range, with identical hyperparameters: on pi0.5 (3B) across four LIBERO suites (40 tasks, 400 episodes), SnapFlow achieves 98.75% average success -- matching the 10-step teacher at 97.75% and slightly exceeding it -- with 9.6x denoising speedup and end-to-end latency reduced from 274ms to 83ms; on SmolVLA (500M), it reduces MSE by 8.3% with 3.56x end-to-end acceleration. An action-step sweep on long-horizon tasks reveals that SnapFlow maintains its advantage across execution horizons, achieving 93% at n_act=5 where the baseline reaches only 90%. SnapFlow is orthogonal to layer-distillation and token-pruning approaches, enabling compositional speedups.
Wuyang Luan, Junhui Li, Weiguang Zhao +3
Jilin University · Chongqing University · University of Liverpool +1