VeriVLA: 잠재 월드모델로 플로 기반 VLA의 행동을 실행 직전 검증하는 적응형 기법

Abstract

Flow-based Vision-Language-Action (VLA) policies are inherently stochastic: different noise seeds can produce action chunks of varying quality from the same observation. At test time, however, the policy typically commits to a single sample without an explicit estimate of its quality. In fine-grained manipulation, executing a suboptimal action can irreversibly disrupt task progress and lead to failure. To exploit policy stochasticity, we introduce a training-free two-axis trigger that uses two initial samples to measure within-chunk temporal variation and cross-sample variance, detecting the critical states. Once triggered, a JEPA-based latent world model ranks candidate action chunks by predicting action-conditioned future latent states and the corresponding changes in task progress. By operating in latent space, the verifier avoids pixel reconstruction and enables efficient and more accurate ranking. Across three real-world tasks (i.e., pen insertion, pipetting, and apple placement), our method raises the average completion score from 50.8% to 65.5%, while adding 326 ms for sampling and verification per triggered decision on a single RTX 4090. Consistent gains are also observed in simulation, where the average success rate rises from 66.4% to 73.6% in the clean setting of RoboTwin 2.0, from 62.8% to 69.6% in its randomized setting, and from 96.9% to 97.6% on LIBERO. Project page: https://shirley430316.github.io/projects/verivla/.

1 Introduction

Vision-Language-Action (VLA) models have emerged as a promising paradigm towards general robotic control [6, 22, 4]. In the pretraining stage, the field has evolved from VLMs autoregressively generating over discretized action tokens [54, 22, 38] to more recent flow-matching action experts coupled with pretrained VLMs [36, 4, 19], enabling scalable learning from diverse action trajectories. The paradigm shift was foreshadowed by diffusion-based visuomotor policies [10], which established iterative denoising as an effective means of learning multi-modal (i.e., multi-peaked) action distributions. However, the stochasticity that benefits learning also introduces a unique challenge at deployment.

Given the same observation and instruction, different noise seeds yield samples of different quality during inference. However, the flow-based VLA model cannot distinguish which action chunk is most likely to succeed. During execution, a robot must commit to one sampled action chunk, which may irreversibly change the physical world. A good action chunk advances the task, while a poor one could directly lead to failure or accumulate errors that drift the trajectory out of distribution [40, 30, 31]. We empirically show that the policy variance is non-uniform along the task, and failures tend to happen in high-variance segments of the action trajectory, as in Figure 1(a). What if we could detect these critical moments before committing to an irreversible action, and briefly “rewind” the decision by spending additional computation? This calls for two components: a trigger that decides when the states are critical and additional computation is worthwhile, and a verifier that determines which sampled action should be executed.

To answer the first question, we start with the policy’s uncertainty. As shown in Figure 1(a), when the end-effector is close to a contact-rich interaction region, the trajectory follows a more complex motion [37], and internally, the policy uncertainty increases. We therefore combine temporal action variation and cross-sample uncertainty into a training-free two-axis trigger. Computed with two sampled action chunks, the trigger closely tracks the contact information from the environment and aligns well with the policy’s intrinsic uncertainty, as shown in Figure 1(b). We therefore use the trigger to activate repeated sampling and verification at critical decision steps.

Once repeated sampling is activated, the second question arises: how should candidate actions be evaluated? We argue that latent world models are a natural fit. The verifier evaluates the quality of action chunk samples by predicting the progress or relative ranking [23, 11]. Therefore, the model must understand world dynamics and represent the future states resulting from executing the action chunk. In addition, verification is a low-dimensional problem: how much an action chunk advances the task is a scalar judgment, and most camera pixels are irrelevant to it. As a result, pixel-level world models have two pitfalls: (1) the image or video generation incurs substantial latency, making it difficult to deploy at real-time control frequencies; and (2) they solve the harder pixel generation before the easier progress estimation, making the quality of downstream verification unnecessarily dependent on generation fidelity. We compare these paradigms in Figure 2. This motivates verification in a latent space, which compresses the pixel observation into compact and dynamic-rich features, where we can jointly predict the latent states and task progress.

Building on these observations, we recast action randomness not as a hazard to be suppressed but as a resource to select from, with the latent world model as a verifier. Specifically, we claim the following contributions:

1. A latent world model as a verifier. We exploit the action-conditioned latent representation produced by a pretrained latent world model to estimate the progress of candidate action chunks.
2. An empirical characterization of policy stochasticity in flow-based VLAs and the two-axis trigger. We characterize policy stochasticity. Leveraging the temporal action variation and the cross-sampling variance, we propose a two-axis trigger that is action-based and training-free. It detects the critical states and reduces inference costs while preserving the benefits of test-time selection.
3. A simple training, evaluation, and real-robot deployment pipeline. On real-world manipulation tasks, each triggered round of repeated sampling and verification adds 326 ms of latency. Our method improves the average completion score by 14.7 percentage points over the base policy, outperforming baselines, including VLM-based verifiers and pixel-level world model verifiers.

2 Related Work

Test-time Enhancement for VLAs.

Existing approaches can be broadly categorized according to whether the VLA policy is updated at deployment time. Test-time training methods, such as EVOLVE-VLA [3] and TT-VLA [28], perform online policy optimization during deployment using dense reward signals. Rather than relying on external reward estimation, T2VLA [8] derives intrinsic rewards from the policy’s own confidence to enable self-supervised adaptation.

Another line of work keeps the pretrained VLA policy frozen and improves action quality through either gradient-free selection or gradient-based augmentation. Gradient-free methods [46] generally adopt a repeated-sampling-and-selection strategy where a model-based verifier evaluates candidate actions. RoboMonkey [23] uses a VLM-based verifier to select the optimal action, demonstrating a test-time scaling law of autoregressive VLAs. GPC-RANK [39] employs a lightweight pixel-generation model with a downstream estimator to rank candidate actions. DreamAvoid [11] combines a pretrained foundation-level, action-conditioned video generation model with an estimator and introduces a vision-based trigger to reduce computational overhead. In contrast, gradient-based methods such as Guided Action Flow [47] backpropagate gradients from the verifier score to refine sampled actions.

