One-sentence Summary

Zhejiang University and Alibaba DAMO Academy propose VLA-Corrector, a lightweight detect-and-correct inference framework that augments action-chunked VLA policies with a Latent-space Vision Monitor for online detection of visual dynamics deviations and Online Gradient Guidance for corrective replanning, enabling event-triggered adaptive action horizons without retraining the backbone policy, interrupting compounding errors while preserving the efficiency of action chunking and substantially improving robustness in long-horizon, contact-rich robotic manipulation tasks.

Key Contributions

• This work quantifies the performance–efficiency trade-off imposed by fixed action horizons in action-chunked VLA policies, showing that the open-loop blind spot consistently degrades robustness across different VLA backbones.
• VLA-Corrector is introduced as a lightweight inference-time framework that integrates a Latent-space Vision Monitor for online drift detection, event-triggered truncation of stale actions, and Online Gradient Guidance to steer corrective replanning without altering the VLA backbone.
• Simulation and real-world experiments show that on π₀.₅ at horizon 50, VLA-Corrector raises success from 48.7% to 58.7% while slightly reducing policy calls, yielding a +24.6% success-per-call efficiency gain, and enables a few-shot fine-tuned model to reach 97.8% average success on LIBERO, surpassing the fully fine-tuned baseline.

Introduction

The authors examine vision-language-action (VLA) foundation models for robot control, which often rely on action chunking to amortize the high latency of generative action policies. This chunking creates an open-loop blind spot where the robot executes a fixed number of predicted actions without responding to fresh observations, leaving it vulnerable to compounding errors and task failure. They propose VLA-Corrector, a lightweight inference-time module that continuously monitors latent-space visual dynamics to detect execution drift, truncates stale action chunks early, and then applies gradient-guided re-inference to steer the robot back toward the intended trajectory. This turns a fixed action horizon into an adaptive one, preserving the efficiency of long chunks while regaining short-horizon reactivity, all without retraining the underlying VLA model.

Method

The main limitation that VLA-Corrector targets is the open-loop blind spot inherent in action-chunked VLA policies. In such policies, the visual encoder processes observation $o_t$ot​ into a latent $Z_t^{\mathrm{real}}$Ztreal​, and the policy outputs an action chunk $A_t$At​ containing multiple future actions. During the action horizon, the controller executes the first $H$H actions without re-querying the policy, even though fresh visual observations become available. This creates a window where the executed actions may drift from the intended trajectory without any corrective mechanism.

VLA-Corrector addresses this by decoupling action generation from execution monitoring. The core idea is to keep the VLA backbone for action chunk generation while adding a lightweight external dynamics corrector that monitors online visual consistency and triggers corrective replanning only when persistent drift is detected. The framework consists of four tightly integrated modules: (1) training an external latent dynamics corrector, (2) Latent-space Vision Monitor (LVM) for online anomaly detection, (3) event-triggered truncation, and (4) Online Gradient Guidance (OGG) for corrective inference.

The external latent dynamics corrector $M_\phi$Mϕ​ is trained after the VLA policy has been fine-tuned and frozen. Using the VLA’s visual encoder, the authors extract latent representations from demonstration trajectories. For a transition $(o_t, a_t, o_{t+k})$(ot​,at​,ot+k​), they compute the true short-horizon visual latent evolution:

$$\Delta Z_{t+k}^{*} = Z_{t+k}^{\mathrm{real}} - Z_t^{\mathrm{real}},$$ΔZt+k∗​=Zt+kreal​−Ztreal​,

and train a lightweight MLP $M_\phi$Mϕ​ to predict this residual from the current latent state and the executed action:

$$\Delta \hat{Z}_{t+k} = M_\phi(Z_t^{\mathrm{real}}, a_t).$$ΔZ^t+k​=Mϕ​(Ztreal​,at​).

The objective encourages both magnitude matching and directional consistency:

$$\mathcal{L}_{\mathrm{corr}} = \big\| \Delta \hat{Z}_{t+k} - \Delta Z_{t+k}^{*} \big\|_2^2 + \beta \big[1 - \operatorname{CosSim}(\Delta \hat{Z}_{t+k}, \Delta Z_{t+k}^{*})\big].$$Lcorr​=​ΔZ^t+k​−ΔZt+k∗​​22​+β[1−CosSim(ΔZ^t+k​,ΔZt+k∗​)].

