DreamAvoid: Test-Time Safety for VLA Policies

• The paper proposes a test-time failure-avoidance approach using selective short-horizon dreaming to evaluate multiple candidate action chunks for critical manipulation tasks.
• It introduces three core modules—Dream Trigger, Action Proposer, and Dream Evaluator—to detect critical phases, generate diverse action candidates via SDE sampling, and predict future progress.
• Empirical evaluations show that the full DreamAvoid system (DA-ABL) significantly improves success rates (up to 72.5%) over baseline methods in fine-grained manipulation tasks.

Searching arXiv for the specified paper and closely related context. DreamAvoid is a test-time failure-avoidance framework for Vision-Language-Action (VLA) policies that targets fine-grained manipulation settings in which minor action errors during critical phases can escalate into irrecoverable failures. It is formulated around selective short-horizon “dreaming” at inference time: the system detects whether execution has entered a critical phase, proposes multiple candidate action chunks, predicts short future trajectories under those actions with an action-conditioned world model, and chooses the candidate with the highest predicted short-horizon progress value. The framework also introduces an autonomous boundary learning paradigm intended to sharpen the distinction between success, failure, and near-boundary cases during training (Fan et al., 12 May 2026).

1. Formal problem formulation

DreamAvoid is posed over a robot state space $S$, a language-instruction space $L$, and an action space $A$. A pre-trained VLA policy is written as

$\pi_\theta : S \times L \longrightarrow A^H,$

mapping the current state and instruction $(o_t,l)$ to a short action chunk

$$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$

In this formulation, $S$ includes visual observations $o_t$ and proprioceptive state $s_t$, while $A$ may include joint-angle vectors and gripper commands (Fan et al., 12 May 2026).

The central problem is that direct execution of $L$0 is efficient but can induce irrecoverable failure when local action errors occur during a “critical phase.” DreamAvoid therefore introduces an adaptive inference procedure with four objectives: detect approach to a critical phase, sample multiple plausible action chunks, “dream” short-horizon futures for each candidate, and select the safest action so as to minimize failure probability (Fan et al., 12 May 2026).

A binary indicator $L$1 governs whether test-time dreaming is used. If $L$2, the base policy is executed directly; if $L$3, a compute-intensive dreaming routine is invoked. The test-time decision rule is expressed as choosing

$L$4

where $L$5 denotes the predicted short-horizon “progress value” of candidate $L$6. This construction yields an explicit latency–robustness trade-off by restricting expensive inference to moments judged critical (Fan et al., 12 May 2026).

2. Core architecture: Dream Trigger, Action Proposer, and Dream Evaluator

DreamAvoid is organized around three modules: a Dream Trigger, an Action Proposer, and a Dream Evaluator. Their interaction defines the framework’s selective intervention mechanism (Fan et al., 12 May 2026).

The Dream Trigger is a lightweight classifier $L$7 operating on the most recent $L$8 frames $L$9 together with proprioceptive state $A$0. It outputs

$A$1

interpreted as the probability that execution has entered a critical phase. Training uses teleoperation videos with manually annotated critical times $A$2, from which a soft target is defined: $A$3 This target transitions smoothly in a $A$4-frame window around $A$5. The trigger is trained with class-weighted binary cross-entropy,

$A$6

where $A$7 balances positive and negative frames. At inference, the framework sets

$A$8

so dreaming is activated exactly when the estimated critical-phase probability crosses threshold $A$9 (Fan et al., 12 May 2026).

The Action Proposer is used only when $\pi_\theta : S \times L \longrightarrow A^H,$0. Rather than applying the deterministic flow-matching ODE, DreamAvoid converts the base policy into a stochastic differential equation sampler. The deterministic flow is written as

$\pi_\theta : S \times L \longrightarrow A^H,$1

for $\pi_\theta : S \times L \longrightarrow A^H,$2. Noise injection yields

$\pi_\theta : S \times L \longrightarrow A^H,$3

where $\pi_\theta : S \times L \longrightarrow A^H,$4 is a Wiener process. Sampling $\pi_\theta : S \times L \longrightarrow A^H,$5 independent SDE traces generates the candidate set $\pi_\theta : S \times L \longrightarrow A^H,$6. The stated rationale is that each candidate remains grounded in the base policy’s learned action manifold while exploring locally diverse hypotheses, which is especially important when small action perturbations can produce large downstream effects (Fan et al., 12 May 2026).

The Dream Evaluator scores each candidate using a pre-trained world model $\pi_\theta : S \times L \longrightarrow A^H,$7 and a value network $\pi_\theta : S \times L \longrightarrow A^H,$8. For candidate $\pi_\theta : S \times L \longrightarrow A^H,$9, the world model predicts a short rollout of future images: $(o_t,l)$0 The value network then estimates the expected progress delta: $(o_t,l)$1 At test time, the chosen action is determined by

$(o_t,l)$2

This separation between candidate generation and candidate evaluation is fundamental to DreamAvoid’s short-horizon decision procedure (Fan et al., 12 May 2026).

3. Value learning and autonomous boundary learning

The Dream Evaluator is trained using explicit progress annotations and an explicit treatment of irreversible failure. Ground-truth values are computed via a separate reward model, Robometer, as

$(o_t,l)$3

where $(o_t,l)$4 denotes task progress at time $(o_t,l)$5. If a candidate rollout leads to irreversible failure, such as a dropped object, DreamAvoid clamps the target to

$(o_t,l)$6

thereby explicitly encoding catastrophic outcomes in the training signal (Fan et al., 12 May 2026).