In this work, we follow the repeated-sampling-and-selection paradigm. Unlike prior verifier-based methods, which rely on VLMs or pixel-level world models followed by downstream signal extraction, our approach uses a latent world model to jointly predict dynamics and estimate task-specific progress, synergizing with an action-based trigger to allocate computation adaptively. We compare more test-time verification methods in Appendix A.

Latent World Models for Robotics.

Building on advances in visual representation learning, prior research on latent world models has developed along two main directions. The first line of work [42, 33, 51], represented by DINO-WM [53], V-JEPA 2-AC [2] and H-JEPA [50] utilizes pretrained visual encoders and trains dynamics predictors to perform zero-shot planning in latent space. Given a goal image, these methods employ search-based algorithms to identify suitable action proposals. The second direction combines latent world models with VLAs. VLA-JEPA [44], Being-H0.7 [32] and Copper-Policy [14] incorporate the prediction objective of latent world models into VLA training, while LaWAM [7] introduces a latent subgoal as an additional conditioning signal. These integrated approaches improve overall manipulation performance and generalization.

3 Method

3.1 Problem Formulation

In the standard VLA setting, at each decision step t, a policy \pi_{\theta} generates an action chunk with current observation o_{t}, language instruction l, and robot proprioceptive state s_{t}:

a_{t:t+H}\sim\pi_{\theta}(\cdot\mid o_{t},l,s_{t}),

where a_{t:t+H} denotes H consecutive actions, from timestep t to t+H-1. Recent VLAs commonly employ flow-matching-based action generation [19], which takes random Gaussian noise as input. This noise dependence is typically omitted from the policy notation. We make this dependence explicit:

a^{(i)}_{t:t+H}\sim\pi_{\theta}(\cdot\mid o_{t},l,s_{t},N_{i}),

where N_{i} denotes the random seed used to generate the Gaussian noise, with a distinct seed for each sampling index i. Repeated sampling therefore produces a set of diverse action chunks \{a_{t:t+H}^{(i)}\}_{i=1}^{K}.

Executing an action chunk changes task progress; therefore we define the quality of an action chunk as its change in progress, referred to as delta progress,

\Delta p=p_{t+H}-p_{t},

where p_{t} is the task progress at timestep t. Compared with absolute progress, delta progress matches the effect of the action chunk, making it a more direct and intuitive target for action evaluation [9].

3.2 Overview

As illustrated in Figure 3, our framework comprises two tightly related components: Two-Axis Trigger and Latent World Model Verifier. Based on initial action chunk samples, the trigger identifies decision steps at which the policy is likely to produce unreliable actions and activates verification only in these challenging situations.

When the trigger is inactive, no additional action chunks are sampled, and the initial sample a^{(1)}_{t:t+H} is executed directly. When the trigger is activated, the policy generates additional samples to expand the candidate action pool. The verifier V_{\phi} then predicts the delta progress associated with each candidate:

\left(\hat{z}_{t+H}^{(i)},\Delta\hat{p}^{(i)}\right)=V_{\phi}\left(s_{t},a^{(i)}_{t:t+H},o_{t};q_{l}\right),

where q_{l} is the learned query token for the instructed task, \hat{z}_{t+H}^{(i)} denotes the predicted visual latent at time step t+H, and \Delta\hat{p}^{(i)} denotes the estimated delta progress of the sample i. The action chunk with the largest estimated delta progress is subsequently executed.

3.3 Two-axis Trigger

Following prior work [16, 11] and our empirical observations (shown in Figure 1), we design two complementary signals for allocating verification computation: (C1) activate in contact-rich regions, where manipulation is inherently more complex [37] and failures concentrate; and (C2) activate at states where repeated sampling produces diverse candidate actions, providing the verifier with meaningful alternatives to choose from.

At timestep t, we draw k action chunks \{a_{t:t+H}^{(i)}\}_{i=1}^{k} from the VLA policy, where k is chosen to be much smaller than the full sampling budget K used during verification, so that the trigger incurs acceptable overhead. To avoid bias toward fast-moving stages, each action chunk is first normalized by its average action magnitude m^{(i)}. We denote the normalized actions by \tilde{a}^{(i)}_{t+j}=a^{(i)}_{t+j}/m^{(i)}. The sampled action chunks can be viewed along two complementary axes. The temporal axis of each action chunk captures C1, while the sample axis across repeated action chunks captures C2. Along the temporal axis, we measure the mean squared changes between consecutive actions within each sampled chunk, defined as

T_{\text{temp}}(s_{t})=\frac{1}{k}\sum_{i=1}^{k}\frac{1}{H-1}\sum_{j=1}^{H-1}\|\tilde{a}^{(i)}_{t+j}-\tilde{a}^{(i)}_{t+j-1}\|^{2}.

Motivated by AdaFlow’s variance-adaptive computation [16], we measure cross-sample action variance:

T_{\text{cross}}(s_{t})=\frac{1}{k}\sum_{i=1}^{k}\frac{1}{H}\sum_{j=0}^{H-1}\big\|\tilde{a}_{t+j}^{(i)}-\bar{\tilde{a}}_{t+j}\big\|^{2},

where \bar{\tilde{a}}_{t+j}=\frac{1}{k}\sum_{i=1}^{k}\tilde{a}_{t+j}^{(i)} is the mean action at step t+j over k samples. In practice, we use k=2 as two samples are sufficient to reflect the cross-sample divergence.

Before deployment in a new environment, we perform a lightweight calibration by rolling out the base policy and computing T_{\text{temp}} and T_{\text{cross}} at every timestep for a small number of episodes to collect a reference set. The collected statistics form two empirical reference distributions for the environment. During execution, the trigger values T_{\text{temp}}(s_{t}) and T_{\text{cross}}(s_{t}) are converted into their corresponding percentiles, \tau_{\text{temp}}(s_{t}) and \tau_{\text{cross}}(s_{t}), within their respective reference distributions. The overall trigger score is then defined as

\tau(s_{t})=\max\bigl(\tau_{\mathrm{temp}}(s_{t}),\;\tau_{\mathrm{cross}}(s_{t})\bigr).