Predicting residuals instead of absolute latents suppresses static scene content and forces the model to focus on task-relevant dynamics. The corrector is a small module (around 40M parameters in the authors’ experiments) trained solely on demonstration data, which makes it cheap to train and reusable across different benchmarks without touching the expensive VLA backbone.

During deployment, the Latent-space Vision Monitor (LVM) leverages the trained corrector to detect online deviations. At control step $t$t, LVM uses the executed action $a_t$at​ and the current latent state to compute the expected latent evolution $\Delta Z_{t+k}^{\exp} = M_\phi(Z_t^{\mathrm{real}}, a_t)$ΔZt+kexp​=Mϕ​(Ztreal​,at​). It then compares this with the actual latent evolution $\Delta Z_{t+k}^{\mathrm{real}} = Z_{t+k}^{\mathrm{real}} - Z_t^{\mathrm{real}}$ΔZt+kreal​=Zt+kreal​−Ztreal​ obtained from the fresh camera observation, yielding an inconsistency score:

$$E_t = 1 - \operatorname{CosSim}\big(\Delta Z_{t+k}^{\exp}, \Delta Z_{t+k}^{\mathrm{real}}\big).$$Et​=1−CosSim(ΔZt+kexp​,ΔZt+kreal​).

A higher $E_t$Et​ indicates a stronger mismatch between expected and observed visual dynamics, serving as a continuous monitoring signal.

Rather than thresholding $E_t$Et​ directly, which would be sensitive to transient outliers, the authors employ a robust event-triggered truncation rule. A sliding window of recent scores $\mathbf{E}_W$EW​ is maintained, and its median $M_e$Me​ and median absolute deviation $\mathrm{MAD}$MAD are computed. Two adaptive thresholds are defined:

$$T_{\mathrm{on}} = M_e + \lambda_{\mathrm{on}}\mathrm{MAD},\quad T_{\mathrm{off}} = M_e + \lambda_{\mathrm{off}}\mathrm{MAD},\quad \lambda_{\mathrm{on}} > \lambda_{\mathrm{off}}.$$Ton​=Me​+λon​MAD,Toff​=Me​+λoff​MAD,λon​>λoff​.

An interrupt is triggered only when $E_t > T_{\mathrm{on}}$Et​>Ton​ persists for $p$p consecutive steps, effectively filtering out isolated spikes while detecting sustained drift. Once triggered, the system discards the remaining actions in the current queue and initiates a corrective replan. The effective action horizon becomes $H_{\mathrm{adaptive}} = h < H$Hadaptive​=h<H, where $h$h is the number of already executed steps, thereby shortening the fixed horizon only when the chunk has truly become stale.

Corrective replanning after truncation is performed by Online Gradient Guidance (OGG), applied exclusively to the policy call immediately following the interrupt. OGG guides the flow-matching denoising process toward a latent direction that compensates for the accumulated drift. At denoising step $\tau$τ, a candidate clean action $\hat{a}_t$a^t​ is estimated from the noisy chunk, and its predicted latent effect is $\Delta \hat{Z}_{\mathrm{act}} = M_\phi(Z_t^{\mathrm{real}}, \hat{a}_t)$ΔZ^act​=Mϕ​(Ztreal​,a^t​). A corrective target $\Delta Z_{\mathrm{corr}}$ΔZcorr​ is defined as the difference between the expected residual from the last stable step $t-k$t−k and the accumulated deviation $\Delta Z_{\mathrm{dev}} = Z_t^{\mathrm{real}} - Z_{t-k}^{\mathrm{real}}$ΔZdev​=Ztreal​−Zt−kreal​:

$$\Delta Z_{\mathrm{corr}} = \Delta Z_{\exp} - \Delta Z_{\mathrm{dev}}.$$ΔZcorr​=ΔZexp​−ΔZdev​.

The guidance loss measures the directional mismatch between the predicted action effect and the corrective target:

$$\mathcal{L}_{\mathrm{OGG}} = 1 - \operatorname{CosSim}(\Delta \hat{Z}_{\mathrm{act}}, \Delta Z_{\mathrm{corr}}).$$LOGG​=1−CosSim(ΔZ^act​,ΔZcorr​).

The gradient of this loss is injected into the flow-matching velocity field:

