CARE: Certifying Acceleration for Vision-Language-Action Inference

AI summary

Overview

Research area: Efficient inference for vision-language-action (VLA) models, language-model agents, and statistical risk certification (Learn-then-Test, anytime-valid sequential testing). The paper is categorized under Natural Language Processing (arXiv:2610.08917v1 [cs.CL], 06 Oct 2026, CC BY-NC-ND 4.0).

Technical level: Intermediate. The core idea is intuitive, but the paper leans on hypothesis testing, family-wise error control, e-processes, and closed-loop robot evaluation.

Authors and affiliations: Rui Liu and Tong Zheng (University of Maryland, College Park), Jindong Gu (University of Oxford), Zhipeng Wang (Google).

One-sentence scope: CARE is a training-free, offline procedure that selects the fastest accelerated version of an expensive policy whose measured rate of "acceleration-induced failure" is certified, with a finite-sample guarantee, to stay below a user-specified risk budget.

What This Paper Is About

Running a vision-language-action model at every control step is expensive, so researchers speed it up with action chunking, visual-token pruning, feature caching, or fewer flow-matching refinement steps. Those accelerations are normally judged by latency and average task success, but average success hides the specific tasks that acceleration breaks, because tasks newly solved by the faster policy offset tasks it destroys. CARE reframes the problem as a statistical certification question: how much can a policy be accelerated while bounding, with provable confidence, how often acceleration causes a failure on an episode the original full-compute policy would have solved?

Key Contributions

1. A certify-then-select formulation of acceleration safety. CARE returns the fastest candidate whose acceleration-induced failure (AIF) risk is certified below a user-specified budget α, with a finite-sample, PAC-style guarantee (probability of deploying a candidate with risk ≥ α is at most δ) that holds across the whole candidate family, plus a simultaneous lower bound on the fraction of reference-solved episodes preserved. If no candidate can be certified, it retains the reference policy.

2. A new risk definition for closed-loop acceleration. The AIF loss is defined per episode as L_λ(U) = Y₀(U)·(1 − Y_λ(U)), which equals 1 only when the reference succeeds and the accelerated policy fails from the same task, initial scene, and seeds. Risk is the equal-weight task average R(λ) = (1/T)Σₜ E[L_λ(U) | τ = t], and the reported retention is Ret(λ) = Pr(Y_λ = 1 | Y₀ = 1) = 1 − R(λ)/Pr(Y₀ = 1).

3. Two mechanisms that make certification cheap without weakening the guarantee. Task-balanced sequential certification evaluates candidates in rounds of m units per task so every inspection reflects task proportions, and uses an e-process (a likelihood-ratio average over a grid of safe risk values) that remains anytime-valid under early stopping, with family-wise error control via Σδⱼ ≤ δ. Failure-triggered reference evaluation exploits the fact that a candidate success makes the reference outcome irrelevant, so the expensive reference policy runs only after a candidate failure, with outcomes cached across candidates — yielding exactly the same losses and certification decisions as exhaustive paired evaluation.

4. Empirical validation across model classes, acceleration mechanisms, and domains. Experiments cover OpenVLA-OFT and the flow-matching policy π₀.₅ on LIBERO, and Qwen3.5-9B and Llama-3.1-8B agents in Crafter, showing large certified speedups where common selectors violate the budget while cutting certification cost by nearly 80%.

Main Findings

• Certified speedups are large on LIBERO. With OpenVLA-OFT, one-step replanning (H1) as reference, an eight-configuration candidate family, 500 matched scenes per suite (2,000 initial scenes, 18,000 rollouts), 250 task-balanced calibration episodes and 250 test episodes per suite, α = 5.0% and δ = 5.0%: CARE certifies FastV-25 H8 on Goal (9.02× speedup, 93.5% preserved), FastV-75 H8 on Spatial (10.08×, 95.7%), Plain H8 on Object (9.56×, 92.2%), and VLA-Cache H8 on Long (10.81×, 85.8%). The preserved figures are simultaneous 95% lower bounds on reference-solved episodes retained.

• Common selectors blow the budget; CARE does not. Across 10,000 resampling trials of 250 calibration episodes each, at α = 2.0% and α = 2.5% the over-budget rates were: latency-only 75.0% / 25.0%, average-success 75.0% / 25.0%, validation-tuned 36.8% / 13.0%, unpaired test 67.1% / 19.5%, and CARE 0.0% / 0.0%. CARE's validity comes from safe fallback to H1 rather than forced acceleration.