The trigger follows an OR rule, activating when either percentile exceeds the threshold: \tau(s_{t})>\tau_{0}, where \tau_{0} is the only trigger hyperparameter that decides how strict the trigger is. Since the trigger correlates well with the critical states, calibrating \tau_{0} is straightforward and a few rollout episodes are sufficient.

3.4 Latent World Model Verifier

When the Two-Axis Trigger is activated, we perform additional sampling to obtain the remaining K-k action chunk candidates, resulting in a total of K candidates \{a_{t:t+H}^{(i)}\}_{i=1}^{K}. Unlike search-based planning with latent world models [53, 2], our verifier ranks action chunk candidates by predicting delta progress without the need for a goal image. This makes it compatible with real-time VLA inference.

Architecture.

We instantiate the verifier using the Joint-Embedding Predictive Architecture (JEPA) world model framework [2, 34], which consists of a pretrained visual encoder and an action-conditioned autoregressive predictor. The encoder compresses the current observation into a latent representation, while the predictor models how the latent state evolves conditioned on robot actions.

To adapt the pretrained world model to our setting, we introduce embodiment-specific state encoders and action encoders together with sub-chunk rollouts. For each embodiment, the encoders project the raw robot states and actions into the predictor embedding dimension. Each action chunk with horizon H is uniformly divided into M sub-chunks, enabling multi-step latent rollouts. This design provides denser supervision than predicting only the state at the end of the full action chunk, while reducing inference overhead and mitigating error accumulation compared with predicting a state after every individual action.

Building upon the latent world model, we introduce a delta progress prediction branch. Unlike latent state prediction, which models task-agnostic environment dynamics, delta progress prediction estimates how much the executed action sub-chunk advances the specified task. Consequently, it requires task-specific information beyond the current observation, robot state, and action. For example, the same state transition corresponds to positive progress for the task “closing the closet”, but negative progress for “opening the closet”. We therefore introduce a task-specific learnable query token to condition delta progress prediction.

Following the autoregressive paradigm, the predictor first imagines the next latent state \hat{z} and then predicts the corresponding progress increment \Delta\hat{p} for each input action sub-chunk. An attention mask prevents latent state prediction from attending to the task query. Otherwise, task-specific information could leak into the latent dynamics model, encouraging the predictor to exploit task semantics instead of learning task-agnostic environment dynamics. This design cleanly separates task-conditioned progress estimation from task-agnostic latent dynamics modeling, allowing the pretrained world model to be adapted for verification while preserving its original modeling objective.

Training.

The verifier is jointly optimized for latent prediction and progress estimation, with progress estimation as the primary objective. Across the M action sub-chunks, the progress loss combines a Huber regression loss [18] with a pairwise ranking loss:

\displaystyle\mathcal{L}_{\text{prog}}=\sum_{i=1}^{M}\Bigg[\frac{1}{|\mathcal{B}_{i}|}\sum_{k\in\mathcal{B}_{i}}L_{\delta}\bigl(\Delta\hat{p}^{(k)}_{i},\Delta p^{(k)}_{i}\bigr) \\ \displaystyle+\frac{\lambda_{\text{rank}}}{|\mathcal{P}_{i}|}\sum_{(k,l)\in\mathcal{P}_{i}}\max\Bigl(0,\,\begin{aligned} &-\bigl(\Delta\hat{p}^{(k)}_{i}-\Delta\hat{p}^{(l)}_{i}\bigr)\\
&+\alpha\bigl(\Delta p^{(k)}_{i}-\Delta p^{(l)}_{i}\bigr)\end{aligned}\Bigr)\Bigg],

where \Delta\hat{p}^{(k)}_{i} and \Delta p^{(k)}_{i} denote the predicted and target progress for sample k at sub-chunk i, respectively. Here, \mathcal{B}_{i} is the batch; \mathcal{P}_{i} contains same-task pairs with \Delta p_{i}^{(k)}>\Delta p_{i}^{(l)}, following DreamAvoid [11]. Empty pair sets contribute zero ranking loss. The coefficient \lambda_{\text{rank}} balances regression accuracy and ranking consistency, while \alpha controls the target-difference-dependent ranking margin. Huber regression fits progress targets, while ranking preserves within-task ordering. The absolute progress is labeled autonomously with Robometer [25], and then the delta progress is calculated based on the result. The visual prediction loss is defined following V-JEPA 2-AC [2],

\mathcal{L}_{\text{vis}}=\sum_{i=1}^{M}\|\hat{z}_{t+i\cdot\frac{H}{M}}-z_{t+i\cdot\frac{H}{M}}\|_{1}.

The total training loss is computed as

\mathcal{L}=\mathcal{L}_{\text{prog}}+\lambda_{\text{vis}}\mathcal{L}_{\text{vis}}.

We use both teacher forcing and self-forcing [17] during the training stage to balance learning efficiency and inference distribution alignment.

Inference.

At inference time, the predictor conditions exclusively on its previously predicted latent frames and autoregressively rolls out over the M sub-chunks of each candidate action chunk. The verifier thus produces M delta progress estimates for each candidate. The robot then executes the action chunk with the largest cumulative predicted progress, computed as the sum of these M estimates.

To keep verification practical for real-world deployment, three latency optimizations are applied cumulatively: (O1) reusing the KV cache of the verifier throughout the autoregressive rollout, (O2) optimizing the inference pipeline by overlapping independent computations, including the parallel generation of candidate action chunk samples and performing latent feature encoding in parallel with the action generation of the VLA policy, and (O3) PyTorch-level optimization, including pre-compilation.

4 Experiments

We organize our experiments around the core question: how the verifier should be designed. We first evaluate the mechanism in three settings: (1) real-world fine-grained manipulation tasks, validating the complete system under practical latency and hardware constraints, (2) RoboTwin 2.0 clean, studying the trade-off between inference efficiency and performance, and (3) RoboTwin 2.0 clean2random, showcasing the generalization ability of the verifier under randomized settings. We conduct ablation studies to assess the model design. We additionally evaluate on LIBERO across two base policies and 40 tasks. Section 4.4 analyzes the trigger; Appendix C provides evaluation details.