$$v_\tau^{\text{guide}} = v_\tau - \eta \nabla_{v_\tau} \mathcal{L}_{\mathrm{OGG}},\quad A^{\tau - \Delta\tau} = A^\tau - \Delta\tau \, v_\tau^{\text{guide}}.$$vτguide​=vτ​−η∇vτ​​LOGG​,Aτ−Δτ=Aτ−Δτvτguide​.

Because OGG adjusts the velocity field rather than directly manipulating action coordinates, the corrective replanning remains smoothly integrated with the original flow-matching generative process.

Overall, VLA-Corrector forms a lightweight, modular corrective inference system that sits alongside a frozen VLA policy. It monitors latent dynamics online, truncates unreliable action chunks adaptively, and guides recovery replanning toward a consistent trajectory without retraining the main policy.

Experiment

The evaluation of VLA-Corrector across three simulation benchmarks and a real robot, using multiple VLA backbones, validates its cross-architecture robustness, sample and data efficiency, mechanism, and real-world transfer. The method consistently improves success rates and policy-call efficiency by interrupting stale action chunks early and guiding corrective replanning, with the largest gains on hard tasks and under online disturbances. Mechanistic studies confirm that the detection signal isolates critical error-prone phases while the recovery module enhances post-truncation replanning, and ablations show that decoupled monitoring and moderate data and model sizes suffice.

VLA-Corrector consistently improves success rates across all three VLA backbones on MetaWorld, with larger gains on harder difficulty splits. The average improvement is largest for π0.5 at 15.65 percentage points, driven by a 24-point jump on the Very Hard split. SmolVLA and X-VLA also benefit, achieving average gains of 4.75 and 4.05 points respectively. VLA-Corrector boosts all backbones and achieves its largest absolute improvements on harder tasks, such as the Very Hard split for π0.5. For π0.5, the Very Hard success rate rises from 41.0% to 65.0%, a 24-percentage-point gain. The average improvement ranges from 15.65 points for π0.5 to 4.05 points for X-VLA, demonstrating benefits that scale with backbone baseline performance.

On the LIBERO benchmark, adding VLA-Corrector to a few-shot fine-tuned policy lifts average success from 94.00% to 97.80%, exceeding the fully fine-tuned baseline of 96.95%. The improvement is strongest on long-horizon and spatial tasks, showing that the corrector compensates for limited task-specific data by enabling recovery from execution drift. VLA-Corrector boosts the few-shot policy above the fully fine-tuned model, reaching 97.80% average success. Long-horizon task success jumps from 86.6% to 93.4%, the largest absolute gain among task categories. Spatial tasks achieve perfect 100.0% success after correction, up from 95.4%.

Training the corrector on more demonstration data steadily improves average success over the open-loop baseline. Using the full training split (after validation hold-out) yields the largest gain, while even 60% of the data already delivers most of the benefit, and very low data (20%) slightly underperforms the baseline. With only 20% of the training split, the corrector averages 48.32%, marginally below the baseline's 48.72%. Using the full held-in training split (r=1.0) pushes average success to 54.32%, a 5.60-point improvement, with gains concentrated in medium and hard tasks.

Across both backbones and all action horizons, VLA-Corrector raises task success while typically reducing the average number of policy calls per episode. The largest efficiency gain appears for SmolVLA at the shortest horizon, and improvements remain positive even in the rare case where call counts rise slightly. For SmolVLA with a 10-step horizon, success jumps by 11.1 percentage points and calls drop by 3.63, yielding a 45.3% relative success-per-call efficiency gain. At horizon 40 on π₀.₅, call count increases marginally yet the method still delivers a 10.2% efficiency gain due to a 6.35-point success improvement.

Truncations that trigger corrective re-inference are concentrated in critical task phases, where precision matters most. More than four out of every five truncations occurred during these segments, at a rate over five times higher than in non-critical phases, showing that the interruption mechanism is selective about when to discard stale actions. Over 80% of truncations happened in critical task phases. Truncations were 5.1× more common in critical phases than in non-critical ones.

VLA-Corrector was evaluated on MetaWorld and LIBERO benchmarks across multiple VLA backbones, few-shot and fully fine-tuned policies, varying training data sizes, and different action horizons. It consistently improves task success rates, with the largest gains on harder difficulty splits and long-horizon tasks, and can lift a few-shot policy above a fully fine-tuned baseline. The corrective mechanism also enhances efficiency by reducing the number of policy calls per episode, and its truncations are selectively triggered during critical task phases where precise actions are most needed.