Training of $(o_t,l)$7 uses mixed real and dreamed data, with a loss combining Huber regression and continuous margin ranking: $(o_t,l)$8 Here $(o_t,l)$9 is a prioritized batch and $$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$0 is the set of valid ranking pairs. The formulation indicates that absolute progress estimation and relative ordering among candidate futures are both treated as important training objectives (Fan et al., 12 May 2026).

A distinctive part of the framework is autonomous boundary learning. DreamAvoid is first trained using only successful teleoperation data $$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$1. Deployment of this initial system yields an online dataset $$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$2 containing successes, outright failures, and boundary episodes in which the system narrowly succeeds or fails. Each sample is annotated with value $$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$3 as above, and the world model $$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$4 together with the value network $$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$5 is then fine-tuned on

$$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$6

During value-model training, mini-batches are sampled so that 20% are terminal successes, 40% are boundary/failure cases, and 40% are routine steady-progress frames. This sampling policy is explicitly intended to concentrate discriminative capacity around the subtle threshold between success and failure (Fan et al., 12 May 2026).

This suggests that DreamAvoid treats failure awareness not as a static property learned solely from curated demonstrations, but as an iteratively refined representation shaped by data near the decision boundary. A plausible implication is that the framework is especially designed for domains where demonstration-only training leaves the policy underexposed to near-miss dynamics.

4. Short-horizon dreaming procedure and computational profile

At each time step $$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$7, DreamAvoid executes a fixed sequence. It first computes the critical-phase probability $$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$8. If $$u_t=[a_t,a_{t+1},\ldots,a_{t+H-1}] \sim \pi_\theta(\cdot \mid o_t,l).$$9, it executes $S$0 directly. Otherwise, it generates candidate action chunks through SDE sampling, dreams short-horizon image rollouts $S$1, evaluates them with $S$2, and executes the maximizing candidate $S$3. This process is summarized as Algorithm 1 in the paper (Fan et al., 12 May 2026).

The world model is described as an autoregressive diffusion distilled via Self-Forcing, using a causal attention transformer and only a few forward-sampling steps. A 13-frame rollout takes approximately 2 s on an RTX 4090, and value scoring takes approximately 40 ms. Because dreaming is triggered only at critical phases, which occur approximately 1–3 times per trajectory, the additional latency is reported as manageable (Fan et al., 12 May 2026).

These design choices position DreamAvoid as a selective alternative to always-on planning or verification. The paper explicitly contrasts the method with “constant compute burden” approaches such as always-on MPC or verification. The significance of this comparison lies in the framework’s gating mechanism: compute is expended only when the trigger estimates elevated failure sensitivity (Fan et al., 12 May 2026).

5. Empirical evaluation

DreamAvoid is evaluated on four real-world fine-grained manipulation tasks using the AgileX PiperX arm, with 40 trials per task: Cup Sleeving, Charger Plugging, Cap Opening, and Screw Insertion. The compared methods are the base policy $S$4 without dreaming, GPC-RANK as an always-on sampling plus world-model ranking baseline, DA-Vanilla as DreamAvoid without boundary refinement, and DA-ABL as the full system with Autonomous Boundary Learning (Fan et al., 12 May 2026).

The reported average success rates over the four real-world tasks are shown below.

Method	Average success rate
Base $S$5	48.8%
GPC-RANK	54.4%
DA-Vanilla	66.9%
DA-ABL	72.5%

On these tasks, DA-ABL improves by $S$6 over the base policy and $S$7 over GPC-RANK. Ablation results further indicate that SDE sampling is much more effective than repeated deterministic ODE seeds, with 72.5% versus 57.5%, and that a blind random pick among SDE candidates performs poorly at 45.0% (Fan et al., 12 May 2026).

The framework is also evaluated in simulation. On four LIBERO tasks with 200 trials each, the base $S$8 achieves 96.5%, GPC-RANK 96.6%, and DA-ABL 97.8%. On SimplerEnv Bridge, comprising 7 tasks, and Fractal, comprising 5 tasks, using GR00T-N1.6 as the base policy, DA-ABL achieves 63.6% versus 59.9% for the base and 61.1% for GPC-RANK on Bridge, and 80.7% versus 76.4% and 78.2% on Fractal (Fan et al., 12 May 2026).

Taken together, these results indicate that DreamAvoid is most consequential in settings characterized by fine-grained contact sensitivity and elevated risk of irreversible local errors. This suggests that the marginal utility of selective dreaming depends on the extent to which base-policy execution is brittle around narrow success/failure boundaries.

6. Strengths, limitations, and extensions

The paper identifies several strengths. DreamAvoid is described as plug-and-play compatible with flow-based VLAs, incorporates explicit boundary-aware world modeling, and produces interpretable pixel-space rollouts. The framework also demonstrates that selective short-horizon test-time dreaming can reduce manipulation failures without incurring the compute cost associated with always-on MPC or verification (Fan et al., 12 May 2026).

The limitations are also explicit. The 1–2 s latency associated with video-level rollouts is characterized as acceptable for slow, contact-sensitive tasks but challenging in high-speed settings. The method also relies on large pre-trained world models. These constraints imply that DreamAvoid’s deployment regime is currently better aligned with manipulation domains in which temporal slack exists during critical phases (Fan et al., 12 May 2026).

The paper outlines several future directions: latent-space rollouts, hardware acceleration, tighter integration with other action generators such as diffusion policies, and reuse of dreamed failures as negative training data through advantage-weighted regression or RL-HF to improve the base policy itself (Fan et al., 12 May 2026). A plausible implication is that DreamAvoid can be interpreted not only as a test-time correction layer but also as a mechanism for generating structured failure supervision for subsequent policy refinement.