4.1 Real-world Experiments

Setup.

We conduct real-world experiments on the AgileX PiperX robotic embodiment, equipped with one front camera (RealSense D455) and two wrist cameras (RealSense D435), as shown in Figure 4. To evaluate methods in different situations, we design three tasks with varying arm configurations (one single-arm and two dual-arm) and key challenges. The tasks are pen insertion (pick up the pen and insert it into the yogurt bottle), apple placement (pick up the apple and place it into the container), and pipetting (transfer liquid from the right bottle to the left with a pipette), shown in Figure 4. The detailed task configurations are provided in Appendix D.

Implementation Details.

For each task, we collect 50 demonstration episodes to fine-tune the base policy. We then collect another 50 policy rollout episodes per task, label them using Robometer [25], and train one verifier for all tasks in the environment on a single H800 GPU. The same protocol is used in the simulation experiments. Each method is evaluated over 50 trials per task in the real-world, RoboTwin 2.0, and LIBERO experiments. The test-time deployment is based on one RTX 4090 GPU, with the policy model and the verifier running on the same device. During testing, we set the trigger threshold to a certain value, where verification is turned on during contact-rich phases. We use k=2 samples for Two-Axis Trigger and K=10 samples for the verifier.

Metrics.

We utilize three metrics: two validation losses and one closed-loop completion score. Specifically, rank loss measures the model’s ability to rank the action chunk samples within one task. Huber loss measures how well the model regresses delta progress. Completion score reflects the system’s closed-loop performance on the real-world tasks, where each stage is assigned a predefined score; details are provided in Appendix D.

Baselines.

We compare against the following methods: (1) Base policy (\pi_{0.5}) with single sampling; (2) VLM-based verifier following RoboMonkey [23], with the training objective adapted to delta progress estimation; (3) Pixel-level world model verifier following GPC-RANK [39].

Results.

The results are shown in Table 1. Our method improves the real-world completion score by 14.7 percentage points, outperforming all baselines. Our three-level optimization reduces the latency to 326 ms per triggered decision (trigger latency excluded), shown in Figure 5. RoboMonkey performs competitively on tasks requiring only coarse-scale localization (e.g., apple placement), but struggles with fine-grained manipulation, likely because its VLM lacks an explicit understanding of world dynamics. GPC-RANK achieves strong performance when estimating progress from real observations; however, its performance degrades on test-time rollout frames, indicating that the test-time generation quality becomes a bottleneck.

4.2 Simulation Results

To provide reproducible results, we evaluate the combination of the trigger and the verifier in simulation environments, including RoboTwin 2.0 [9] and LIBERO [27].

RoboTwin 2.0.

RoboTwin 2.0 is a benchmark for bimanual manipulation with both clean and randomized settings. For RoboTwin 2.0, we use Hy-Embodied-0.5-VLA [49] as the base policy. We evaluate our method on five fine-grained tasks that have relatively low baseline success rates. In the clean setting, we sweep a trigger threshold for all the tasks so that different fractions of decision steps trigger verification. Results show that (1) always-on verification improves the success rate on all five tasks; (2) the trigger could reduce computation while retaining much of the success-rate improvement, as shown in the first four tasks in Figure 6. In the Clean2Random setting, both the policy and verifier are trained exclusively on clean data and evaluated in randomized environments with always-on verification. Table 2 shows that our verifier can boost the base policy in randomized settings by 6.8 percentage points, showcasing generalization capability.

LIBERO.

We evaluate our method on LIBERO [27], using \pi_{0.5} and StarVLA-GR00T [43] as the base policies. As shown in Table 3, the results indicate that our method improves performance on LIBERO-10 suite, while maintaining strong performance on other suites. Each policy uses its own verifier weights, shared across all 40 tasks but not across the two policies.

4.3 Ablation Study

In this section, we discuss the design of the verifier, and specifically answer the following question: Do latent world modeling and pretrained latent dynamics improve progress estimation? We conduct two sets of ablation studies. First, we assess the role of latent world modeling by removing the visual prediction objective. Second, we investigate whether pretraining the predictor on the general-purpose DROID dataset [21] leads to better performance.

4.3.1 Effect of World Modeling.

Does the test-time improvement stem from latent world modeling, or merely from a strong visual encoder? To answer the question, we implement a variant that predicts only delta progress, without jointly predicting future visual latents. Therefore, the variant degenerates into an autoregressive transformer without world modeling. We train the variant on the same three real-world tasks. As shown in Table 4, the completion score drops from 65.5% to 55.2%. These results suggest that without the dense world modeling objective, the model struggles to learn informative dynamics, leading to substantially weaker performance.

4.3.2 Effect of Predictor Pretraining

Our verifier builds on a frozen pretrained V-JEPA 2 encoder, which provides a rich visual prior learned from web-scale video data. In addition, the action-conditioned predictor is pretrained on 23k trajectories from the DROID dataset, offering a strong dynamics prior for robotic manipulation. To assess whether this predictor pretraining is beneficial for knowledge transfer, we train a variant without pretraining where the predictor is initialized randomly. In Table 4, the variant shows lower completion scores on real-world tasks, especially on the tasks with stronger generalization requirements, e.g. apple placement. In contrast, on the pipetting task, where bottle locations remain almost fixed and generalization is less critical, the performance degradation is relatively minor.

4.4 Trigger Analysis

We compare the Two-Axis Trigger with a trained DINOv2–MLP baseline, action chunk entropy (ACE) [26], and its temporal and cross-sample components. Our trigger requires no training. Baseline configurations and evaluation details are provided in Appendix C.

Metrics.

Status AUC measures alignment between trigger scores and contact-based reference labels from privileged simulator states. Variance Correlation measures Spearman’s \rho between trigger scores and reference action variance estimated from K policy samples per state. These diagnostics assess contact relevance and candidate diversity; full definitions appear in Appendix C.1.

Results.

In Table 5, the combined trigger achieves a Status AUC of 0.727 and a Variance Correlation of 0.887, exceeding both individual components. The temporal component has higher Status AUC (0.704 versus 0.694), while the cross-sample component has higher Variance Correlation (0.877 versus 0.789), suggesting complementary signals. Our trigger uses two samples with 14 ms of additional latency per decision.