• At the standard budget, CARE is both faster and cheaper. At α = 5.0%, fixed-n CARE achieves the highest mean speedup among risk-controlling selectors: 8.88× with 11.7% fallback and 2,250 rollouts. Pareto Testing gets 6.16× (42.2% fallback), cost-order fixed-sequence LTT 6.35× (45.5%), safe policy improvement 5.30× (60.5%). Sequential CARE keeps 7.32× with 26.9% fallback while using only 592 rollouts, a 73.7% reduction.

• A larger candidate family widens CARE's lead. With 24 OpenVLA-OFT configurations (horizons H ∈ {2,4,6,8} × six inference modes), CARE is the only method that certifies an accelerated policy on all four suites (FastV-25 H8, FastV-75 H8, Plain H8, VLA-Cache H8), using 5,263 rollouts (5,150 candidate + 113 reference) versus 25,000 for full-sample Hoeffding–Bentkus, a 78.9% saving. Sequential HB saved 70.8% (7,306 rollouts, certified only on Object), sequential exact 74.1% (6,485, reference retained on Long), and the plug-in e-process 76.5% (5,873, reference retained on Spatial and Long). CARE used 610, 1,222, and 2,043 fewer rollouts than the plug-in e-process, sequential exact, and sequential HB respectively.

• Certification transfers to flow-matching policies and to language-model agents. For π₀.₅ with ten-step inference and H8 as reference, three candidates (2, 4, or 6 flow steps) checked every 50 episodes over 250 task-stratified episodes per suite at α = 0.05: CARE selected two-step on Spatial and Object (20% of reference compute, 1.45×, 254 and 253 rollouts, 74.6% and 74.7% savings) and four-step on Goal (40% compute, 1.26×, 305 rollouts, 69.5%), while retaining the reference on Long (464 rollouts, 53.6% saving). Totals were 1,276 rollouts (1,250 candidate + 26 reference) versus 4,000 exhaustive, a 68.1% saving. In Crafter, Qwen3.5-9B certified its collect_wood schedule on 3/3 seeds at 69.4% of reference compute and its collect_drink schedule on 2/3 seeds at 85.8%; Llama-3.1-8B certified collect_wood on 3/3 at 74.9% and collect_drink on 2/3 at 98.6% — reductions of 25.1%–30.6% on the wood schedules.

• Local, per-decision signals do not predict episode-level failure. On Object, the local acceleration rate was 4.3% versus an episode-level rate of 1.0%; on Long, 9.5% versus 2.7%. This supports certifying complete paired episodes rather than individual decisions (the paper states this risk cannot in general be recovered from marginal success rates or per-decision measurements such as confidence or action coverage; Appendix A.5).

• Family correction and task-balancing are both necessary. In a controlled ten-candidate simulation, uncorrected selection deployed an over-budget policy in 46.0% of trials, whereas family-corrected testing stayed at or below 0.15%. Balanced round-robin acquisition stayed within the candidate-level error budget for every tested heterogeneous task-risk profile, while task-by-task acquisition could certify an over-budget policy before its high-risk tasks were observed.

• The efficiency gains decompose cleanly. Sequential fastest-first evaluation cut candidate rollouts from 8,000 to 1,950 by abandoning candidates that can no longer be certified; failure-triggered evaluation cut H1 rollouts from 1,000 to 47. Together they reduced total evaluation from 9,000 to 1,997 rollouts, a 77.8% reduction, and wall-clock time from 38.6 to 7.0 hours, an 81.9% reduction.

Methodology in Plain English

The starting point is a heavy reference policy π₀ and a list of M acceleration settings Λ = {λ₁, …, λ_M}, each of which turns π₀ into a faster policy (for example, an action-chunk length, a token-pruning ratio, or a number of flow-integration steps). CARE runs once, offline, before deployment, and treats every accelerated policy as a black box that only needs to report whether the episode succeeded and how much compute it used.

The safety signal is a paired comparison. For each episode, the reference and the candidate start from exactly the same task, initial scene, and random seeds. CARE records whether the reference succeeded and the candidate failed — that single combination is the failure of interest. Because a cheaper action changes the next state and every state after it, this quantity cannot be reconstructed from each policy's overall success rate or from per-step confidence; it has to be measured on complete episodes.

Turning that measurement into a guarantee is framed as multiple hypothesis testing. For each candidate, the null hypothesis is "this candidate's risk is at least α." A candidate is certified only if that hypothesis is rejected at its allocated significance level, with levels set so they sum to at most δ, which bounds the chance of certifying any unsafe candidate by the union bound.

