Paper deep dive
SnapFlow: One-Step Action Generation for Flow-Matching VLAs via Progressive Self-Distillation
Wuyang Luan, Junhui Li, Weiguang Zhao, Wenjian Zhang, Tieru Wu, Rui Ma
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 97%
Last extracted: 4/10/2026, 3:18:01 AM
Summary
SnapFlow is a plug-and-play self-distillation method for Vision-Language-Action (VLA) models that compresses iterative multi-step flow-matching denoising into a single forward pass (1-NFE). By mixing standard flow-matching samples with two-step Euler shortcut consistency targets and utilizing a zero-initialized target-time embedding, SnapFlow achieves state-of-the-art robotic manipulation success rates while significantly reducing end-to-end inference latency (e.g., 9.6x speedup on pi0.5).
Entities (5)
Relation Signals (3)
SnapFlow → evaluatedon → LIBERO
confidence 99% · We validate on two VLA architectures... across four LIBERO suites
SnapFlow → accelerates → pi0.5
confidence 98% · SnapFlow achieves 98.75% average success—matching the 10-step teacher at 97.75% and slightly exceeding it—with 9.6x denoising speedup
SnapFlow → improves → SmolVLA
confidence 98% · on SmolVLA (500M), it reduces MSE by 8.3% with 3.56x end-to-end acceleration
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract: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.
Tags
Links
- Source: https://arxiv.org/abs/2604.05656v1
- Canonical: https://arxiv.org/abs/2604.05656v1
Trouble viewing inline? Open PDF directly →
Full Text
68,600 characters extracted from source content.
Expand or collapse full text
SnapFlow: One-Step Action Generation for Flow-Matching VLAs via Progressive Self-Distillation Wuyang Luan Jilin University luanwy25@mails.jlu.edu.cn &Junhui Li Chongqing University junhuili@stu.cqu.edu.cn &Weiguang Zhao University of Liverpool weiguang.zhao@liverpool.ac.uk &Wenjian Zhang GenY zhangwenjian@genycc.cn &Tieru Wu Jilin University wutr@jlu.edu.cn &Rui Ma Jilin University ruim@jlu.edu.cn Corresponding author (industry).Corresponding author. Abstract Vision-Language-Action (VLA) models based on flow matching—such as π 0, π 0.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. Naïvely 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 6×6× parameter range, with identical hyperparameters: on π 0.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.6× denoising speedup and end-to-end latency reduced from 274 ms to 83 ms; on SmolVLA (500M), it reduces MSE by 8.3% with 3.56× end-to-end acceleration. An action-step sweep on long-horizon tasks reveals that SnapFlow maintains its advantage across execution horizons, achieving 93% at nact=5n_act\!=\!5 where the baseline reaches only 90%. SnapFlow is orthogonal to layer-distillation and token-pruning approaches, enabling compositional speedups. 1 Introduction Vision-Language-Action (VLA) models Black et al. (2024); Intelligence et al. (2025); Kim et al. (2024); Team et al. (2024) have advanced generalist robotic manipulation, with π 0 Black et al. (2024) and π 0.5 Intelligence et al. (2025) generating action trajectories via flow matching Lipman et al. (2023): a learned velocity field iteratively denoises Gaussian noise into a coherent action chunk through 10 Euler steps. This iterative process is the primary inference bottleneck. On an A800 GPU, each denoising step of π 0.5 takes ∼ 23 ms; the 10-step chain consumes ∼ 241 ms—80% of the total 274 ms end-to-end latency, with the remaining 60 ms spent on the shared VLM prefix. On edge devices the problem is more acute: at 3 Hz control frequency each cycle allows only ∼ 330 ms for perception and action generation, leaving almost no headroom for 10-step denoising. Can fewer Euler steps suffice? Naïvely reducing the step count is unreliable: on LIBERO, 1-step inference drops from 97.75% to 96.75% average success. The velocity field learned for 10-step integration is not calibrated for single-step jumps. We propose SnapFlow, a self-distillation method that trains a flow-matching VLA to generate high-quality actions in a single forward pass. SnapFlow mixes standard flow-matching samples that preserve multi-step capability with consistency samples whose target is the average velocity along a two-step Euler shortcut. A learnable target-time projection lets the network distinguish these two objectives within a single architecture, progressively “straightening” the velocity field for accurate single-step generation. Evaluated on π 0.5 across all four LIBERO suites following the protocol of Intelligence et al. (2025), SnapFlow at 1-step achieves 98.75% average success, matching the 10-step teacher at 97.75% and slightly exceeding it. The consistency objective directly optimizes single-step predictions, whereas multi-step Euler integration compounds discretization errors as predicted by Theorem 3. SnapFlow delivers a 9.6× denoising speedup, reducing end-to-end latency from 274 ms to 83 ms. Contributions. • SnapFlow: A progressive self-distillation framework that achieves 1-NFE inference for flow-matching VLAs via FM/consistency sample mixing and a target-time embedding—requiring no external teacher, no architecture changes, and only ∼ 12h of training on a single A800. • Favorable quality–speed trade-off in tested settings: SnapFlow 1-step achieves 98.75% average success on LIBERO, matching the 10-step baseline at 97.75% and slightly exceeding it, with 9.6× denoising speedup. • Generality and orthogonality: Validated on two representative flow-matching VLAs spanning 500M–3B with identical hyperparameters; orthogonal to layer-distillation methods Jeon et al. (2026), enabling compositional speedups. 2 Related Work Flow-Matching VLAs and Their Latency Bottleneck. π 0 Black et al. (2024) introduced flow matching as the action head for generalist VLAs; π 0.5 Intelligence et al. (2025) scales this to 3B parameters; SmolVLA Shukor et al. (2025) provides a lightweight ∼ 500M alternative; complementary open VLA baselines include OpenVLA Kim et al. (2024) and Octo Team et al. (2024). All share a critical bottleneck: iterative Euler denoising—typically 10 sequential forward passes through the action expert—dominates end-to-end latency. VLA Inference Acceleration. Recent works attack VLA latency from two complementary angles. Architecture compression: Shallow-π Jeon et al. (2026) distills the π 0.5 transformer from 18 to 6 layers for 2× speedup; EfficientVLA Yang et al. (2025) dynamically skips layers and prunes visual tokens for 1.9×. Sampling compression: our work belongs to this category—reducing the number of denoising steps rather than the per-step cost. The two axes are orthogonal and compose multiplicatively; see Sec. 4.4. Fast Flow Models. Consistency Models Song et al. (2023) enforce trajectory self-consistency for single-step generation and are closely related to continuous-time consistency formulations Lu and Song (2025), with foundations in score/diffusion modeling Song et al. (2020); Ho et al. (2020); Sohl-Dickstein et al. (2015); Karras et al. (2022). In the flow-matching setting, MeanFlow Geng et al. (2025a) models average velocity; ShortCut Frans et al. (2025) uses two-step target decompositions; α-Flow Zhang et al. (2025) introduces FM-to-consistency curricula. Prior work identifies trajectory drift from conditional velocities and proposes corrected consistency objectives. These methods target image or video generation. Fast Sampling for Robot Policies. Consistency Policy Prasad et al. (2024) applies consistency distillation to small DDPM U-Net policies with an EMA target network, building on diffusion-policy style robot control formulations Chi et al. (2023); Ajay et al. (2022); Janner et al. (2022); Carvalho et al. (2023); Ke et al. (2024). FlowPolicy Zhang et al. (2025b) uses consistency flow matching on 3D point clouds for single-step generation; ManiFlow Yan et al. (2025) combines consistency flow training with a DiT-X architecture for 1–2 NFE manipulation across 60+ tasks; FreqPolicy Wang et al. (2025b) introduces frequency-domain consistency constraints on LIBERO. SnapFlow differs in three respects: theoretical grounding in the corrected consistency objective of Theorems 1–3, which avoids trajectory drift; minimal intervention—a single zero-initialized MLP with no EMA, no auxiliary networks, and no frequency transforms; and comprehensive evaluation on billion-parameter VLAs across four LIBERO suites. 3 Method Figure 1: SnapFlow overview. SnapFlow is a plug-and-play self-distillation method for flow-matching VLAs. During training, it mixes flow-matching and two-step Euler shortcut objectives; at inference, a single forward pass replaces the 10-step denoising loop. The VLM prefix is shared and unmodified. We first review flow matching in VLAs (Sec. 3.1–3.2), analyze the trajectory consistency problem (Sec. 3.3), and then present the SnapFlow framework (Sec. 3.4–3.6). 3.1 Preliminaries: Flow Matching in VLAs Flow-matching VLAs Black et al. (2024); Intelligence et al. (2025) generate action chunks 0∈ℝH×Dx_0 ^H× D by learning a velocity field conditioned on a context c encoding the observation and language instruction. Given a ground-truth action 0x_0 and noise ϵ∼(,) ε (0,I), a flow path is defined by linear interpolation: t=(1−t)0+tϵ,t∈[0,1] _t=(1-t)\,x_0+t\, ε, t∈[0,1] (1) The velocity along this path is the conditional velocity t=ϵ−0v_t= ε-x_0, determined by the specific pair (0,ϵ)(x_0, ε). Since multiple pairs can produce the same tx_t, the marginal velocity field is defined as t(t)=[t∣t]u_t(x_t)=E[v_t _t]. Flow matching trains a network FθF_θ to approximate tu_t using the conditional velocity as a surrogate: ℒFM=t,0,ϵ[∥Fθ(t,t,t∣)−(ϵ−0)∥2] _FM=E_t,x_0, ε\! [ \|F_θ(x_t,t,t )-( ε-x_0) \|^2 ] (2) Here Fθ(t,s,t∣)F_θ(x_t,s,t ) denotes the predicted average velocity from t to target time s; at s=ts\!=\!t this reduces to the instantaneous velocity. At inference, the model starts from pure noise 1∼(,)x_1 (0,I) and integrates backward using K-step Euler: t−Δt=t−Δt⋅Fθ(t,t,t∣),Δt=1/K _t- t=x_t- t· F_θ(x_t,t,t ), t=1/K (3) In π 0.5, K=10K\!=\!10 is the default, requiring 10 sequential forward passes through the action expert. 3.2 Fast Flow Models and Average Velocity Rather than using many Euler steps to approximate the ODE integral, a fast flow model directly learns the average velocity between time t and a target time s<ts<t, enabling a linear mapping Geng et al. (2025a); Zhang et al. (2025): fθ(t,s,t)=t−(t−s)Fθ(t,s,t∣) f_θ(x_t,s,t)=x_t-(t-s)\,F_θ(x_t,s,t ) (4) where Fθ(t,s,t)F_θ(x_t,s,t) approximates the true average velocity avg(t,s,t)=1t−s∫st(τ,τ)τu_avg(x_t,s,t)= 1t-s\! _s^t\!u(x_τ,τ)\,dτ. Setting s=0s\!=\!0 and t=1t\!=\!1 yields the desired 1-NFE mapping from noise to action: 0^=1−Fθ(1,0,1) x_0=x_1-F_θ(x_1,0,1). The trajectory consistency objective Song et al. (2023); Geng et al. (2025a) enforces that the predicted endpoint fθ(t,s,t)f_θ(x_t,s,t) is invariant to the starting time t along the same trajectory: t[‖dtfθ(t,s,t)‖2]=t[‖∇tfθ⋅t+∂tfθ‖2]=0 _x_t\! [ \| ddtf_θ(x_t,s,t) \|^2 ]=E_x_t\! [ \| _x_tf_θ·u_t+ _tf_θ \|^2 ]=0 (5) In practice tu_t is unknown and is typically replaced by the conditional velocity t=ϵ−0v_t= ε-x_0. For standard flow matching at s=ts\!=\!t, this substitution is valid because [t∣t]=tE[v_t _t]=u_t. However, for fast flow models that require trajectory consistency across a finite time span s≠ts≠ t, we show below that this substitution introduces systematic drift. 3.3 Trajectory Consistency Analysis Two theoretical results motivate SnapFlow’s design; complete proofs are in Appendix A. Theorem 1 (Conditional–Marginal Velocity Discrepancy). Let 0∼pdatax_0 p_data be non-degenerate (not a Dirac mass) and ϵ∼(,) ε (0,I). Let t=ϵ−0v_t= ε-x_0 be the conditional velocity and t=[t∣t]u_t=E[v_t _t] the marginal velocity. The conditional covariance t(t)=[(t−t)(t−t)⊤∣t] _t(x_t)=E[(v_t-u_t)(v_t-u_t) _t] satisfies t(t)≠ _t(x_t) 0 almost surely for all t∈[0,1]t∈[0,1]. Proof sketch. At t=0t\!=\!0, t=0x_t=x_0 is deterministic given the data, so 0=ϵ−0v_0= ε-x_0 has variance Var(ϵ)=Var( ε)=I. For t∈(0,1]t∈(0,1], substituting ϵ=(t−(1−t)0)/t ε=(x_t-(1\!-\!t)x_0)/t gives t=t−2Var(0∣t) _t=t^-2Var(x_0 _t). Since pdatap_data is non-degenerate and ϵ ε has full support, the posterior p(0∣t)p(x_0 _t) cannot be a point mass, so Var(0∣t)≠Var(x_0 _t) 0 a.s. □ Theorem 2 (Trajectory Drift Under Conditional Training). Let the conditional training objective be ℒcond(θ)=t,t[‖∇tfθ⋅t+∂tfθ‖2]L_cond(θ)=E_x_t,v_t[\| _x_tf_θ·v_t+ _tf_θ\|^2]. Then: ℒcond(θ) _cond(θ) =t[‖∇tfθ⋅t+∂tfθ‖2]⏟ℒconsist(θ)+t[Tr(∇tfθt(t)(∇tfθ)⊤)]⏟ℒvar(θ) = E_x_t\! [ \| _x_tf_θ·u_t+ _tf_θ \|^2 ]_L_consist(θ)+ E_x_t\! [Tr\! ( _x_tf_θ\, _t(x_t)\,( _x_tf_θ) ) ]_L_var(θ) (6) Optimizing ℒcondL_cond equals optimizing the true consistency objective ℒconsistL_consist only if t= _t=0, which Theorem 1 shows is never the case. Proof sketch. Decompose t=t+(t−t)v_t=u_t+(v_t-u_t) in the quadratic loss. The cross term vanishes because [t−t∣t]=E[v_t-u_t _t]=0. The residual is ℒvarL_var, a positive-definite quadratic form in ∇tfθ _x_tf_θ weighted by t _t. □ Remark 1. The variance term ℒvarL_var forces ∇tfθ _x_tf_θ toward zero in high-variance directions, suppressing the model’s ability to faithfully capture trajectory curvature. For standard flow matching (s=ts\!=\!t), this does not matter because fθ(t,t,t)=tf_θ(x_t,t,t)=x_t is trivially consistent. For fast flow models (s≠ts≠ t), however, ℒvarL_var induces systematic trajectory drift that degrades one-step generation quality. Theorem 3 (Cumulative Error in Consistency Mapping). Let f∗(t,s,t)f^*(x_t,s,t) denote the ideal consistency mapping and fθ(t,s,t)f_θ(x_t,s,t) the learned model. Define the local residual R(t)=∂tfθ+∇tfθ⋅tR(t)= _tf_θ+ _x_tf_θ·u_t and the total error e(s,t)=fθ(t,s,t)−f∗(t,s,t)e(s,t)=f_θ(x_t,s,t)-f^*(x_t,s,t). Then: e(s,t)=∫stR(r)r e(s,t)= _s^tR(r)\,dr (7) The total approximation error grows with the time span |t−s||t-s| via accumulation of local residuals. Remark 2. Theorem 3 suggests why a single-step model can match a multi-step teacher: the Euler integrator compounds discretization error over K steps, whereas the 1-NFE consistency model learns a direct mapping that avoids this accumulation. Whether this advantage materializes depends on ‖R(t)‖\|R(t)\| relative to the single-step approximation error; Sec. 4.3 provides empirical evidence that it does for VLA action prediction. 3.4 SnapFlow: Corrected Consistency Training for VLAs Motivated by Theorems 1–3, SnapFlow replaces the conditional velocity in the consistency target with the model’s own marginal velocity prediction and uses progressive mixing to stabilize training. Corrected Consistency Objective. Prior theoretical analysis of corrected consistency objectives shows that replacing tu_t with tv_t in the first term of the consistency loss introduces only a parameter-free constant (Appendix A.4), but the total-derivative term must use the marginal velocity estimate θ=Fθ(t,t,t)u_θ=F_θ(x_t,t,t) to avoid drift per Theorem 2. This yields: ℒconsist=t[‖Fθ(t,s,t)−sg(t−(t−s)(∇tFθ⋅θ+∂tFθ))‖2] _consist=E_x_t\! [ \|F_θ(x_t,s,t)-sg\! (v_t-(t-s)\! ( _x_tF_θ·u_θ+ _tF_θ ) ) \|^2 ] (8) where sg(⋅)sg(·) denotes stop-gradient and θ=Fθ(t,t,t∣)u_θ=F_θ(x_t,t,t ) is the model’s marginal velocity estimate, maintained by the FM component of training. Two-Step Euler Shortcut Target. Computing ∇tFθ⋅θ+∂tFθ _x_tF_θ·u_θ+ _tF_θ is expensive for billion-parameter VLAs. We instead implement Eq. (8) via a two-step Euler shortcut Frans et al. (2025), evaluating the model at two time points and averaging their velocities: 0.5 _0.5 =1−0.5⋅sg(Fθ(1,1,1∣)) =x_1-0.5·sg\! (F_θ(x_1,1,1 ) ) (9) target _target =12[sg(Fθ(1,1,1∣))+sg(Fθ(0.5,0.5,0.5∣))] = 12\! [sg\! (F_θ(x_1,1,1 ) )+sg\! (F_θ(x_0.5,0.5,0.5 ) ) ] (10) The consistency loss then trains the 1-step velocity to match this two-step shortcut: ℒshortcut=∥Fθ(1,0,1∣)−target∥2 _shortcut= \|F_θ(x_1,0,1 )-v_target \|^2 (11) The two-step Euler target better estimates the true average velocity than tv_t because it uses the model’s marginal velocity predictions at both t=1t\!=\!1 and t=0.5t\!=\!0.5, effectively approximating the integral ∫01(τ,τ)τ _0^1u(x_τ,τ)\,dτ via the trapezoidal rule rather than a single conditional sample. As the model improves during training, these marginal velocity estimates become more accurate, creating a virtuous cycle: better θu_θ yields a better shortcut target, which in turn produces a better 1-step predictor. Progressive FM/Consistency Mixing. Following α-Flow Zhang et al. (2025), we mix the FM and consistency objectives with ratio α: ℒ=α⋅ℒFM+(1−α)⋅λ⋅ℒshortcut =α·L_FM+(1-α)·λ·L_shortcut (12) The FM component maintains the velocity estimator θu_θ used in the consistency target; the consistency component teaches accurate one-step jumps; λ balances their gradient magnitudes. 3.5 Target-Time Embedding To let FθF_θ distinguish FM (s=ts\!=\!t) from consistency (s=0s\!=\!0) samples without modifying the pretrained architecture, we inject a target-time embedding ϕs _s Lee et al. (2025): a zero-initialized two-layer MLP that encodes s and adds to the existing time embedding before each transformer block. Zero initialization preserves the teacher at step 0; ϕs _s is the only new parameter, making SnapFlow applicable to any flow-matching VLA by a single addition to the time-embedding pathway. 3.6 Training and Inference SnapFlow freezes the VLM backbone and trains only the action expert and ϕs _s—about 10% of parameters—with gradient checkpointing, for 30k steps on a single A800 in ∼ 12h; full hyperparameters are in Appendix J. At deployment, a single forward pass produces the action chunk: 0^=1−Fθ(1,s=0,t=1∣),1∼(,) x_0=x_1-F_θ(x_1,s\!=\!0,t\!=\!1 ), _1 (0,I) (13) yielding ∼ 83 ms E2E (3.3× faster than the 274 ms baseline). 4 Experiments 4.1 Experimental Setup Models. We evaluate on two flow-matching VLAs spanning a 6×6× parameter range to demonstrate plug-and-play generality: π 0.5 Intelligence et al. (2025), a 3B VLA with PaliGemma backbone and cross-attention action expert, and SmolVLA Shukor et al. (2025), a ∼ 500M VLA with SmolVLM backbone and concatenation-based expert. These cover two distinct VLM backbones and two different action expert designs. Published π 0 Black et al. (2024) results serve as a cross-model reference. Benchmarks. For π 0.5 we use LIBERO Liu et al. (2024): four suites, 10 tasks each, 10 episodes per task (400 total), following the protocol of Intelligence et al. (2025); Black et al. (2024). All methods share the same LeRobot evaluation pipeline and seeds.111A known LeRobot issue may cause episodes within the same task to share initial states at batch_size=1; this affects all methods equally. Offline metrics use 500 held-out samples; latency is profiled on a single A800-80G. Baselines. Baseline 10-step: pretrained model with default 10-step Euler; Naïve 1-step: same model with 1 step, no retraining; SnapFlow 1-step: distilled model with 1-step inference. 4.2 Main Results All flow-matching VLAs are designed and deployed with 10-step Euler denoising as the standard configuration Black et al. (2024); Intelligence et al. (2025); Shukor et al. (2025). Table 1 presents the central result: SnapFlow improves both quality and speed vs. this baseline across two VLAs spanning a 6×6× parameter range, with no architecture changes and identical hyperparameters. On π 0.5 it achieves 98.75% LIBERO success at 1 step, matching or exceeding the teacher at 97.75%. On SmolVLA it reduces MSE by 8.3% and improves CosSim by 6.9% with 3.56× E2E acceleration. Table 1: LIBERO closed-loop evaluation: SnapFlow vs. the VLA landscape. π 0.5: Baseline uses 10-step Euler; Naïve sets 1 step without retraining; SnapFlow uses 1-step after distillation (α=0.5α\!=\!0.5, λ=0.1λ\!=\!0.1, 30k steps). Published baselines† provide cross-model context. †Published results; OpenVLA/Octo/DP use per-suite fine-tuning (favors them), while π 0/π 0.5/SnapFlow use a single model for all 4 suites. All latency on A800-80G. SmolVLA (0.5B) results in Tables 2–3. Blue bold: best. LIBERO Success (%) Offline Latency (A800) Method Params Steps Spatial Object Goal Long-10 Avg MSE↓ CosSim↑ E2E↓ E2E Speedup Published VLA Baselines† LIBERO closed-loop success rates from original papers Diff. Policy Chi et al. (2023) — 100 78.3 92.5 68.3 50.5 72.40 n/a n/a Octo-Base Team et al. (2024) 93M 10 78.9 85.7 84.6 51.1 75.08 n/a n/a OpenVLA Kim et al. (2024) 7.0B AR 84.9 88.4 79.2 53.7 76.55 n/a n/a π 0 Black et al. (2024) 3.0B 10 97.4 98.4 97.6 93.0 96.60 n/a n/a π 0.5 + SnapFlow (Ours) Intelligence et al. (2025) PaliGemma backbone ⋅· cross-attention action expert ⋅· LIBERO (400 eps) Baseline (Euler) 3.0B 10 98.0 100.0 96.0 97.0 97.75 .0117 .9885 274 ms 1.0× Naïve 1-step 3.0B 1 96.0 99.0 98.0 94.0 96.75 .0089 .9911 81 ms 3.4× SnapFlow 3.0B 1 99.0 100.0 99.0 97.0 98.75 .0077 .9916 83 ms 3.3× Key observations. SnapFlow 1-step reaches 98.75% average success, exceeding the 10-step baseline by 1 p, consistent with Theorem 3’s prediction that multi-step integration accumulates error. It also compares favorably to π 0, OpenVLA, Octo, and Diffusion Policy while being 3.3× faster than the π 0.5 baseline. Naïve 1-step reduction shows mixed reliability: while its average (96.75%) is competitive, per-task variance is high (Appendix C). On libero_goal, both naïve 1-step (98%) and SnapFlow (99%) exceed the 10-step baseline (96%), suggesting that 10-step Euler can compound errors on certain tasks. Identical hyperparameters improve both π 0.5 and SmolVLA, confirming plug-and-play generality. Table 2 shows that SnapFlow’s advantage grows at higher percentiles—P95 MSE drops 29.4% on π 0.5—taming the worst-case predictions that drive closed-loop failures. Table 2: Extended offline metrics. π 0.5: 500 held-out LIBERO samples; SmolVLA: PushT. SnapFlow disproportionately reduces tail errors (P90/P95) and variance. Blue bold: best per block. Method Avg MSE↓ Med MSE↓ Std MSE↓ P90 MSE↓ P95 MSE↓ CosSim↑ π 0.5 — LIBERO (500 samples) Baseline (10-step) .01169 .00397 .05412 .01544 .02357 .9885 SnapFlow (1-step) .00773 .00367 .02964 .01179 .01664 .9916 Δ : MSE −-33.9%, Std −-45.2%, P95 −-29.4% SmolVLA — PushT Baseline (10-step) 0.468 0.268 0.517 1.162 — 0.765 SnapFlow (1-step) 0.429 0.272 0.452 1.029 — 0.818 Δ : MSE −-8.3%, Std −-12.6%, P90 −-11.4%, CosSim ++6.9% 4.3 Inference Steps vs. Quality: Pareto Analysis We sweep denoising steps ∈1,2,3,4,5,10∈\1,2,3,4,5,10\ for both the baseline and SnapFlow on π 0.5 using 500 held-out LIBERO samples, and evaluate SmolVLA at deployment-relevant endpoints. Figure 2 and Table 3 present the quality–cost Pareto frontier across all three VLAs. Figure 2: Pareto frontier: all VLAs on one plot. (a) Normalized MSE (each VLA’s 10-step baseline =1.0=1.0; lower is better, y-axis inverted). π 0.5 has a full step sweep; SmolVLA shows measured endpoints; π 0 is a single published reference at k=10k\!=\!10. All three VLAs cluster at the dashed 1.01.0 line under the standard 10-step configuration; SnapFlow (★ ) breaks away into the low-cost zone. (b) LIBERO simulation success rate. SnapFlow π 0.5 at 1-step (98.75%) matches or exceeds its own 10-step teacher (97.75%) and the published π 0 at 10-step (96.6%). Table 3: Step sweep: quality vs. latency Pareto analysis. π 0.5 on LIBERO (A800, 500 samples); SmolVLA on PushT. Offline MSE increases monotonically with Euler step count on the pretrained model, consistent with Theorem 3. Blue bold: best per block. Action Quality Quality Trend Latency Method Steps Avg MSE↓ CosSim↑ Δ vs 1-step Δ vs 1-step E2E (ms)↓ E2E Speedup Pareto optimal? π 0.5 Baseline (Naïve Euler) Naïve Euler 1 0.00893 0.9911 — — 163.5 2.24× ✓ Naïve Euler 2 0.00904 0.9910 ++1.2% −-0.01% 184.3 1.99× Naïve Euler 3 0.01001 0.9894 ++12.1% −-0.17% 206.0 1.78× Naïve Euler 4 0.01048 0.9890 ++17.4% −-0.21% 228.6 1.60× Naïve Euler 5 0.01091 0.9886 ++22.2% −-0.25% 251.4 1.46× Naïve Euler 10 0.01167 0.9880 ++30.7% −-0.31% 366.6 1.00× π 0.5 SnapFlow SnapFlow 1 0.00933 0.9904 — — 166.5 2.20× ✓ SnapFlow 2 0.00808 0.9906 −-13.4% ++0.02% 192.3 1.91× ★ SnapFlow 3 0.00825 0.9904 −-11.6% ++0.00% 216.2 1.70× SnapFlow 4 0.00848 0.9901 −-9.1% −-0.03% 240.1 1.53× SnapFlow 5 0.00901 0.9896 −-3.4% −-0.09% 264.0 1.39× SnapFlow 10 0.01043 0.9877 ++11.8% −-0.27% 382.2 0.96× SmolVLA — PushT offline Naïve Euler 10 0.468 0.765 — 178 1.0× SnapFlow 1 0.429 0.818 MSE −-8.3% 50 3.56× ✓ Key findings. On the pretrained model, offline MSE increases monotonically with step count—++30.7% from 1 to 10 steps—consistent with Theorem 3. This is an offline proxy: the 10-step baseline still achieves higher simulation success (97.75% vs. 96.75% for naïve 1-step), so MSE alone does not fully capture closed-loop quality. SnapFlow resolves this tension by achieving both low offline MSE and the highest simulation success at 98.75% through explicit single-step training (Appendix C). SF 2-step achieves the lowest offline MSE at 0.00808, the Pareto optimum when multi-step inference is acceptable. SmolVLA confirms the pattern cross-architecture: SF 1-step reduces MSE by 8.3% and improves CosSim by 6.9% vs. the 10-step baseline. We further investigate the interaction between denoising steps and the action execution horizon nactn_act on the challenging libero_10 suite. SnapFlow at nact=5n_act\!=\!5 reaches 93% success—exceeding the baseline’s 90% at the same setting—while being 1.4× faster per episode. This suggests that SnapFlow’s advantage extends beyond pure inference speedup to improved robustness under moderate replanning frequencies; full results are in Appendix H. 4.4 Comparison with Concurrent VLA Acceleration Methods Several concurrent works also target VLA inference efficiency. Table 4 compares SnapFlow with the two most relevant methods on π 0.5. Table 4: Comparison with concurrent VLA acceleration methods on π 0.5. SnapFlow compresses the sampling trajectory (denoising steps); Shallow-π Jeon et al. (2026) compresses the architecture (transformer layers). The two approaches are orthogonal and can be composed for multiplicative speedups. Blue bold: best per column. What is Compressed Result Method Layers (architecture) Steps (sampling) Success Δ E2E Speedup Orthogonal to SnapFlow? Shallow-π Jeon et al. (2026) 18 → 6 10 (unchanged) <−<\!-1% 2× Yes — layer distillation EfficientVLA Yang et al. (2025) dynamic skip 10 → 2 −-0.6% 1.9× Partially — also reduces steps SnapFlow (ours) unchanged 10 → 1 ++1% 3.3× — Key insight: orthogonal axes. Shallow-π shrinks the transformer to reduce per-step cost; SnapFlow eliminates 9 of 10 steps. Since the two target different components, the speedups are in principle multiplicative: 2× layer compression × 9.6× denoising == 5–6× E2E, potentially bringing π 0.5 below 50 ms for 20 Hz control. SnapFlow is notable for maintaining or slightly improving task success rather than trading quality for speed. 4.5 Ablation Studies We ablate the mixing ratio α, consistency weight λ, and target-time embedding on π 0.5 with 1-NFE inference (500-sample offline set; Table 5). Table 5: Joint ablation study (π 0.5, 1-NFE offline, 500 samples). We ablate three SnapFlow design choices: mixing ratio α, consistency weight λ, and target-time embedding. The default configuration (α=0.5α\!=\!0.5, λ=0.1λ\!=\!0.1, with embedding) achieves the best trade-off. Blue bold: best per block. Configuration 1-NFE Quality Variant α λ Target-Time Embed? MSE↓ CosSim↑ Observation (a) FM/Consistency Mixing Ratio α (fix λ=0.1λ\!=\!0.1, embed ON) Pure consistency 0.0 0.1 ✓ .0115 .9876 No FM signal; velocity estimate degrades Consistency-heavy 0.3 0.1 ✓ .0088 .9901 Slightly less stable θu_θ Balanced (default) 0.5 0.1 ✓ .0077 .9916 Best: FM maintains θu_θ quality FM-heavy 0.7 0.1 ✓ .0084 .9908 Insufficient consistency signal Pure FM 1.0 0.1 ✓ .0093 .9896 No consistency; 1-step uncalibrated (b) Consistency Weight λ (fix α=0.5α\!=\!0.5, embed ON) Low weight 0.5 0.01 ✓ .0089 .9902 Weak consistency signal Default 0.5 0.1 ✓ .0077 .9916 Balanced gradient magnitude High weight 0.5 1.0 ✓ .0096 .9891 Overpowers FM component (c) Target-Time Embedding (fix α=0.5α\!=\!0.5, λ=0.1λ\!=\!0.1) No embedding 0.5 0.1 × .0098 .9889 FM and consistency objectives conflict With embedding (default) 0.5 0.1 ✓ .0077 .9916 Clean separation of objectives Analysis. The mixing ratio α controls a fundamental trade-off: at α=0α\!=\!0 the velocity estimator degrades without FM supervision; at α=1α\!=\!1 no consistency signal exists. The balanced α=0.5α\!=\!0.5 lets both objectives co-train stably; the target-time embedding enables clean separation between local velocity prediction and global one-step generation. 5 Conclusion We presented SnapFlow, a plug-and-play self-distillation method that compresses multi-step denoising of flow-matching VLAs into a single forward pass via a corrected consistency objective, progressive FM/consistency mixing, and a zero-initialized target-time embedding—requiring no external teachers or architecture changes. On π 0.5, it achieves 98.75% success on LIBERO (vs. 97.75% for the 10-step baseline) with 9.6× denoising speedup; on SmolVLA, it reduces MSE by 8.3% with 3.56× acceleration, supporting transfer across model scales. An action-step sensitivity analysis shows that SnapFlow maintains its advantage across execution horizons (Appendix H). SnapFlow is orthogonal to layer-distillation methods Jeon et al. (2026), enabling compositional speedups. Limitations. Evaluation is limited to LIBERO simulation (10 episodes per task, 10 p resolution); real-robot validation is needed. We note that the same LIBERO protocol is used by π 0/π 0.5 Black et al. (2024); Intelligence et al. (2025) to validate their core claims, and SnapFlow does not modify the policy’s action distribution—only its sampling efficiency—so we expect the sim-to-real gap to be comparable. A pretrained flow-matching checkpoint is required. The VLM prefix bottleneck. With denoising compressed to one step, the VLM prefix (60 ms) becomes the new bottleneck (72% of E2E). Combining SnapFlow with VLM-side acceleration Jeon et al. (2026); Yang et al. (2025) can yield multiplicative speedups, potentially bringing π 0.5 below 50 ms. Acknowledgments and Disclosure of Funding References Black et al. [2024] K. Black, N. Brown, D. Driess, A. Esmail, M. Equi, et al. π 0: A vision-language-action flow model for general robot control. arXiv preprint arXiv:2410.24164, 2024. Frans et al. [2025] K. Frans, D. Hafner, S. Levine, and P. Abbeel. One step diffusion via shortcut models. In ICLR, 2025. Geng et al. [2025a] Z. Geng, M. Deng, X. Bai, J. Z. Kolter, and K. He. Mean flows for one-step generative modeling. In NeurIPS, 2025. Intelligence et al. [2025] Physical Intelligence, K. Black, N. Brown, et al. π 0.5: A vision-language-action model with open-world generalization. arXiv preprint arXiv:2504.16054, 2025. Jeon et al. [2026] B. Jeon, Y. Choi, and T. Kim. Shallow-π: Knowledge distillation for flow-based VLAs. arXiv preprint arXiv:2601.20262, 2026. Chi et al. [2023] C. Chi, S. Feng, Y. Du, Z. Xu, E. Cousineau, B. Burchfiel, and S. Song. Diffusion Policy: Visuomotor Policy Learning via Action Diffusion. In RSS, 2023. Kim et al. [2024] M. J. Kim, K. Pertsch, S. Karamcheti, et al. OpenVLA: An open-source vision-language-action model. arXiv preprint arXiv:2406.09246, 2024. Lee et al. [2025] K. Lee, S. Yu, and J. Shin. Decoupled MeanFlow: Turning flow models into flow maps for accelerated sampling. arXiv preprint arXiv:2510.24474, 2025. Prasad et al. [2024] A. Prasad, K. Lin, J. Wu, L. Zhou, and J. Bohg. Consistency policy: Accelerated visuomotor policies via consistency distillation. In RSS, 2024. arXiv:2405.07503. Lipman et al. [2023] Y. Lipman, R. T. Q. Chen, H. Ben-Hamu, M. Nickel, and M. Le. Flow matching for generative modeling. ICLR, 2023. Liu et al. [2024] B. Liu, Y. Zhu, C. Gao, Y. Feng, et al. LIBERO: Benchmarking knowledge transfer for lifelong robot learning. NeurIPS Datasets and Benchmarks, 2023. Lu and Song [2025] C. Lu and Y. Song. Simplifying, stabilizing and scaling continuous-time consistency models. In ICLR, 2025. Shukor et al. [2025] M. Shukor, et al. SmolVLA: A Vision-Language-Action Model for Affordable and Efficient Robotics. arXiv preprint arXiv:2506.01844, 2025. Team et al. [2024] Octo Model Team, D. Ghosh, H. Walke, K. Pertsch, et al. Octo: An open-source generalist robot policy. arXiv preprint arXiv:2405.12213, 2024. Song et al. [2023] Y. Song, P. Dhariwal, M. Chen, and I. Sutskever. Consistency models. ICML, 2023. Yang et al. [2025] Y. Yang, et al. EfficientVLA: Training-Free Acceleration and Compression for Vision-Language-Action Models. arXiv preprint arXiv:2506.10100, 2025. Zhang et al. [2025] H. Zhang, A. Siarohin, W. Menapace, et al. AlphaFlow: Understanding and improving MeanFlow models. arXiv preprint arXiv:2510.20771, 2025. Zhang et al. [2025b] Q. Zhang, Z. Liu, H. Fan, and S. Liu. FlowPolicy: Enabling fast and robust 3D flow-based policy via consistency flow matching for robot manipulation. In AAAI, 2025. Yan et al. [2025] Z. Yan, et al. ManiFlow: A general robot manipulation policy via consistency flow training. In CoRL, 2025. Wang et al. [2025b] Y. Wang, et al. FreqPolicy: Efficient flow-based visuomotor policy via frequency consistency. In NeurIPS, 2025. Ho et al. [2020] J. Ho, A. Jain, and P. Abbeel. Denoising diffusion probabilistic models. In NeurIPS, 2020. Sohl-Dickstein et al. [2015] J. Sohl-Dickstein, E. Weiss, N. Maheswaranathan, and S. Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In ICML, 2015. Song et al. [2020] Y. Song, J. Sohl-Dickstein, D. P. Kingma, A. Kumar, S. Ermon, and B. Poole. Score-based generative modeling through stochastic differential equations. In ICLR, 2021. Karras et al. [2022] T. Karras, M. Aittala, T. Aila, and S. Laine. Elucidating the design space of diffusion-based generative models. In NeurIPS, 2022. Ajay et al. [2022] A. Ajay, Y. Du, A. Gupta, J. Tenenbaum, T. Jaakkola, and P. Agrawal. Is conditional generative modeling all you need for decision-making? In ICLR, 2023. Janner et al. [2022] M. Janner, Y. Du, J. B. Tenenbaum, and S. Levine. Planning with diffusion for flexible behavior synthesis. In ICML, 2022. Carvalho et al. [2023] J. Carvalho, A. T. Le, M. Baierl, D. Koert, and J. Peters. Motion planning diffusion: Learning and planning of robot motions with diffusion models. In IROS, 2023. Ke et al. [2024] T.-W. Ke, N. Gkanatsios, and K. Fragkiadaki. 3D diffuser actor: Policy diffusion with 3D scene representations. arXiv preprint arXiv:2402.10885, 2024. Appendix A Theoretical Proofs We provide complete proofs for the three theorems stated in the main text. A.1 Proof of Theorem 1 (Conditional–Marginal Velocity Discrepancy) Proof. We analyze two cases. Case 1: t=0t=0. At t=0t\!=\!0, t=0x_t=x_0. The conditional velocity is 0=ϵ−0v_0= ε-x_0. Since ϵ∼(,) ε (0,I) is independent of 0x_0, the marginal velocity is 0(0)=[ϵ−0∣0]=−0u_0(x_0)=E[ ε-x_0 _0]=-x_0. Therefore: 0(0)=Var(0∣0)=Var(ϵ)=≠ _0(x_0)=Var(v_0 _0)=Var( ε)=I 0 (14) Case 2: t∈(0,1]t∈(0,1]. Substituting ϵ=(t−(1−t)0)/t ε=(x_t-(1-t)x_0)/t into t=ϵ−0v_t= ε-x_0: t=t−(1−t)0t−0=1t(t−0) _t= x_t-(1-t)x_0t-x_0= 1t(x_t-x_0) (15) The conditional covariance is therefore: t(t)=Var(t∣t)=1t2Var(0∣t) _t(x_t)=Var(v_t _t)= 1t^2\,Var(x_0 _t) (16) The posterior p(0∣t)∝pdata(0)(t−(1−t)0t;,)p(x_0 _t) p_data(x_0)\,N\! ( x_t-(1-t)x_0t;0,I ). Since pdatap_data is non-degenerate (contains at least two distinct points) and the Gaussian noise has full support on ℝdR^d, the posterior p(0∣t)p(x_0 _t) cannot be a Dirac measure for almost all tx_t. Therefore Var(0∣t)≠Var(x_0 _t) 0, which implies t(t)≠ _t(x_t) 0 a.s. for all t∈[0,1]t∈[0,1]. ∎ A.2 Proof of Theorem 2 (Trajectory Drift Decomposition) Proof. Let Jθ=∇tfθJ_θ= _x_tf_θ and f˙θ=∂tfθ f_θ= _tf_θ. The conditional objective can be written as: ℒcond(θ)=t[t∣t[‖Jθt+f˙θ‖2]] _cond(θ)=E_x_t\! [E_v_t _t\! [\|J_θv_t+ f_θ\|^2 ] ] (17) Decompose t=t+tv_t=u_t+ δ_t where t=t−t δ_t=v_t-u_t and [t∣t]=E[ δ_t _t]=0: ‖Jθt+f˙θ‖2 \|J_θv_t+ f_θ\|^2 =‖(Jθt+f˙θ)+Jθt‖2 =\|(J_θu_t+ f_θ)+J_θ δ_t\|^2 =‖Jθt+f˙θ‖2+2(Jθt+f˙θ)⊤Jθt+‖Jθt‖2 =\|J_θu_t+ f_θ\|^2+2(J_θu_t+ f_θ) J_θ δ_t+\|J_θ δ_t\|^2 (18) Taking the conditional expectation t∣t[⋅]E_v_t _t[·]: • The first term is deterministic given tx_t: ‖Jθt+f˙θ‖2\|J_θu_t+ f_θ\|^2. • The cross term vanishes: [Jθt∣t]=Jθ[t∣t]=E[J_θ δ_t _t]=J_θE[ δ_t _t]=0. • The third term: [‖Jθt‖2∣t]=Tr(Jθt(t)Jθ⊤)E[\|J_θ δ_t\|^2 _t]=Tr(J_θ\, _t(x_t)\,J_θ ). Taking the outer expectation over tx_t completes the decomposition: ℒcond(θ)=t[‖Jθt+f˙θ‖2]⏟ℒconsist+t[Tr(JθtJθ⊤)]⏟ℒvar _cond(θ)= E_x_t[\|J_θu_t+ f_θ\|^2]_L_consist+ E_x_t[Tr(J_θ\, _t\,J_θ )]_L_var (19) Since t≠ _t 0 by Theorem 1, ℒvar>0L_var>0 for any non-degenerate fθf_θ (i.e., any fθf_θ with Jθ≠J_θ 0). ∎ A.3 Proof of Theorem 3 (Cumulative Error) Proof. Let rr∈[s,t]\x_r\_r∈[s,t] follow the marginal flow: drdr=r(r) dx_rdr=u_r(x_r). The ideal consistency mapping satisfies f∗(t,s,t)=sf^*(x_t,s,t)=x_s for all t, hence its total derivative along the flow vanishes: dtf∗(t,s,t)=∂tf∗+∇tf∗⋅t=0 ddtf^*(x_t,s,t)= _tf^*+ _x_tf^*·u_t=0 (20) The total derivative of the error e(s,t)=fθ(t,s,t)−f∗(t,s,t)e(s,t)=f_θ(x_t,s,t)-f^*(x_t,s,t) is: dte(s,t)=dtfθ(t,s,t)−dtf∗(t,s,t)=(∂tfθ+∇tfθ⋅t)−0=R(t) ddte(s,t)= ddtf_θ(x_t,s,t)- ddtf^*(x_t,s,t)=( _tf_θ+ _x_tf_θ·u_t)-0=R(t) (21) With boundary condition e(s,s)=fθ(s,s,s)−f∗(s,s,s)=s−s=e(s,s)=f_θ(x_s,s,s)-f^*(x_s,s,s)=x_s-x_s=0, integration gives: e(s,t)=∫stR(r)r e(s,t)= _s^tR(r)\,dr (22) The total error is the integral of local residuals, growing with the time span |t−s||t-s|. ∎ A.4 Equivalence of Corrected Objective (Eq. 8) We show that replacing the marginal velocity tu_t with the conditional velocity tv_t in the first term of the consistency loss introduces only a parameter-independent constant. Starting from the true consistency objective ℒconsistu=t[‖Fθ−t+(t−s)F˙θ(t)‖2]L_consist^u=E_x_t[\|F_θ-u_t+(t\!-\!s) F_θ(u_t)\|^2], define the auxiliary objective with tv_t in the first term: ℒv ^v =t,t[‖Fθ−t+(t−s)F˙θ(θ)‖2] =E_x_t,v_t\! [\|F_θ-v_t+(t\!-\!s) F_θ(u_θ)\|^2 ] (23) Using t=t+tv_t=u_t+ δ_t with [t∣t]=E[ δ_t _t]=0: ‖Fθ−t+Δ‖2 \|F_θ-v_t+ \|^2 =‖(Fθ−t+Δ)−t‖2 =\|(F_θ-u_t+ )- δ_t\|^2 =‖Fθ−t+Δ‖2−2(Fθ−t+Δ)⊤t+‖t‖2 =\|F_θ-u_t+ \|^2-2(F_θ-u_t+ ) δ_t+\| δ_t\|^2 (24) where Δ=(t−s)F˙θ(θ) =(t\!-\!s) F_θ(u_θ). Taking the expectation, the cross term vanishes: t|t[(Fθ−t+Δ)⊤t]=(Fθ−t+Δ)⊤[t|t]⏟= 0=0 _v_t|x_t[(F_θ-u_t+ ) δ_t]=(F_θ-u_t+ ) E[ δ_t|x_t]_=\,0=0 (25) Therefore: ℒv=ℒconsistu+t,t[‖t‖2]=ℒconsistu+Tr(t) ^v=L_consist^u+E_x_t,v_t[\| δ_t\|^2]=L_consist^u+Tr( _t) (26) Since Tr(t)Tr( _t) is independent of θ, optimizing ℒvL^v is equivalent to optimizing ℒconsistuL_consist^u. It remains to specify how tu_t in the total derivative term F˙θ(t) F_θ(u_t) is estimated. Observe that at s=ts\!=\!t, the corrected objective (Eq. 8) reduces to the standard FM loss ‖Fθ(t,t,t)−t‖2\|F_θ(x_t,t,t)-v_t\|^2, whose minimizer is precisely the marginal velocity tu_t. The FM component of SnapFlow training (α fraction of each batch) therefore provides a continuously refined estimate θ=Fθ(t,t,t)≈tu_θ=F_θ(x_t,t,t) _t. Substituting θu_θ for tu_t in the total derivative yields Eq. (8). Appendix B Training and Inference Algorithms We provide the complete SnapFlow training loop (Algorithm 1) and inference procedure (Algorithm 2). Training details. Each training step involves three forward passes through the action expert: one for the FM loss (at random t), one for 1v_1 at t=1t\!=\!1, and one for 0.5v_0.5 at t=0.5t\!=\!0.5. The two consistency forward passes are wrapped in stop_gradient to prevent collapse: only the student prediction Fθ(1,0,1)F_θ(x_1,0,1) receives gradients from the consistency loss. This is analogous to the target network in consistency models Song et al. [2023], but without requiring an EMA copy—the stop-gradient on the shortcut target suffices because the FM component continuously refines the velocity estimate θu_θ. Memory considerations. Three forward passes per step may seem expensive, but since the VLM backbone is frozen and only the action expert (∼ 300M params for π 0.5) receives gradients, the memory footprint is modest. With gradient checkpointing enabled, peak VRAM for π 0.5 is ∼ 40 GB, fitting comfortably on a single A800-80G. For SmolVLA (∼ 500M total), peak usage is only ∼ 18 GB. Inference simplicity. At deployment, SnapFlow requires exactly one forward pass through the full model (VLM prefix + action expert), identical to a naïve 1-step run. The only difference from the pretrained model is that the target-time input s is set to 0 (instead of s=ts\!=\!t for standard FM). No EMA networks, no multi-step scheduling, and no additional memory are needed at inference time. Algorithm 1 SnapFlow Training 0: Pretrained VLA FθF_θ, dataset D, ratio α, weight λ, learning rate η, steps N 1: Initialize target-time MLP ϕs← _s 0; freeze VLM backbone 2: for i=1i=1 to N do 3: Sample batch (0(j),(j))\(x_0^(j),c^(j))\ from D 4: Sample ϵ(j)∼(,) ε^(j) (0,I); sample t(j)∼(0,1)t^(j) (0,1) 5: Compute t(j)=(1−t(j))0(j)+t(j)ϵ(j)x_t^(j)=(1-t^(j))\,x_0^(j)+t^(j)\, ε^(j) 6: // FM component (with probability α) 7: ℒFM=∥Fθ(t,t,t∣)−(ϵ−0)∥2L_FM=\|F_θ(x_t,t,t )-( ε-x_0)\|^2 8: // Consistency component (with probability 1−α1-α) 9: 1←sg(Fθ(1,1,1∣))v_1 \! (F_θ(x_1,1,1 ) ) ⊳ velocity at t=1t\!=\!1 10: 0.5←1−0.5⋅1x_0.5 _1-0.5·v_1 ⊳ midpoint via Euler 11: 0.5←sg(Fθ(0.5,0.5,0.5∣))v_0.5 \! (F_θ(x_0.5,0.5,0.5 ) ) ⊳ velocity at t=0.5t\!=\!0.5 12: target←12(1+0.5)v_target← 12(v_1+v_0.5) ⊳ 2-step average velocity 13: ℒshortcut=∥Fθ(1,0,1∣)−target∥2L_shortcut=\|F_θ(x_1,0,1 )-v_target\|^2 14: ℒ=α⋅ℒFM+(1−α)⋅λ⋅ℒshortcutL=α·L_FM+(1-α)·λ·L_shortcut 15: Update θ←θ−η∇θℒθ←θ-η _θL ⊳ action expert + ϕs _s only 16: end for 17: return Distilled model FθF_θ Algorithm 2 SnapFlow 1-NFE Inference 0: Observation images o, language instruction l, distilled VLA FθF_θ 1: ←VLM-Prefix(,)c← VLM-Prefix(o,l) ⊳ shared VLM computation (∼ 60 ms) 2: 1∼(,)∈ℝH×Dx_1 (0,I) ^H× D ⊳ sample noise 3: 0^=1−Fθ(1,s=0,t=1∣) x_0=x_1-F_θ(x_1,s\!=\!0,t\!=\!1 ) ⊳ single forward pass (∼ 24 ms) 4: Execute first nactn_act steps of 0 x_0 Appendix C Per-Task Success Rate Breakdown Tables 6–6 provide the complete per-task breakdown for all four LIBERO suites, complementing the aggregate results in Table 1. Each task is evaluated over 10 independent episodes with randomized initial conditions. Key patterns across suites. Several instructive patterns emerge from the per-task analysis: • Naïve 1-step failures are task-specific, not uniform. Most tasks show ≤ 10% degradation, but a few tasks exhibit notable drops (e.g., libero_spatial Task 6: −-10%; libero_10 Task 6: ++20%, Task 9: −-10%). These are typically tasks requiring precise multi-phase coordination where the uncalibrated velocity field produces subtly misaligned actions. • SnapFlow recovers most naïve failures and often exceeds the baseline. On libero_spatial, SnapFlow achieves 99% vs. baseline 97%, recovering naïve drops on Tasks 6 and 9 while improving Task 5 from 80% to 90%. On libero_goal, SnapFlow reaches 99% vs. baseline 96%, with three tasks (3, 9) improving from 80–90% to 100%. • Long-horizon tasks (libero_10) exhibit high variance across all methods. Task 8 is at 60%/100%/50% for baseline/naïve/SnapFlow respectively—a 50 p swing—illustrating that 10 episodes per task is insufficient to reliably distinguish methods on the hardest tasks. Suite-level averages (100 episodes) are more stable: SnapFlow (91%) exceeds baseline (89%) by 2 p. • The hardest tasks are hard for all methods. Tasks 0 and 8 in libero_10 are at ≤ 90% for at least two methods, suggesting that these failures stem from the policy’s capability boundary rather than from inference quality. Table 6: Complete per-task LIBERO success rate (%) across all 4 suites (10 episodes per task, 400 total, following the standard protocol of Intelligence et al. [2025]). Blue row: suite averages. Red: notable drops from baseline. SnapFlow recovers the observed naïve degradations and closely tracks the teacher across tasks. Blue bold: best per task. libero_spatial libero_object libero_goal libero_10 (long) Task Base Naïve SF Base Naïve SF Base Naïve SF Base Naïve SF 0 100 100 100 100 100 100 100 100 100 90 90 90 1 100 100 100 100 100 100 100 100 100 100 100 100 2 100 100 100 100 100 100 90 90 90 90 100 100 3 100 100 100 100 90 100 80 90 100 100 100 100 4 100 100 100 100 100 100 100 100 100 100 100 90 5 80 80 90 100 100 100 100 100 100 100 100 100 6 100 90 100 100 100 100 100 100 100 70 90 100 7 90 100 100 100 100 100 100 100 100 90 90 100 8 100 100 100 100 100 100 100 100 100 60 100 50 9 100 90 100 100 100 100 90 100 100 90 80 80 Avg 97.0 96.0 99.0 100.0 99.0 100.0 96.0 98.0 99.0 89.0 95.0 91.0 Appendix D LIBERO Success Rate Visualization Figure 3: LIBERO simulation success rate comparison (π 0.5). SnapFlow 1-step (red) exceeds the 10-step baseline (blue) on 3 of 4 suites. On libero_10, SnapFlow (91%) exceeds baseline (89%) but naïve 1-step (95%) is higher, reflecting high per-task variance on long-horizon tasks (see Table 6). The dashed line marks the published π 0 10-step reference (96.6%). Appendix E Detailed Offline Metrics Analysis Table 2 (main text) reports extended percentile metrics. Here we discuss the implications in depth. Why SnapFlow improves across all percentiles. On π 0.5, SnapFlow reduces MSE at the median (−-7.6%), P90 (−-23.6%), and P95 (−-29.4%). The disproportionate tail improvement indicates SnapFlow is particularly effective at taming worst-case predictions—those causing closed-loop failures. The −-45.2% standard deviation reduction means predictions are also significantly more consistent across samples. Cross-architecture consistency. SmolVLA shows an identical relative pattern: larger gains at higher percentiles and better stability (MSE −-8.3%, P90 −-11.4%, Std −-12.6%, CosSim ++6.9%), confirming generality despite 6×6× smaller model size. Connection to simulation results. Simulation success is sensitive to the tail of the error distribution. A single catastrophic prediction can cause a task failure that a hundred good predictions cannot compensate for. SnapFlow’s tail MSE reduction (π 0.5: P95 −-29.4%; SmolVLA: P90 −-11.4%) directly translates to its closed-loop advantage. Appendix F Latency Decomposition Details Figure 4 visualizes the latency decomposition across both VLAs; Table 7 provides exact numbers at various step counts. Figure 4: Latency decomposition: VLM prefix vs. denoising. SnapFlow compresses the denoising stage (red) by ∼ 10× for both π 0.5 and SmolVLA, making the fixed VLM prefix (blue) the new dominant cost. E2E speedup is 3.3×/3.56×3.56× respectively. Table 7 reports measured end-to-end latency at various step counts, demonstrating that denoising dominates at high step counts. All measurements are the median of 100 inference runs after 10 warm-up runs on a single NVIDIA A800-80G GPU with CUDA 12.1 and PyTorch 2.1, using torch.cuda.synchronize() for accurate timing. The VLM prefix as the new bottleneck. On π 0.5, at 10 steps denoising accounts for 80% of E2E latency (214 ms out of 274 ms). After SnapFlow reduces denoising to 1 step (∼ 24 ms), the VLM prefix (∼ 60 ms) becomes the dominant cost at 72% of E2E. SmolVLA shows the same pattern: denoising drops from 79% to 24% of E2E. This inversion highlights VLM-side acceleration as the next leverage point (Sec. 5). Scaling implications. The denoising cost scales linearly with step count (∼ 23 ms/step), confirming that the flow-matching action expert processes each step in approximately constant time. The VLM prefix is strictly step-independent. This decomposition means that SnapFlow’s 10× denoising speedup directly translates to a cost reduction from O(K)O(K) to O(1)O(1) in the denoising stage, with the constant VLM overhead determining the actual E2E speedup. Table 7: End-to-end latency vs. step count (A800, batch size 1). VLM prefix is constant; denoising scales linearly with steps. VLA Steps E2E (ms) Denoise Fraction E2E Speedup π 0.5 (3B) 1 81.2 28% 3.38× 2 103.3 44% 2.65× 3 124.4 54% 2.20× 5 166.9 66% 1.64× 10 274.0 80% 1.00× SmolVLA (0.5B) 1 50 24% 3.56× 10 178 79% 1.00× Appendix G Simulation Evaluation Timing Table 8 reports wall-clock evaluation time per episode, showing the end-to-end speedup in the simulation loop (including environment stepping, rendering, and reset overhead that dilutes the pure inference speedup). Timing is measured from episode start to termination (success or max-step timeout). Why simulation speedup is less than inference speedup. The ∼ 1.25× simulation speedup is much less than the 3.3× inference speedup because each evaluation loop iteration includes: (a) environment stepping and physics simulation (∼ 2 ms), (b) observation rendering and image preprocessing (∼ 5 ms), (c) action post-processing and execution (∼ 1 ms), and (d) episode reset overhead amortized over steps. These environment-side costs are independent of the inference method and effectively dilute the speedup. In a real-robot deployment, these overhead costs are typically lower (no physics simulation, no rendering), so the realized speedup would be closer to the 3.3× inference ratio. Variation across suites. The per-suite timing differences reflect task complexity: libero_10 (long-horizon) has the longest episodes (∼ 24 s baseline) because tasks involve multi-step manipulation sequences, while libero_goal has the shortest (∼ 7.7 s) because most tasks terminate quickly upon reaching the goal pose. The speedup is relatively consistent (1.19–1.42×), indicating that SnapFlow’s benefit is robust across task complexities. Table 8: Simulation wall-clock time per episode across LIBERO suites. Environment overhead limits the apparent speedup to ∼ 1.25× despite 3.3× inference acceleration. Suite Baseline (s/ep) Naïve (s/ep) SF (s/ep) Sim Speedup libero_spatial 12.57 10.91 10.60 1.19× libero_10 23.95 19.65 20.04 1.20× libero_object 9.41 6.62 6.64 1.42× libero_goal 7.71 5.72 5.74 1.34× Average 13.41 10.73 10.76 1.25× Appendix H Action Execution Horizon Sensitivity We sweep the number of executed action steps nact∈1,3,5,10,20n_act∈\1,3,5,10,20\ on libero_10 (the most challenging long-horizon suite) for both the 10-step baseline and SnapFlow 1-step. This experiment disentangles two axes: how the action is generated (1-step vs. 10-step denoising) and how much of the action chunk is executed before replanning. Figure 5: Action execution horizon sensitivity on libero_10. (a) Success rate vs. nactn_act. SnapFlow peaks at nact=5n_act\!=\!5 (93%), exceeding the baseline (90%) at the same setting. Both methods suffer at nact=1n_act\!=\!1 due to excessive replanning noise. (b) Wall-clock time per episode. SnapFlow is consistently faster due to 1-step inference; the gap is largest at low nactn_act (2.6× at nact=1n_act\!=\!1). Table 9: Action execution horizon sweep on libero_10. Success rate (%) and wall-clock time per episode (s/ep) as a function of nactn_act, the number of action steps executed before replanning. SnapFlow achieves its best at nact=5n_act\!=\!5 (93%), exceeding the baseline’s best sub-20 setting (90% at nact=5n_act\!=\!5). Blue bold: best per column. Success (%) Time (s/ep) nactn_act Baseline SnapFlow Baseline SnapFlow 1 77 72 96.2 36.8 3 88 87 50.3 31.6 5 90 93 37.2 26.3 10 89 91 23.9 20.0 20 97 92 27.1 24.2 Key findings. • Both methods suffer at nact=1n_act\!=\!1. Executing only 1 step before replanning forces the policy to re-observe and re-infer at every control tick. The baseline drops to 77% and SnapFlow to 72%, indicating that very frequent replanning is harmful for long-horizon tasks—likely because each replanning introduces noise from re-sampled 1x_1 and observation jitter. • SnapFlow peaks at nact=5n_act\!=\!5 (93%), outperforming the baseline at the same setting (90%). This is the “sweet spot” where replanning is frequent enough to correct errors but infrequent enough to avoid destabilizing the trajectory. SnapFlow’s advantage here is particularly notable: its 1-step inference takes only 26.3 s/ep vs. 37.2 s/ep for the baseline—a 1.4× speedup at a higher success rate. • The baseline benefits most from nact=20n_act\!=\!20 (97%), but at the cost of replanning frequency. Executing 20 of 50 action steps before replanning reduces the number of re-inference calls, which paradoxically helps the 10-step baseline by avoiding error injection from repeated denoising. However, this also means the policy cannot correct mid-trajectory errors—a liability in real-world deployment with perturbations. • SnapFlow provides a better speed–quality Pareto frontier. At every nact≤10n_act≤ 10, SnapFlow is faster and achieves comparable or better success. The baseline only surpasses SnapFlow at nact=20n_act\!=\!20, where both methods are slow and the time difference is minimal (27.1 vs. 24.2 s/ep). Appendix I Training Convergence Analysis Figure 6: SnapFlow training convergence on π 0.5. The combined loss (FM ++ λ⋅λ\!·\! consistency) starts at ∼ 0.021 during warmup and steadily decreases to ∼ 0.017 by 3.5k steps, with the minimum reaching 0.009. The gradient norm decreases from ∼ 0.63 to ∼ 0.44, confirming smooth convergence. A brief gradient spike at step 650 (‖∇‖=7.48\|∇\|\!=\!7.48) marks the onset of effective consistency learning and is immediately absorbed. Training is stable throughout with no NaN or divergence events. Training dynamics. We log every 50 steps during a 5,000-step SnapFlow training run on π 0.5 (batch size 4, single A800, 25 minutes total). The training exhibits three clear phases: 1. Warmup (steps 0–500): The learning rate ramps from 1.3×10−61.3\!×\!10^-6 to 2.4×10−52.4\!×\!10^-5. Loss oscillates between 0.016–0.028 (mean 0.021) as the zero-initialized target-time embedding ϕs _s begins to differentiate the consistency objective from standard FM. Gradient norms are moderate (∼ 0.6). 2. Consistency onset (steps 500–1,000): The peak learning rate drives active consistency learning. A notable gradient spike at step 650 (‖∇‖=7.48\|∇\|\!=\!7.48) marks the point where the consistency objective begins producing meaningful updates; the loss briefly rises to 0.035 then recovers sharply. This spike is transient and does not cause instability. 3. Convergence (steps 1,000–5,000): Under cosine LR decay, both loss and gradient norm decrease monotonically. The loss trends from ∼ 0.021 (step 1,000) to ∼ 0.017 (step 3,500–5,000), with lowest values of 0.009 (steps 3,250 and 4,400). The gradient norm decreases from ∼ 0.9 to ∼ 0.4, confirming the model approaches a stable minimum. The initial loss is already low (∼ 0.02) because SnapFlow fine-tunes a converged FM checkpoint: the FM component (α=0.5α\!=\!0.5 of the batch) is nearly at its optimum from the start, and the consistency component is weighted by λ=0.1λ\!=\!0.1. Despite this, the 18% relative loss reduction (0.021→ 0.017) and the 30% gradient norm reduction (0.63→ 0.44) are significant—they directly translate to the quality gap between naïve 1-step and SnapFlow 1-step observed in simulation (Table 1). Stability observation. Unlike many consistency distillation methods that require careful EMA scheduling or progressive step reduction Song et al. [2023], Lu and Song [2025], SnapFlow training is remarkably stable. We attribute this to three factors: (a) the zero-initialized ϕs _s ensures a smooth start where FM training is initially unperturbed; (b) the FM component (α=0.5α\!=\!0.5) acts as an implicit regularizer that prevents the velocity field from degenerating; and (c) the low consistency weight (λ=0.1λ\!=\!0.1) prevents the consistency gradient from dominating early training. Across all experiments (including ablations with α∈0,0.3,0.7,1.0α∈\0,0.3,0.7,1.0\ and λ∈0.01,1.0λ∈\0.01,1.0\), we observed zero training instabilities—no NaN losses, no gradient explosions, and no need for manual intervention. Appendix J Training Hyperparameters Table 10 lists all hyperparameters used for SnapFlow training across both VLA architectures. Unless stated otherwise, the same hyperparameters are used for all VLAs—an important aspect of the plug-and-play design. Hyperparameter selection rationale. • α=0.5α\!=\!0.5: An equal mix of FM and consistency samples ensures that the velocity estimator θu_θ remains well-calibrated throughout training (needed for the consistency target in Eq. 10) while providing sufficient 1-step supervision. This is the same default used in α-Flow Zhang et al. [2025]. • λ=0.1λ\!=\!0.1: The consistency gradient tends to be larger in magnitude than the FM gradient (because the shortcut target spans the full [0,1][0,1] interval). A weight of 0.1 brings the two gradient norms to comparable scales, preventing the consistency loss from dominating early training. • Learning rate 2.5×10−52.5× 10^-5: One-tenth of the original π 0.5 training rate, reflecting that we are fine-tuning from a converged checkpoint rather than training from scratch. We apply linear warmup over 500 steps. • Prediction clamp [−20,20][-20,20]: The velocity predictions are clamped to prevent numerical instabilities from occasional outlier predictions during early consistency training. In practice, converged predictions rarely exceed ±5± 5. • 30k training steps: Empirically, the combined loss plateaus by ∼ 3.5k steps in our 5k-step convergence study (see Appendix I). We train for 30k to ensure full convergence with diminishing-return safety margin. This corresponds to ∼ 12h on a single A800 GPU. Table 10: SnapFlow training hyperparameters. Parameter Value SnapFlow FM/Consistency ratio α 0.5 Consistency weight λ 0.1 Prediction clamp range [−20,20][-20,20] Target-time projection Zero-init MLP Training Optimizer AdamW Learning rate 2.5×10−52.5× 10^-5 Gradient clipping norm 1.0 Warmup steps 500 Total steps 30,000 Batch size 4 Precision bfloat16 Frozen components VLM backbone (PaliGemma) Trainable components Action expert + target-time proj Gradient checkpointing Enabled Inference Denoising steps 1 (1-NFE) Action chunk size 50 Executed action steps 10