Variance Correlation thus evaluates whether a k=2 trigger tracks the K-sample reference. Figure 6 separately evaluates the closed-loop success–computation trade-off.

5 Limitations and Future Work

A key limitation of repeated sampling and selection is the difficulty of steering a pretrained VLA model. Although the verifier can rank sampled action candidates, its effectiveness depends on the diversity and quality of the proposals generated by the underlying policy. The diversity of repeated sampling with different random seeds is still relatively limited. Another limitation is the use of a frozen visual encoder. While freezing the encoder reduces training cost and preserves pretrained representations, these representations are not explicitly optimized for manipulation progress estimation. They may overlook subtle changes in object configurations, contact conditions, or task completion that are essential for distinguishing promising actions from ineffective ones. Future work can investigate learning an encoder–predictor pair for progress estimation within a JEPA framework by considering progress estimation as an optimization goal.

6 Conclusion

We have introduced an adaptive test-time verification framework for exploiting the stochasticity of flow-based VLA policies. Our training-free two-axis trigger identifies critical states from within-chunk motion variation and cross-sample disagreement, invoking additional sampling only when it is likely to be useful. A JEPA-based latent world model then ranks candidate action chunks by jointly predicting action-conditioned future latents and delta task progress, avoiding pixel reconstruction and goal-image dependence. Experiments in both real-world and simulation demonstrate consistent gains across tasks, environments, and base policies. On three real-world tasks, our method increases the average completion score from 50.8% to 65.5% while adding 326 ms for sampling and verification per triggered decision, excluding the 14 ms trigger overhead. Ablation studies further confirm the benefits of latent dynamics modeling and pretraining. Taken together, these results establish adaptive latent verification as an effective and practical approach to improving frozen generative VLAs at deployment.

References