To avoid wasting compute, candidates are pre-sorted from fastest to slowest using a separate, small profiling set, and tested in that order so the search stops at the first certified candidate. Evaluation happens in task-balanced rounds — the same number of episodes from every task per round — so an early look cannot be fooled by seeing only low-risk tasks. Evidence is checked only at round boundaries using an anytime-valid e-process, which permits stopping the moment a candidate is certified, or abandoning a candidate whose accumulated failures make certification impossible. Finally, since a candidate success forces the AIF loss to zero regardless of the reference, the reference policy is executed only when a candidate fails, and its outcome is cached and reused for later candidates. None of these shortcuts change which candidate gets certified, so the deployment guarantee survives.

Why This Matters

Acceleration research typically reports a speed–accuracy trade-off, and average task success is a weak safety signal: it lets tasks the faster policy repairs cancel tasks it breaks. CARE converts "is this acceleration safe enough to deploy?" into a decision with a stated confidence level, so practitioners can pick an acceleration setting on evidence rather than by trial and error on a robot.

Real-world applications:

• Robotic manipulation and warehouse or lab automation, where a chunked, pruned, or cached VLA policy must be trusted on episodes the full model previously solved.
• Edge and on-device deployment of large multimodal policies, where the reference model can be kept as a fallback when no acceleration is certifiable.
• Flow-matching generative policies for control, where the number of refinement steps is a direct compute knob that CARE can certify suite by suite.
• Language-model agents acting in simulated or game-like environments, where a learned compute schedule can be certified per task and per random seed.

Industry relevance: Certification shifts an engineering argument from benchmark averages to a deployment-level risk statement, which matters for cost planning (fewer GPU hours per control step), for release decisions (deploy fast, or retain the reference), and for auditing acceleration methods that are already shipping. Because CARE only needs terminal outcomes and measured compute, it drops into existing pipelines without retraining or architecture changes, and it applies unchanged across chunking, token pruning, feature caching, flow-step reduction, and their combinations.

Future Directions

• How well do the certified bounds transfer when the deployment scene distribution differs from the calibration set, given that risk is defined under an equal-weight task mixture?
• How does certification cost scale with much larger candidate families, or with accelerations that are composed online rather than fixed in advance?
• Can the same paired-episode guarantee be extended to continuous severity measures of degradation, rather than the binary succeed/fail outcome CARE relies on?
• What happens under long-horizon or multi-robot settings where paired rollouts become expensive or initialization cannot be perfectly matched?
• Would combining certified selection with online monitoring during deployment allow re-certification when policies drift, and at what added overhead?

Target Audience

Robotics and embodied-AI engineers deploying VLA policies; efficiency and inference-optimization researchers working on action chunking, token pruning, feature caching, or flow-step reduction; applied machine-learning practitioners who need defensible deployment criteria rather than average-success numbers; and statisticians or safety researchers interested in how selective inference tools such as Learn-then-Test, e-processes, and conformal risk control behave in closed-loop control settings.

Authors’ abstract

While vision-language-action (VLA) models have advanced rapidly, running them at every control step remains expensive. Prior work accelerates VLA inference using techniques like action chunking and visual-token pruning, typically evaluating based on latency and average task success. However, acceleration may discard information and break tasks the original policy would solve, a risk hidden by average metrics. Measuring these failures is challenging because action deviations compound over closed-loop trajectories, meaning task failure is only observable across full episodes. We therefore define an acceleration-induced failure via paired rollouts from identical initial conditions, tracking when the reference succeeds but the accelerated policy fails. To manage this, we introduce CARE, an approach for certified accelerator selection. CARE uses paired rollouts on a calibration set to provide finite-sample guarantees that acceleration-induced failure risk stays below a user-specified budget. It deploys the fastest certified candidate, falling back to the reference if none qualify. By relying only on terminal outcomes and measured compute, CARE applies unchanged across diverse acceleration mechanisms, while sequential testing and failure-triggered reference rollouts keep certification affordable. On four LIBERO suites with OpenVLA-OFT, CARE certifies $9.0$--$10.8\times$ speedups while guaranteeing (at $95\%$ confidence) that at least $85.8\%$ of reference-solved episodes are preserved. Under tight budgets, selectors without guarantees exceed the budget in up to $75\%$ of trials, whereas CARE stays within budget and its sequential form uses $78.9\%$ fewer rollouts than exhaustive evaluation. CARE further generalizes to flow-step reduction for $π_{0.5}$, and to Qwen3.5-9B and Llama-3.1-8B agents in Crafter.