1. [1] C. Agia, R. Sinha, J. Yang, Z. Cao, R. Antonova, M. Pavone, and J. Bohg (2024) Unpacking failure modes of generative policies: runtime monitoring of consistency and progress. In CoRL, Note: arXiv:2410.04640
2. [2] M. Assran, A. Bardes, D. Fan, Q. Garrido, R. Howes, M. Komeili, M. Muckley, A. Rizvi, C. Roberts, K. Sinha, A. Zholus, S. Arnaud, A. Gejji, A. Martin, F. R. Hogan, D. Dugas, P. Bojanowski, V. Khalidov, P. Labatut, F. Massa, M. Szafraniec, K. Krishnakumar, Y. Li, X. Ma, S. Chandar, F. Meier, Y. LeCun, M. Rabbat, and N. Ballas (2025) V-jepa 2: self-supervised video models enable understanding, prediction and planning. External Links: 2506.09985, Link
3. [3] Z. Bai, C. Gao, and M. Z. Shou (2025) EVOLVE-vla: test-time training from environment feedback for vision-language-action models. External Links: 2512.14666, Link
4. [4] K. Black, N. Brown, D. Driess, A. Esmail, M. Equi, C. Finn, N. Fusai, L. Groom, K. Hausman, B. Ichter, et al. (2025) \pi_{0}: A vision-language-action flow model for general robot control. In RSS,
5. [5] K. Black, M. Y. Galliker, and S. Levine (2025) Real-time execution of action chunking flow policies. In NeurIPS, Note: arXiv:2506.07339
6. [6] A. Brohan, N. Brown, J. Carbajal, Y. Chebotar, J. Dabis, C. Finn, K. Gopalakrishnan, K. Hausman, A. Herzog, J. Hsu, J. Ibarz, B. Ichter, A. Irpan, T. Jackson, S. Jesmonth, N. Joshi, R. Julian, D. Kalashnikov, Y. Kuang, I. Leal, K. Lee, S. Levine, Y. Lu, U. Malla, D. Manjunath, I. Mordatch, O. Nachum, C. Parada, J. Peralta, E. Perez, K. Pertsch, J. Quiambao, K. Rao, M. S. Ryoo, G. Salazar, P. R. Sanketi, K. Sayed, J. Singh, S. Sontakke, A. Stone, C. Tan, H. Tran, V. Vanhoucke, S. Vega, Q. H. Vuong, F. Xia, T. Xiao, P. Xu, S. Xu, T. Yu, and B. Zitkovich (2023) RT-1: Robotics Transformer for Real-World Control at Scale. In Proceedings of Robotics: Science and Systems,
7. [7] J. Chen, K. Wang, K. Chen, S. Chen, F. Gao, W. Tang, Z. Li, W. Liu, Z. Yao, B. Li, Y. Xu, and C. Yu (2026) LaWAM: latent world action models for efficient dynamics-aware robot policies. External Links: 2606.15768, Link
8. [8] S. Chen, J. Yuan, J. Wang, and T. Chen (2026) Trust your instincts: confidence-driven test-time rl for vision-language-action models. External Links: 2606.29892, Link
9. [9] T. Chen, Z. Chen, B. Chen, Z. Cai, Y. Liu, Z. Li, Q. Liang, X. Lin, Y. Ge, Z. Gu, W. Deng, Y. Guo, T. Nian, X. Xie, Q. Chen, K. Su, T. Xu, G. Liu, M. Hu, H. Gao, K. Wang, Z. Liang, Y. Qin, X. Yang, P. Luo, and Y. Mu (2025) RoboTwin 2.0: a scalable data generator and benchmark with strong domain randomization for robust bimanual robotic manipulation. External Links: 2506.18088, Link
10. [10] C. Chi, S. Feng, Y. Du, Z. Xu, E. Cousineau, B. Burchfiel, and S. Song (2023) Diffusion Policy: visuomotor policy learning via action diffusion. In RSS,
11. [11] X. Fan, Y. Lu, S. Gao, X. Wu, R. Han, M. Li, and H. Zhao (2026) DreamAvoid: critical-phase test-time dreaming to avoid failures in vla policies. External Links: 2605.11750, Link
12. [12] S. Fei, S. Wang, J. Shi, Z. Dai, J. Cai, P. Qian, L. Ji, X. He, S. Zhang, Z. Fei, J. Fu, J. Gong, and X. Qiu (2025) LIBERO-plus: in-depth robustness analysis of vision-language-action models. External Links: 2510.13626, Link
13. [13] X. Feng, Y. Cheng, C. Shi, B. Han, Y. Yan, Y. Hong, Z. Tian, and L. Jiang (2026) Denoising tells when to replan: denoising-variance adaptive chunking for flow-based robot policies. arXiv preprint arXiv:2606.03847.
14. [14] Z. Feng, Y. Feng, L. Xiao, S. Su, K. Zheng, C. Xu, M. Shi, S. Feng, and X. Yan (2026) Copper-policy: focus on the representation for robust robot manipulation. External Links: 2609.32779, Link
15. [15] Q. Gu, Y. Ju, S. Sun, I. Gilitschenski, H. Nishimura, M. Itkina, and F. Shkurti (2025) Safe: multitask failure detection for vision-language-action models. Advances in Neural Information Processing Systems 38, pp. 40041–40076.
16. [16] X. Hu, B. Liu, X. Liu, and Q. Liu (2024) Adaflow: imitation learning with variance-adaptive flow-based policies. NeurIPS.
17. [17] X. Huang, Z. Li, G. He, M. Zhou, and E. Shechtman (2025) Self Forcing: bridging the train-test gap in autoregressive video diffusion. In NeurIPS,
18. [18] P. J. Huber (1964) Robust estimation of a location parameter. The Annals of Mathematical Statistics 35 (1), pp. 73–101. External Links: Document
19. [19] P. Intelligence, K. Black, N. Brown, J. Darpinian, K. Dhabalia, D. Driess, A. Esmail, M. Equi, C. Finn, N. Fusai, M. Y. Galliker, D. Ghosh, L. Groom, K. Hausman, B. Ichter, S. Jakubczak, T. Jones, L. Ke, D. LeBlanc, S. Levine, A. Li-Bell, M. Mothukuri, S. Nair, K. Pertsch, A. Z. Ren, L. X. Shi, L. Smith, J. T. Springenberg, K. Stachowicz, J. Tanner, Q. Vuong, H. Walke, A. Walling, H. Wang, L. Yu, and U. Zhilinsky (2025) \pi_{0.5}: A vision-language-action model with open-world generalization. External Links: 2504.16054, Link
20. [20] S. Jang, D. Kim, C. Kim, Y. Kim, and J. Shin (2026) Verifier-free test-time sampling for vision-language-action models. In ICLR, Note: arXiv:2510.05681
21. [21] A. Khazatsky, K. Pertsch, S. Nair, A. Balakrishna, S. Dasari, S. Karamcheti, S. Nasiriany, M. K. Srirama, L. Y. Chen, K. Ellis, et al. (2024) Droid: a large-scale in-the-wild robot manipulation dataset. arXiv preprint arXiv:2403.12945.
22. [22] M. J. Kim, K. Pertsch, S. Karamcheti, T. Xiao, A. Balakrishna, S. Nair, R. Rafailov, E. Foster, G. Lam, P. Sanketi, et al. (2024) OpenVLA: an open-source vision-language-action model. In CoRL,
23. [23] J. Kwok, C. Agia, R. Sinha, M. Foutter, S. Li, I. Stoica, A. Mirhoseini, and M. Pavone (2025) RoboMonkey: scaling test-time sampling and verification for vision-language-action models. In CoRL,
24. [24] J. Kwok, X. Zhang, M. Xu, Y. Liu, A. Mirhoseini, C. Finn, and M. Pavone (2026) Scaling verification can be more effective than scaling policy learning for vision-language-action alignment. arXiv preprint arXiv:2602.12281.
25. [25] A. Liang, Y. Korkmaz, J. Zhang, M. Hwang, A. Anwar, S. Kaushik, A. Shah, A. S. Huang, L. Zettlemoyer, D. Fox, Y. Xiang, A. Li, A. Bobu, A. Gupta, S. Tu, E. Biyik, and J. Zhang (2026) Robometer: scaling general-purpose robotic reward models via trajectory comparisons. External Links: 2603.02115, Link
26. [26] Y. Liang, X. Wang, K. Wang, S. Wang, X. Peng, H. Chen, D. K. H. Chua, and P. Vadakkepat (2026) Adaptive action chunking at inference-time for vision-language-action models. External Links: 2604.04161, Link
27. [27] B. Liu, Y. Zhu, C. Gao, Y. Feng, Q. Liu, Y. Zhu, and P. Stone (2023) LIBERO: benchmarking knowledge transfer for lifelong robot learning. In NeurIPS,
28. [28] C. Liu, Y. Liu, T. Wang, Q. Zhuang, J. C. Liang, W. Yang, R. Xu, Q. Wang, D. Liu, and C. Han (2026) On-the-fly vla adaptation via test-time reinforcement learning. External Links: 2601.06748, Link
29. [29] Y. Liu, J. Ibn Hamid, A. Xie, Y. Lee, M. Du, and C. Finn (2025) Bidirectional decoding: improving action chunking via guided test-time sampling. In ICLR, Note: arXiv:2408.17355
30. [30] Z. Liu, J. Hou, Y. Lu, Z. Yang, X. Fan, J. Luo, J. Li, R. Han, Z. Hou, and H. Zhao (2026) StreamPI: streaming multimodal temporal modeling for vision-language-action models. arXiv preprint arXiv:2608.26067.
31. [31] Y. Lu, Z. Liu, X. Fan, Z. Yang, J. Hou, J. Li, K. Ding, and H. Zhao (2026) Faster: rethinking real-time flow vlas. arXiv preprint arXiv:2603.19199.
32. [32] H. Luo, W. Zhang, Y. Feng, S. Zheng, H. Xu, C. Xu, Z. Xi, Y. Fu, and Z. Lu (2026) Being-h0.7: a latent world-action model from egocentric videos. External Links: 2605.00078, Link
33. [33] L. Maes, Q. L. Lidec, D. Scieur, Y. LeCun, and R. Balestriero (2026) LeWorldModel: stable end-to-end joint-embedding predictive architecture from pixels. External Links: 2603.19312, Link
34. [34] L. Mur-Labadia, M. Muckley, A. Bar, M. Assran, K. Sinha, M. Rabbat, Y. LeCun, N. Ballas, and A. Bardes (2026) V-jepa 2.1: unlocking dense features in video self-supervised learning. External Links: 2603.14482, Link
35. [35] M. Nakamoto, O. Mees, A. Kumar, and S. Levine (2024) Steering your generalists: improving robotic foundation models via value guidance. In 8th Annual Conference on Robot Learning, External Links: Link
36. [36] NVIDIA, J. Bjorck, F. Castañeda, N. Cherniadev, X. Da, R. Ding, L. ”. Fan, Y. Fang, D. Fox, F. Hu, S. Huang, J. Jang, Z. Jiang, J. Kautz, K. Kundalia, L. Lao, Z. Li, Z. Lin, K. Lin, G. Liu, E. Llontop, L. Magne, A. Mandlekar, A. Narayan, S. Nasiriany, S. Reed, Y. L. Tan, G. Wang, Z. Wang, J. Wang, Q. Wang, J. Xiang, Y. Xie, Y. Xu, Z. Xu, S. Ye, Z. Yu, A. Zhang, H. Zhang, Y. Zhao, R. Zheng, and Y. Zhu (2025) GR00T n1: an open foundation model for generalist humanoid robots. External Links: 2503.14734, Link
37. [37] T. Pang, H. J. T. Suh, L. Yang, and R. Tedrake (2023) Global planning for contact-rich manipulation via local smoothing of quasi-dynamic contact models. External Links: 2206.10787, Link
38. [38] K. Pertsch, K. Stachowicz, B. Ichter, D. Driess, S. Nair, Q. Vuong, O. Mees, C. Finn, and S. Levine (2025) FAST: efficient action tokenization for vision-language-action models. External Links: 2501.09747, Link
39. [39] H. Qi, H. Yin, A. Zhu, Y. Du, and H. Yang (2026) Inference-time enhancement of generative robot policies via predictive world modeling. IEEE Robotics and Automation Letters.
40. [40] S. Ross, G. J. Gordon, and J. A. Bagnell (2011) A reduction of imitation learning and structured prediction to no-regret online learning. External Links: 1011.0686, Link
41. [41] F. Seligmann, E. Gospodinov, E. U. Dincer, and G. Neumann (2026) VLA-fail: efficient task failure detection for finetuned vision-language-action models. arXiv preprint arXiv:2606.21386.
42. [42] U. Sobal, W. Zhang, K. Cho, R. Balestriero, T. G. Rudner, and Y. LeCun (2025) Learning from reward-free offline data: a case for planning with latent dynamics models. In Advances in Neural Information Processing Systems,
43. [43] StarVLA Community (2026) StarVLA: a lego-like codebase for vision-language-action model developing. External Links: 2604.05014, Link
44. [44] J. Sun, W. Zhang, Z. Qi, S. Ren, Z. Liu, H. Zhu, G. Sun, X. Jin, and Z. Chen (2026) VLA-jepa: enhancing vision-language-action model with latent world model. External Links: 2602.10098, Link
45. [45] Y. Wu, R. Tian, G. Swamy, and A. Bajcsy (2025) From foresight to forethought: VLM-in-the-loop policy steering via latent alignment. In Robotics: Science and Systems (RSS), Note: arXiv:2502.01828
46. [46] C. Xu, E. Yu, J. Xuan, and J. Lu (2026) VGAS: value-guided action-chunk selection for few-shot vision-language-action adaptation. External Links: 2602.07399, Link
47. [47] L. Yang, Z. Jiang, C. Sheng, and Z. Tang (2026) Guided action flow: q-guided inference for flow-matching vision-language-action policies. External Links: 2607.02092, Link
48. [48] H. Zhang, Y. Lu, B. Wang, X. Kang, Y. Kuo, Z. Cheng, M. Wang, and O. C. Jenkins (2026) Foresight: failure detection for long-horizon robotic manipulation with action-conditioned world model latents. arXiv preprint arXiv:2606.23085.
49. [49] H. Zhang, L. Xiang, H. Lin, Z. Huang, M. Wang, D. Zhong, Y. Dong, Y. Wu, Y. Rao, D. Zhang, W. He, L. Chen, K. Huang, J. Chen, S. Su, X. Yu, Z. Wang, C. Zhu, X. Teng, Y. Guo, Y. Zhang, Y. Liu, R. Wang, Z. Lu, H. Hu, and Z. Zhang (2026) Hy-embodied-0.5-vla: from vision-language-action models to a real-world robot learning stack. External Links: 2606.14409, Link
50. [50] W. Zhang, B. Terver, M. Rabbat, Y. LeCun, and R. Balestriero (2026) H-jepa: end-to-end learning of hierarchical world models for visual planning. External Links: 2610.06805, Link
51. [51] W. Zhang, B. Terver, A. Zholus, S. Chitnis, H. Sutaria, M. Assran, R. Balestriero, A. Bar, A. Bardes, Y. LeCun, and N. Ballas (2026) Hierarchical planning with latent world models. External Links: 2604.03208, Link
52. [52] C. Zhao, Z. Wang, H. Li, S. Bao, G. Li, Y. Feng, Y. Li, J. Tang, and J. Zhang (2026) Action draft and verify: a self-verifying framework for vision-language-action model. External Links: 2603.18091, Link
53. [53] G. Zhou, H. Pan, Y. Lecun, and L. Pinto (2025) DINO-WM: world models on pre-trained visual features enable zero-shot planning. In ICML,
54. [54] B. Zitkovich, T. Yu, S. Xu, P. Xu, T. Xiao, F. Xia, J. Wu, P. Wohlhart, S. Welker, A. Wahid, et al. (2023) Rt-2: vision-language-action models transfer web knowledge to robotic control. In CoRL, pp. 2165–2183.

Appendix

Appendix A Extended Related Work

In this section, we provide an extended review of prior work.

A.1 Test-time Verification

Existing methods differ in how the verifier is constructed. Model-based verifiers train a separate scoring model: RoboMonkey [23] fine-tunes a 7B VLM on synthetic action preferences, CoVer [24] argues that scaling such verifiers beats scaling policy learning, and V-GPS [35] re-ranks samples with an offline-RL value function. Model-free methods instead read the signal off the policy itself, via masked-condition divergence [20] or proximity to the discrete action tokens [52]; both measure agreement rather than progress, and neither reasons about the physical consequences of a candidate. World-model verifiers close this gap by imagining outcomes, but do so in two stages: GPC-RANK [39] and DreamAvoid [11] synthesize future pixels before scoring them, while FOREWARN [45] rolls out latents and then aligns a per-task finetuned VLM to narrate them. VeriVLA keeps the world model but removes the second stage, reading delta progress directly from predicted latents. Combined with a two-axis action-based trigger, verification is invoked adaptively.

A.2 Other Test-time Enhancement

In addition to test-time verification, we provide an overview of other existing test-time enhancement methods, including test-time RL, adaptive action chunking, and online monitoring.

Test-time training and RL. Test-time training methods, such as EVOLVE-VLA [3] and TT-VLA [28], perform online policy optimization during deployment using dense reward signals. Rather than relying on external reward estimation, T2VLA [8] derives intrinsic rewards from the policy’s own confidence to enable self-supervised adaptation. These methods update policy parameters and therefore require reward access, gradient computation, and tolerance for transient regression during adaptation.

Adaptive action chunking. A parallel line of work asks not which action to take but how to emit it. BID [29] resamples action chunks under backward coherence and forward contrast to trade off consistency against reactivity. RTC [5] targets the latency gap by generating the next chunk while the current one executes, freezing the actions guaranteed to run and inpainting the remainder. AAC [26] adaptively sets the chunk size from action entropy, and DVAC [13] triggers replanning from denoising variance. The underlying intuition traces back to AdaFlow [16], which links the conditional variance of the flow-matching loss to ODE discretization error and reduces to a one-step generator when the action distribution is unimodal. Our trigger shares this variance-based intuition, but these methods reshape the execution or decoding schedule of a single trajectory and never assess whether the emitted actions make task progress; our trigger instead gates a verifier that can reject and replace a chunk rather than merely smoothing or resizing it.

Online monitoring and failure detection. Runtime monitors aim to predict failure before it becomes irrecoverable. Sentinel [1] splits failures into erratic modes, detected by statistical temporal consistency of action-chunk distributions (STAC), and task-progression modes, detected via VLM video QA; the two detectors together catch 18% more failures than either alone. SAFE [15] shows that VLA internal features carry task-generic success/failure information and trains a lightweight scalar failure predictor on them, using conformal prediction for a calibrated time-varying threshold; VLA-FAIL [41] pairs a last-layer Mahalanobis distance with an action-chunk consistency term to remove the need for failure data. Closest to our setting, Foresight [48] extracts action-conditioned latents from V-JEPA 2-AC and predicts a per-timestep failure score, showing that world-model features generalize across policies better than policy-internal ones.

Appendix B Training Details

B.1 Hyperparameters

We list the training hyperparameters in Table 7.

Appendix C Trigger Experiments

C.1 Evaluation Metrics

Our trigger aims to detect critical task states or states where the policy is uncertain. Since there is no ground truth for when to trigger, we propose two metrics in simulation environments to evaluate how well the trigger value aligns with our setting: (1) Status AUC is the AUC-ROC between the trigger value and a rule-based critical label. The label is a binary indicator obtained by thresholding temporal proximity to critical moments, which are read from the simulator and defined as the moments when task-related objects switch between contact and non-contact, with the gripper or another task-related object. This measures how well the trigger identifies contact-relevant stages that we hypothesize to be most challenging. It serves as a fair metric, since the criterion is computed solely from simulator states rather than the visual states or policy actions that are used by triggers, and it avoids manual annotation. The critical-label construction is detailed in Section C.2. (2) Variance Correlation measures Spearman’s \rho between trigger scores and a K-sample reference variance. At each evaluated state, we draw K action chunk samples from the policy and compute their variance as an empirical ground-truth reference for policy variability. This K-sample Monte Carlo reference differs from the k=2 sample variance used by the trigger at deployment. The metric evaluates whether a trigger computed with few samples tracks variability estimated from the larger sample set; it does not correlate the trigger with its own two-sample variance.

C.2 Critical-label Construction

To evaluate whether a trigger signal at a state V_{\text{trigger}}(s_{t}) identifies moments that genuinely require more compute, we construct a reference label \text{crit}(t)\in[0,1] that is independent of the action or vision. We find the critical moments from privileged simulator state (object/gripper pose, joint angles, contact) using a rule: we mark frames where gripper-object or object-object contact state flips (grasp / release) for any task-relevant object. For each support moment, we assign a Gaussian kernel function. The critical index for each frame is then computed as the sum of all overlapping kernel contributions, clipped to a maximum of 1.

After labeling an episode with the continuous critical index, we compute the trigger value for each chunk a_{t:t+H} and take the maximum critical index within that window. Thresholding the latter at 0.5 yields the binary label, and the trigger value serves as the score; we then compute the ROC curve and the Status AUC. We visualize two tasks from LIBERO and RoboTwin for reference:

C.3 Baselines

We compare the proposed Two-Axis Trigger against representative prior methods as well as its individual components: (1) A lightweight MLP trained on frozen DINOv2 features, as a representative method for a vision-based baseline [11]. We train the model with the signals read from the simulator, and evaluate it together with the other methods on the perturbation set from LIBERO-Plus [12]. (2) Action chunk entropy (ACE) [26]. Although originally designed for adaptive action chunking rather than the trigger, it provides an action-based baseline. (3) The temporal trigger T_{\text{temp}} and cross-sample variance trigger T_{\text{cross}}, components of our Two-Axis Trigger.

The quantitative comparison is reported in Section 4.4 and Table 5.

Appendix D Real-world Setting

D.1 Tasks

We conduct experiments on three real-world tasks, pen insertion, pipetting, and apple placement. Table 8 defines the completion score of each task.

D.2 Computational Cost

We report the inference computational cost in Table 9, including latency and GPU usage.