Uncategorized2026~101 minarXiv:2602.15922

World Action Models are Zero-shot Policies

score 2Seonghyeon Ye, Yunhao Ge, Kaiyuan Zheng +33NVIDIA Deep Imagination Research↑ 12★ 1,039Feb 17, 2026cs.ROhttps://github.com/dreamzero0/dreamzero

🎯 Pitch

A 14B video diffusion model, when jointly trained to predict actions and future frames, acts as a zero-shot robot policy that more than doubles generalization over leading vision-language-action models—without any task-specific demonstrations. Remarkably, simple video-only footage from a human or another robot, requiring just 10–20 minutes of recording, boosts unseen-task performance by over 42%.

1. Executive Summary

This paper introduces DreamZero, a 14B World Action Model (WAM) built on a pretrained video diffusion backbone that jointly predicts future video frames and actions, enabling effective policy learning from diverse, non-repetitive robot data without relying on repeated demonstrations. Evaluated on real-robot benchmarks using AgiBot G1 and Franka embodiments against state-of-the-art Vision-Language-Action models (GR00T N1.6 and π₀.₅), DreamZero achieves over 2× improvement in zero-shot generalization to unseen tasks and environments through its joint video–action formulation — which decomposes into autoregressive video prediction coupled with implicit inverse-dynamics learning — and further demonstrates cross-embodiment transfer where video-only demonstrations from humans (12 minutes) or other robots (20 minutes) yield a relative improvement of over 42% on unseen task performance. Through model and system optimizations including decoupled video–action denoising schedules (DreamZero-Flash), the 14B autoregressive diffusion transformer achieves real-time closed-loop control at 7Hz (a 38× inference speedup), establishing that video generation quality directly translates to downstream action execution but only when the training data distribution is sufficiently diverse — repetitive data with the same total hours yields substantially weaker generalization.

2. Context and Motivation

The Core Problem: Why VLAs Cannot Generalize to New Physical Skills

The fundamental problem this paper addresses is that current state-of-the-art robot policies — specifically Vision-Language-Action models (VLAs) — can generalize across semantic variations (different objects, different language instructions) but fundamentally fail at generalizing to new physical motions or skills in novel environments. The distinction matters enormously for real-world deployment. A VLA might successfully "move the red cup to the counter" even if it has never seen a red cup before, because it transfers the semantic knowledge from web-scale vision-language pretraining. But that same VLA will fail completely at "untie a shoelace" or "iron a shirt" if those specific motion sequences were not present in its robot training data with action labels.

The paper articulates this gap in Section 1:

"While VLAs successfully inherit linguistic priors to generalize across diverse language instructions, especially manipulating diverse objects ... their generalization to novel environments and, more critically, to new motions or skills remains limited. ... Although VLM priors encode what to do at a semantic level, they lack representations of how actions should be executed with precise spatial awareness, aligned with geometry, dynamics, and motor control."

This is not a marginal limitation — it represents a fundamental ceiling on the deployment flexibility of current robot foundation models. Every new task requiring a novel physical motion demands collecting expensive teleoperation data with expert demonstrations, annotating it with action labels, and training a new policy or fine-tuning an existing one. Each new environment with different geometry, lighting, or object placement further erodes performance because VLAs learn direct observation-to-action mappings that are brittle to distribution shifts.

Why This Problem Matters: The True Bottleneck in Physical AI

The paper frames this problem as economically and practically critical. Collecting action-labeled robot demonstration data is extremely expensive compared to collecting video data, and the current VLA paradigm — which requires both modalities for every new skill — fundamentally limits the rate at which robot capabilities can expand. Section 1 characterizes the failure mode precisely:

"As a result, VLAs often struggle to adapt to new environments or generalize to novel tasks beyond the distribution of expert demonstrations, without explicitly collecting large-scale task- and environment-specific action data."

This creates a sharp asymmetry: humans can learn new physical skills by watching videos or observing others, without requiring joint-angle labels on every frame. VLAs cannot. The paper's core motivation is to build robot policies that close this gap — models that can leverage video data (abundant, action-free, and cross-embodiment) to acquire new physical capabilities, not just new semantic mappings.

Beyond deployment economics, this gap represents a theoretical failure mode in how we transfer knowledge from pretrained models to robot control. VLAs inherit static image–text priors from VLMs. These priors capture object identities, spatial relationships, and language grounding — but not temporal dynamics, not physical causality, not how objects move and deform under contact. The paper argues that this is a fundamental mismatch: the modality being transferred (static vision–language) does not encode the information needed for the downstream task (dynamic motor control). The video diffusion approach addresses this by transferring the right pretrained knowledge — spatiotemporal representations that already encode physical dynamics from internet-scale video data.

Prior Approaches and Their Systematic Shortcomings

The paper situates its contribution against three broad categories of prior work, identifying specific failure modes in each.

Vision-Language-Action Models (VLAs). These models (RT-2, OpenVLA, GR00T N1, π₀) extend pretrained VLMs by fine-tuning on robot demonstration data to predict motor actions. Section 2.1 identifies three concrete limitations:

Semantic-only generalization. VLAs transfer semantic knowledge — "what is a cup, where should it go" — but lack spatiotemporal priors for how to physically move. The pretraining data (static image–text pairs) simply does not encode motion dynamics, contact physics, or geometric reasoning about manipulation trajectories. When deployed in environments that look different from training settings, VLAs rely on language understanding to identify correct objects, but their motion generation degrades because the visual context no longer matches the training distribution.
Brittle environment generalization. The paper notes that existing VLA work achieves environment generalization only by covering the combinatorial space explicitly: "collecting human teleoperation data across hundreds of diverse environments for specific tasks" (Section 2.1, citing Physical Intelligence 2025). This is scaling by brute force, not by learning transferable representations. A VLA that folds shirts in 10 environments still cannot fold socks in a new environment unless that specific variant was demonstrated.
Task generalization bottleneck. Current VLAs attempt to generalize by covering a large library of language-conditioned motion primitives, but the paper calls out a fundamental intractability: this approach is "fundamentally constrained by the impracticality of capturing the vast amount of possible physical interactions and motions with a fixed set of episode-level language-conditioned tasks" (Section 2.1). Even if every motion primitive were labeled, the combinatorial explosion of task–environment–object combinations would require exponentially more data than is feasible to collect with current teleoperation methods.

The paper provides empirical evidence for these claims: from-scratch VLAs trained on the same diverse AgiBot dataset achieve near-zero task progress (Section 5.1, Figure 8), while even pretrained VLAs (trained on thousands of hours of cross-embodiment data) achieve only 27.4% average task progress on seen tasks in new environments — less than half of DreamZero's 62.2%.

Video Generation Models for Robotics. Prior work has explored using video generation models in various roles — as planners (Video Language Planning, Yang et al. 2024), as data synthesizers (DreamGen, Jang et al. 2025), or as trajectories from which actions are extracted via separate inverse dynamics models (UniPi, Du et al. 2023; GR-2, Cheang et al. 2024). Section 2.2 reviews these approaches and identifies a structural limitation: most require separate models for video generation and action extraction, creating a modular pipeline where errors in video prediction propagate irrecoverably into action execution. More critically, none of these prior works systematically demonstrated that video-based world models could serve as zero-shot policies — the video prediction was primarily used for planning or data augmentation, not as the end-to-end action generator itself.

World Action Models (WAMs) — Recent Predecessors. The paper explicitly acknowledges several recent works that share the WAM philosophy — jointly learning video and action prediction from pretrained video diffusion models: Cosmos Policy (Kim et al. 2026), Genie Envisioner (Liao et al. 2025), Video Generators are Robot Policies (Liang et al. 2025), and mimic-video (Pai et al. 2025). The paper positions DreamZero as building on this lineage but addresses specific gaps:

Data diversity was not systematically studied. Most prior WAMs focus on repeated demonstrations — the paper notes that while Pai et al. (2025) and Liao et al. (2025) showed that video prediction priors improve sample efficiency for action learning compared to VLAs, "most works still focus on repeated demonstrations." No prior WAM had demonstrated that diverse, non-repetitive data (single or few demonstrations per task, highly heterogeneous) could train a generalist policy that generalizes broadly.
Autoregressive architecture was not explored at scale. Prior WAMs used bidirectional architectures (Zhu et al. 2025; Kim et al. 2026) that process fixed-length video chunks. The paper argues that bidirectional architectures create a fundamental modality alignment problem for closed-loop control: when the sampling point falls mid-task, subsampling video to match the language caption interval distorts native frame rates, degrading video–action alignment (Appendix B, Figure 13). Autoregressive architectures avoid this by conditioning on video context natively.
Cross-embodiment transfer was limited. While some prior WAMs explored embodiment transfer, DreamZero uniquely demonstrates two forms: (a) learning from video-only demonstrations of other embodiments (human and other-robot) to improve unseen task performance, and (b) few-shot adaptation to an entirely new robot embodiment with only 30 minutes of play data while retaining zero-shot generalization — capabilities the paper claims are absent from prior WAM literature.
Real-time inference at scale. Running a 14B diffusion model for closed-loop control represents a substantial engineering challenge that prior WAMs did not solve. The paper's 38× speedup (from 5.7 seconds to 150ms) is a contribution to making WAMs practically deployable, not just conceptually appealing.

How This Paper Positions Itself

The paper introduces DreamZero not as an incremental improvement but as a paradigm shift in what robot foundation models learn from and how they generalize. The core repositioning has three elements:

From state–action imitation to inverse dynamics. Section 3.1 formalizes the decomposition in Equation 1: a WAM that jointly predicts video and action is equivalent to an autoregressive video prediction model multiplied by an implicit inverse-dynamics model (IDM). The key insight is that a pretrained video diffusion backbone already carries most of the video prediction capability — the model only needs to learn the mapping from predicted visual futures to motor commands (the IDM). This is fundamentally more sample-efficient than learning direct observation-to-action mappings from scratch (as VLAs must do) because the visual prediction knowledge is inherited, not acquired.

"We further hypothesize that this encourages better generalization than the conventional practice of training VLA from VLM, as our approach explicitly learns temporal dynamics from video frames used both as conditioning inputs and prediction targets."

Video prediction fidelity as the policy performance ceiling. The paper makes a strong and testable claim: because WAMs faithfully execute whatever trajectory the video predicts, improving video generation directly improves policy performance. This shifts the optimization target — rather than improving action prediction architecture (the VLA approach), one should focus on improving the pretrained video backbone. The paper validates this through model scale ablations (Section 5.2): the 14B backbone significantly outperforms 5B (50% vs. 21% task progress), with the smaller model producing visual hallucinations that propagate to erroneous actions. This scaling behavior is notably different from VLAs, where increasing model size (scaling from 5B to 14B VLM backbones) yields almost no improvement (0% progress for both sizes), because the bottleneck is not model capacity but the wrong pretraining modality.

The term WAM as forward-looking. The paper uses "World Action Model" rather than "Video Action Model" deliberately (Section 2.1):

"We use the term World Action Models (WAMs) rather than Video Action Models (VAMs) to reflect that video is just one possible world modeling objective — future WAMs may align actions with other predictive modalities such as tactile sensing, force feedback, or learned latent representations."

This signals an architectural vision, not a narrow claim about video as the only signal. It positions the paper as initiating a research direction that could encompass future modalities while maintaining the joint prediction framework.

The Specific Gaps DreamZero Directly Addresses

Synthesizing across the paper's positioning, the gaps DreamZero fills are:

No systematic study of data diversity effects in WAMs. Prior WAMs showed that video prediction priors help but did not ablate data diversity versus repetition. Table 4 (Section 5.2) provides evidence that diversity matters enormously: at matched data hours, diverse training yields 50% task progress versus 33% for repetitive training.
No demonstration that WAMs can be zero-shot policies at scale. Prior work used video generation for planning or data augmentation. DreamZero shows that the joint video–action formulation enables the model to serve as the end-to-end policy, generalizing to unseen tasks without task-specific fine-tuning.
No evidence for scaling laws in WAMs. The ablation showing 5B → 14B improvement (21% → 50%) is, to the paper's knowledge, the first evidence that WAM performance scales with backbone size, suggesting a qualitatively different scaling trajectory from VLAs.
No practical deployment recipe for models of this size. The 38× speedup through DreamZero-Flash, system-level optimizations, and quantization provides a concrete pathway from research model to deployable system — something prior WAMs and most VLA papers do not address.
No cross-embodiment transfer without action labels. Unlike VLA-based embodiment transfer (which requires action-labeled data on the new embodiment), DreamZero's video-only transfer (Table 2) and few-shot adaptation (Figure 12) demonstrate a qualitatively different capability: leveraging abundant video data to improve policies, without requiring paired action annotations.

3. Technical Approach

3.1 Reader Orientation

DreamZero is a 14-billion-parameter neural network that acts as a robot policy: it takes in a camera image, a language instruction, and the robot's current joint positions, and outputs a video of what the robot should do next along with the exact motor commands to make that video happen. The system solves the problem of how to build a generalist robot policy that can (1) learn effectively from diverse, non-repetitive demonstrations without requiring hundreds of repetitions per task, (2) generalize zero-shot to entirely new physical skills and environments never seen during training, and (3) transfer knowledge from video-only data of other robots or humans without needing action labels — all while running fast enough for real-time closed-loop control at 7Hz on a real robot.

3.2 Big-Picture Architecture (Diagram in Words)

DreamZero has five major components that together form an end-to-end pipeline from perception to action:

Perception Encoders — three separate encoders: a VAE (Variational Autoencoder) compresses raw camera images into compact latent vectors, a frozen text encoder converts language instructions into conditioning tokens, and a proprioceptive state encoder processes the robot's current joint positions into a conditioning vector. These produce the "context" that tells the model what the scene looks like and what to do.
Autoregressive Diffusion Transformer (DiT) Backbone — a 14B-parameter transformer initialized from Wan2.1-I2V-14B-480P, a pretrained image-to-video diffusion model. This is the central engine that takes in noisy video and action tokens along with the encoded context, and iteratively denoises them to produce clean video frames and motor commands. It operates chunk-by-chunk (each chunk spans 1.6 seconds), generating future observations autoregressively while leveraging a KV-cache for efficiency.
Joint Video-Action Prediction Heads — the DiT backbone predicts velocity vectors (direction toward clean signals) for both video latents and actions simultaneously, rather than using separate models. This shared denoising process ensures that the generated video and the generated actions are tightly aligned — the video acts as a visual plan that the actions follow.
Closed-Loop Execution System — during deployment, the model runs asynchronously: the robot continuously executes the most recent action chunk while DreamZero generates the next chunk from the latest camera observation. Critically, after executing an action chunk, the system replaces the model's predicted video frames with ground-truth camera observations in the KV-cache, preventing the compounding errors that normally plague autoregressive video generation.
Inference Optimization Stack — a collection of system-level, implementation-level, and model-level optimizations that together achieve a 38× speedup (from 5.7 seconds to 150ms per action chunk), enabling real-time control at 7Hz. The key model-level innovation is DreamZero-Flash, which decouples video and action noise schedules during training so that at inference time the model can skip video denoising steps without degrading action quality.

3.3 Roadmap for the Deep Dive

First, the formal problem formulation and training objective (Equation 1 through Equation 3), because these define what the model is learning to do and why the joint video–action objective decomposes into a video prediction model times an inverse dynamics model — this decomposition is the conceptual core of the paper.
Second, the autoregressive chunk-wise architecture and attention masking strategy, since the choice of autoregressive over bidirectional generation is a key design decision with major implications for modality alignment, inference speed, and closed-loop control.
Third, the training procedure — data sampling, teacher forcing, flow matching — because the specific way noise is scheduled and cleaned across video and action latents during training determines what the model can do at inference.
Fourth, the inference-time closed-loop control loop, including how KV-cache is managed, how ground-truth observations replace predicted frames, and how action smoothing works — this is what makes the model a policy rather than just a generative model.
Fifth, the real-time execution optimization stack (DreamZero-Flash, system parallelism, quantization, caching), since without these the model is impractically slow and the entire contribution would be purely academic.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems and methods paper whose core idea is that jointly predicting video and action using a pretrained video diffusion backbone, with carefully designed autoregressive generation and real-time optimizations, yields a generalist robot policy that generalizes better, learns from more diverse data, and transfers across embodiments more effectively than VLAs trained on the same data.

Joint Video-Action Formulation as Inverse Dynamics

The central equation of DreamZero's training objective is a decomposition of the joint distribution of future video frames $\mathbf{o}_{l:l+H}$ and actions $\mathbf{a}_{l:l+H}$ conditioned on history $\mathbf{o}_{0:l}$ , language instruction $\mathbf{c}$ , and current proprioceptive state $\mathbf{q}_l$ :

$\pi_{0}(\mathbf{o}_{l:l+H},\mathbf{a}_{l:l+H} \mid \mathbf{o}_{0:l},\mathbf{c},\mathbf{q}_{l}) = \pi_{0}(\mathbf{o}_{l:l+H} \mid \mathbf{o}_{0:l},\mathbf{c},\mathbf{q}_{l}) \cdot \pi_{0}(\mathbf{a}_{l:l+H} \mid \mathbf{o}_{0:l+H},\mathbf{q}_{l})$

where $l$ is a random index sampled from a trajectory, $H > 0$ is a fixed prediction horizon, $\mathbf{o}_{l:l+H}$ are the future video frames to predict, $\mathbf{a}_{l:l+H}$ are the future actions to predict, $\mathbf{o}_{0:l}$ is the history of past video observations, $\mathbf{c}$ is the language instruction, and $\mathbf{q}_l$ is the proprioceptive state at time $l$ .

What it computes: the probability of a future video–action trajectory given the current context. The left side is what DreamZero directly models. The right side factors this into two terms: (1) an autoregressive video prediction model that generates what the robot should see next, and (2) an inverse dynamics model (IDM) that predicts what actions would produce those visual changes. The product means: first imagine what should happen visually, then figure out what motor commands would make that vision real.

Why this form: rather than training two separate models (a video predictor and an action extractor), DreamZero trains a single end-to-end model that shares representations between both objectives. This is justified by the observation that a pretrained video diffusion backbone already encodes the video prediction capability from internet-scale data — the model only needs to additionally learn (a) how to adapt video prediction to the robot's specific visual perspective and (b) how to map from predicted visual trajectories to motor commands. The paper argues that learning this implicit IDM is inherently more sample-efficient than learning a direct state-to-action mapping (as VLAs do) because the visual prediction knowledge is inherited rather than acquired. The joint objective also ensures that the same internal representations serve both purposes, which the paper claims leads to tighter video–action alignment than would be achieved with separate models whose representations could drift apart.

Flow Matching Training Objective

DreamZero is trained using flow matching (also called rectified flow), a continuous-time generative modeling framework. The core idea: instead of a discrete diffusion process with a fixed number of steps, flow matching defines a continuous interpolation between a clean data point and random noise, and the model learns to predict the velocity (direction and rate of change) that would transform noise into data along a straight path.

Formally, given a chunk index $k > 0$ and a denoising timestep $t_k \in [0,1]$ , the noisy video latent vector and noisy action vector are defined as linear interpolations:

$\mathbf{z}_{t_k}^k = t_k \mathbf{z}_1^k + (1 - t_k) \mathbf{z}_0^k, \quad \mathbf{a}_{t_k}^k = t_k \mathbf{a}_1^k + (1 - t_k) \mathbf{a}_0^k$

where $\mathbf{z}_1^k$ is the clean video latent (obtained by encoding the ground-truth video through the frozen VAE), $\mathbf{z}_0^k \sim \mathcal{N}(\mathbf{0}, \mathbf{I})$ is a random Gaussian noise vector, $\mathbf{a}_1^k$ is the normalized ground-truth action, and $\mathbf{a}_0^k \sim \mathcal{N}(\mathbf{0}, \mathbf{I})$ is random Gaussian noise. When $t_k = 0$ , the sample is pure noise; when $t_k = 1$ , it is clean data; for intermediate $t_k$ , it is a mixture.

What it computes: for each chunk $k$ , this interpolation creates a partially corrupted version of the ground-truth video and action, blending between pure noise (when $t_k = 0$ ) and clean data (when $t_k = 1$ ). The degree of corruption is controlled by $t_k$ — lower values mean more noise, higher values mean more signal.

Why this form: linear interpolation between noise and clean data is the simplest possible corruption process, and flow matching theory shows that under this interpolation, the optimal denoising direction is simply the vector from noise to data: $\mathbf{v}^k \coloneqq [\mathbf{z}_1^k, \mathbf{a}_1^k] - [\mathbf{z}_0^k, \mathbf{a}_0^k]$ . This means the model's training target is a simple, well-defined velocity rather than a score function (as in score-based diffusion) or a noise prediction (as in DDPM). The linear path also enables straight-line sampling trajectories during inference, which can require fewer denoising steps than curved trajectories.

Given the clean context from previous chunks $\mathcal{C}_k = \{(\mathbf{z}_1^j, \mathbf{a}_1^j)\}_{j=1}^{k-1}$ , the model $\mathbf{u}_\theta$ is trained to predict the joint velocity for both modalities:

$\mathcal{L}(\theta) = \mathbb{E}_{\mathbf{z},\mathbf{a},\{t_k\}} \left[ \frac{1}{K} \sum_{k=1}^{K} w(t_k) \left\| \mathbf{u}_{\theta}([\mathbf{z}_{t_k}^k, \mathbf{a}_{t_k}^k]; \mathcal{C}_k, \mathbf{c}, \mathbf{q}_k, t_k) - \mathbf{v}^k \right\|^2 \right]$

where $\mathbf{u}_\theta$ is the DiT backbone parameterized by $\theta$ , $K$ is the number of chunks in the trajectory, $w(t_k) > 0$ is a predefined weight function for the timestep (typically uniform), $\mathbf{c}$ is the text condition, $\mathbf{q}_k$ is the proprioceptive state for chunk $k$ , and $\mathbf{v}^k$ is the target velocity (the vector from noise to clean data for that chunk).

What it computes: the model takes a noisy video–action pair $[\mathbf{z}_{t_k}^k, \mathbf{a}_{t_k}^k]$ , the clean context from all previous chunks $\mathcal{C}_k$ , the language instruction $\mathbf{c}$ , the robot's current state $\mathbf{q}_k$ , and the timestep $t_k$ . It outputs a predicted velocity vector. The loss is the mean squared error between this predicted velocity and the ground-truth velocity $\mathbf{v}^k$ (which points directly from the noise to the clean data). This is averaged across all $K$ chunks in the trajectory and across the expectation over the data distribution and noise samples.

Why this form: the flow matching loss trains the model to learn an ODE (Ordinary Differential Equation) that, when integrated from $t = 0$ to $t = 1$ , maps random noise to clean data. The key property is that along a straight-line interpolation, the velocity is constant — this means fewer integration steps are needed at inference, and the model can be trained with a simple $L_2$ loss rather than the more complex score-matching objective used in standard diffusion. The chunk-wise structure (summing over $k$ chunks) enables trajectory-level updates — the model processes an entire trajectory in one forward pass rather than isolated clips, which the paper argues improves temporal consistency because the model sees how actions and video evolve over longer horizons. The expectation over $\{t_k\}$ means each chunk within a trajectory gets an independent, randomly sampled timestep, so the model learns to denoise from any noise level for any position in the trajectory.

Critical implementation detail from Algorithm 1: DreamZero defaults to having video and action share the same timestep $t_k \sim \mathcal{U}(0,1)$ during standard training. This coupling means the model learns to denoise both modalities at the same rate. DreamZero-Flash (discussed later) decouples these schedules to enable faster inference.

Autoregressive Chunk-Wise Architecture

DreamZero generates video and action chunks autoregressively: each chunk is conditioned on the clean, ground-truth video latents and actions from all previous chunks (teacher forcing). This design choice has specific architectural implications.

Chunk structure. Each chunk contains $K = 2$ latent video frames. The number of chunks per trajectory is $M = 4$ by default, though trajectories shorter than this use fewer chunks. For AgiBot data, video is sampled at 5 FPS and actions at 30 Hz, with an action horizon of $H = 48$ steps. This means each chunk spans $48 / 30 = 1.6$ seconds of real time. For DROID data, actions are sampled at 15 Hz with $H = 24$ , yielding the same 1.6-second chunk duration. The maximum visual context is 8 latent frames (4 chunks × 2 frames per chunk), equivalent to 33 raw frames spanning 6.6 seconds at 5 FPS.

Why $K = 2$ : the paper reports that preliminary experiments showed $K = 2$ latent frames per chunk outperforms $K = 1$ empirically. Generating two frames at once likely provides enough temporal context for the IDM to infer smooth action trajectories, while keeping the per-chunk diffusion cost manageable. Larger $K$ would increase the latent dimension that needs to be denoised, slowing inference.

QKV attention masking strategy (Figure 14). The autoregressive structure is implemented through a causal attention mask in the DiT backbone. During training, given conditioning frames (denoted C0, C1, C2 in Figure 14a) from previous chunks, the model predicts velocities for the next frames (Z1, Z2, Z3) and actions (Y1, Y2, Y3). The attention mask (Figure 14a) enforces that:

Each noisy video token $Z_i$ can attend to all conditioning tokens $C_j$ (the clean context) and to other video tokens within the same chunk, but NOT to action tokens — video prediction is not conditioned on predicted actions.
Each noisy action token $Y_i$ can attend to all conditioning tokens $C_j$ (the clean visual history), to all video tokens (both conditioning and currently-being-denoisied), and to previous action tokens within the same chunk — actions CAN see the full visual context, which is critical for learning inverse dynamics.

This asymmetric masking is fundamental: it ensures that actions are conditioned on visual observations (both past and the video being generated) but video generation is not contaminated by action predictions. At inference time (Figure 14b), the same masking applies, but the conditioning frames $C_0, C_1, C_2$ in the KV-cache are replaced with ground-truth observations from the robot's cameras after each execution cycle (see the closed-loop section below).

Why autoregressive over bidirectional. Appendix B (Figure 13) provides a detailed justification. In a bidirectional WAM, when a language caption covers a long task interval but the model only generates a short video clip, the language describes actions not yet visible in the predicted frames — creating a modality mismatch. Subsampling video to match the caption interval distorts the native FPS, making video–action alignment harder because the temporal relationship between frames changes. An autoregressive WAM sidesteps this by conditioning on past video context rather than subsampling — the language instruction conditions the first chunk, and subsequent chunks inherit the visual context sequentially, preserving both language–video correspondence AND native frame rate. The paper also notes that autoregressive generation is 3–4× faster than bidirectional due to KV-caching (Section 5.2, Table 4 annotation).

Training Procedure and Data Flow

The training loop (Algorithm 1) proceeds as follows:

Sample a trajectory from the dataset. Each trajectory is a sequence of multi-view camera observations, proprioceptive states, and action commands from teleoperation.
Encode and split. The raw video frames are encoded into clean latents $\mathbf{z}_1^{1:M}$ through the frozen VAE. Actions are normalized (likely to zero-mean and unit-variance or $[-1, 1]$ range, though exact normalization is not specified beyond filtering idle actions). The trajectory is split into $M$ chunks of equal length.
Chunk-wise teacher forcing. For each chunk $k$ from 1 to $M$ :
- The clean context $\mathcal{C}_k$ is constructed as the set of all clean video–action pairs from chunks $1$ to $k-1$ . This is teacher forcing: the model sees ground-truth previous chunks, not its own predictions.
- A timestep $t_k \sim \mathcal{U}(0,1)$ is sampled. In DreamZero-Flash mode, instead, $t_{vid} \sim \text{Beta}(7,1)$ is sampled for video and $t_{act} \sim \mathcal{U}(0,1)$ for action (decoupled schedules, detailed in the Flash section below).
- Independent Gaussian noise $\mathbf{z}_0^k, \mathbf{a}_0^k \sim \mathcal{N}(\mathbf{0}, \mathbf{I})$ is sampled for both modalities.
- Noisy latents are computed via the interpolation formula (Equation 2).
- The model predicts the velocity $\mathbf{v}_{pred}$ given the noisy input, clean context, language embedding, proprioceptive state, and timestep.
- The loss is $\mathcal{L} = \|\mathbf{v}_{pred} - \mathbf{v}^k\|^2$ where $\mathbf{v}^k$ is the target velocity $[\mathbf{z}_1^k, \mathbf{a}_1^k] - [\mathbf{z}_0^k, \mathbf{a}_0^k]$ .

Training hyperparameters (Section 4.1). DreamZero is trained for 100K steps with a global batch size of 128 for both AgiBot and DROID datasets. All DiT blocks, the state encoder, action encoder, and action decoder are updated during training. The text encoder, image encoder (VAE encoder), and VAE decoder are frozen. The paper experimented with LoRA (Low-Rank Adaptation) for parameter-efficient fine-tuning but found it "led to suboptimal results." The backbone is Wan2.1-I2V-14B-480P, a 14B image-to-video diffusion model.

Data filtering. Idle actions (where the robot is stationary) are filtered out from the training data. The default action representation is relative joint positions. For multi-view robot data, all camera views are concatenated into a single wide frame rather than modifying the backbone architecture — this is a deliberately minimal architectural change to preserve the pretrained video model's generalization capability.

Why end-to-end full-parameter training over LoRA: the paper does not elaborate extensively on this empirical finding, but the implication is that adapting a video diffusion model to simultaneously generate robot-embodiment-specific video and aligned actions requires substantial capacity changes that low-rank updates cannot capture. The DiT backbone needs to learn entirely new output modalities (actions, robot-specific visual features) and new types of conditioning (proprioception, multi-view camera arrangements). Freezing the VAE and text encoder is safe because these are well-generalized from web-scale pretraining; updating the DiT is necessary because it must learn the robot-specific dynamics.

Inference-Time Closed-Loop Control

The inference procedure (Algorithm 2) is where DreamZero transitions from a generative model to a deployable policy. The key insight is that while video generation is autoregressive (each chunk depends on previous chunks), action execution is closed-loop — the robot's actual observations replace predicted frames, preventing error accumulation.

Phase 1: KV-cache prefill (context phase). At time $t = 0$ , the initial camera observation $\mathbf{o}_{\text{init}}$ is encoded through the VAE to produce clean latents $\mathbf{z}_{\text{init}}$ . The model is called with these clean latents, no action or state, and $t = 0$ , with update = True — meaning the model computes and stores the key-value pairs for these conditioning frames in the KV-cache but does not perform denoising. This establishes the initial visual context.

Phase 2: Autoregressive denoising loop. While the task is not done:

Sample noise. Fresh Gaussian noise is drawn: $\mathbf{x}_0 = [\mathbf{z}_0, \mathbf{a}_0] \sim \mathcal{N}(\mathbf{0}, \mathbf{I})$ .
Iterative denoising. For $i = 0$ to $N - 1$ (typically $N = 4$ with standard DreamZero or $N = 1$ with DreamZero-Flash):
- The current timestep $t_i$ and next timestep $t_{i+1}$ are determined by a scheduler (the paper uses Flow UniPC, a flow-matching scheduler).
- The model $\mathbf{u}_\theta$ predicts the velocity $\mathbf{v}_i^{\text{vid}}$ and $\mathbf{v}_i^{\text{act}}$ given the noisy input $\mathbf{x}_{t_i}$ , the KV-cache $\mathcal{KV}$ , the language condition $\mathbf{c}$ , the current proprioceptive state $\mathbf{q}_{\text{curr}}$ , and the timestep $t_i$ , with update = False (no KV-cache modification during denoising).
- A solver step updates the noisy input: $\mathbf{x}_{t_{i+1}} = \mathbf{x}_{t_i} + \text{Step}(\mathbf{v}_i, t_i, t_{i+1})$ where $\text{Step}$ is a numerical ODE integration step (likely Euler or a higher-order method based on the UniPC scheduler).

Phase 3: Execution and cache update. After denoising is complete:

Extract and execute actions. The clean action $\hat{\mathbf{a}}$ (the action component of $\mathbf{x}_1$ , which is at $t = 1$ ) is extracted. It passes through an action chunk smoothing filter (up-sample to 2× resolution via cubic interpolation, apply Savitzky-Golay filter with window size 21 and polynomial order 3, then downsample to original resolution). The smoothed action chunk is asynchronously executed on the robot while inference continues.
Inject ground-truth observation. While the actions are executing, the robot's cameras capture new real observations $\mathbf{o}_{\text{real}}$ and proprioceptive state $\mathbf{q}_{\text{real}}$ . These are encoded through the VAE to produce $\mathbf{z}_{\text{real}}$ . The model is called again with $[\mathbf{z}_{\text{real}}, \emptyset]$ at $t = 0$ with update = True — the KV-cache is updated with the new ground-truth visual observation. The predicted video latent from the previous denoising cycle is discarded — the model never uses its own video predictions as future context.

Why replace predicted frames with ground-truth: this is the critical mechanism that prevents the compounding error problem inherent to autoregressive video generation. If the model used its own slightly-imperfect predicted frames as context for the next chunk, errors would accumulate and the policy would quickly diverge from reality. By inserting real camera observations after every execution cycle, the model always runs on grounded, accurate visual context. This is a unique advantage of WAMs over pure video generation models — the policy has access to the real world, so it doesn't need perfect video prediction for stable control.

Why asynchronous execution: the denoising process (even at 150ms with optimizations) is too slow to run synchronously with 30Hz control loops. By running inference on the latest observation while the robot executes the previous action chunk (1.6 seconds at 48 steps), the system achieves smooth, reactive control. The constraint is that inference must complete before the current chunk expires; the target is ~200ms to ensure sufficient overlap with the 1.6-second execution window.

DreamZero-Flash: Decoupled Noise Schedules

DreamZero-Flash is the model-level optimization that enables reducing denoising steps from 4 to 1 with minimal performance degradation. The standard DreamZero formulation shares the same denoising timestep for both video and action:

$t_k^{\text{video}} = t_k^{\text{action}} = t_k, \quad t_k \sim \mathcal{U}(0,1)$

This creates a problem at inference time: if we want to denoise actions in very few steps (ideally 1 step, going from $t = 0$ to $t = 1$ instantly), the video latents would also need to denoise from pure noise to clean in one step — but the model was never trained to predict actions when video is still noisy. During training, video and action were always at the same noise level, so at inference, predicting clean actions from partially-denoised (noisy) video is out-of-distribution.

DreamZero-Flash decouples the schedules by biasing video timesteps toward higher noise levels (lower $t$ values) while keeping action timesteps uniform:

$t_k^{\text{video}} = 1 - \eta, \quad \eta \sim \text{Beta}(\alpha, \beta), \quad t_k^{\text{action}} \sim \mathcal{U}(0,1)$

where $\alpha = 7$ and $\beta = 1$ are the parameters of the Beta distribution, chosen such that $\alpha > \beta$ concentrates probability mass near $\eta \approx 1$ . This means $t_k^{\text{video}} = 1 - \eta$ is biased toward small values (high noise). Specifically, $\mathbb{E}[\eta] = 0.875$ , giving $\mathbb{E}[t_k^{\text{video}}] = 0.125$ , meaning during training, video frames appear predominantly noisy (closer to $t = 0$ ) when actions can appear at any noise level from $t \sim \mathcal{U}(0,1)$ .

What it computes: during training, the model is frequently exposed to configurations where (a) video is heavily corrupted (low $t^{\text{video}}$ , close to random noise) and (b) actions are at any arbitrary noise level (possibly clean, if $t^{\text{action}} \approx 1$ ). This means the model learns to predict clean or partially-clean actions from very noisy visual context — exactly the scenario encountered during few-step inference.

Why this form: the Beta(7,1) distribution was chosen as an example configuration that empirically works well; the paper notes it is one of many possible scheduling strategies. The key property is that $\alpha > \beta$ creates a right-skewed distribution over $\eta$ , which when transformed to $1 - \eta$ becomes left-skewed over $t^{\text{video}}$ (biased toward 0). This means the training distribution disproportionately covers the regime where video noise dominates, preparing the model for aggressive action denoising at test time. Alternative distributions (e.g., different $\alpha, \beta$ pairs) would simply shift the bias; the qualitative insight is that at least SOME training mass must cover the few-step inference regime.

Effect on inference: with DreamZero-Flash, the number of denoising steps can be reduced from $N = 4$ to $N = 1$ . In single-step mode, actions denoise from $t = 0$ to $t = 1$ in one leap, while video latents simply stay at whatever noise level they have (since they are not used for execution — they are discarded after the KV-cache update). Empirically, on the table bussing task (Table 3), DreamZero-Flash with 1 denoising step achieves 74% task progress (vs. 52% for standard DreamZero at 1 step), recovering most of the 83% achieved by standard DreamZero at 4 steps — while being 2.33× faster.

System-Level Optimizations

The paper introduces three system-level optimizations that cumulatively reduce inference latency.

CFG Parallelism. Classifier-free guidance (CFG) requires two separate forward passes through the DiT backbone: one conditioned on the text instruction and one unconditioned (with $\mathbf{c}$ set to a null token). These are typically executed sequentially. DreamZero distributes the conditional and unconditional passes across two independent GPUs, running them in parallel. This reduces per-step latency by approximately 47% (Table 1: baseline 1× to 1.9× with CFG parallelism on H100). Since the two passes are independent (same DiT parameters, different conditioning), no synchronization is needed between GPUs until the velocity outputs are combined via the CFG formula $\mathbf{v}_{\text{CFG}} = \mathbf{v}_{\text{uncond}} + w(\mathbf{v}_{\text{cond}} - \mathbf{v}_{\text{uncond}})$ for some guidance scale $w$ . This optimization is mathematically equivalent to sequential execution, so there is no quality degradation.

DiT Caching. The iterative denoising process often produces velocity predictions that change very little between successive denoising steps, especially near convergence. DreamZero exploits this by tracking the cosine similarity between consecutive velocity predictions. When this similarity exceeds a predefined threshold $\epsilon$ , the model skips the DiT forward pass for subsequent steps and reuses the cached velocity vector. This adaptive scheduling reduces the average number of actual DiT forward passes from 16 to 4, yielding a roughly 4× speedup (from 1.9× to 5.5× in Table 1).

The caching mechanism is specific to flow matching: because the velocity field of a straight-line interpolation is theoretically constant, successive denoising steps should produce similar velocity vectors (pointing from the current noisy state toward the clean data). When the cosine similarity is high, the velocity hasn't changed meaningfully, so the expensive DiT computation can be bypassed. The threshold $\epsilon$ controls the tradeoff: a higher threshold means more cautious caching (fewer steps skipped, higher quality), while a lower threshold means more aggressive caching (more steps skipped, lower quality). The paper does not specify the exact threshold value but notes that the effective reduction from 16 to 4 steps incurs "minimal degradation to predicted video and action fidelity."

Asynchronous Execution. The paper adopts an asynchronous architecture where model inference and action execution run concurrently: the robot's motion controller continuously replays the most recent action chunk while the inference module processes the latest camera observation in a separate thread. This decoupling means the latency constraint shifts from "inference must be faster than one control timestep (~33ms at 30Hz)" to "inference must be faster than one action chunk duration (1.6 seconds)." With the target latency of ~150ms (after all optimizations), this provides a comfortable margin. This optimization does not reduce raw inference time but transforms the system architecture so that the time spent on inference is overlapped with action execution, making the overall system reactive rather than stop-and-wait.

Implementation-Level Optimizations

Three additional optimizations operate below the system architecture level.

Torch Compile and CUDA Graphs. The inference pipeline is dominated by CPU overhead — kernel launch scheduling, Python interpreter overhead, and frequent CPU–GPU synchronization. DreamZero applies torch.compile with CUDA Graphs (mode="reduce-overhead") and enforces full graph capture (fullgraph=True) to eliminate graph breaks. Compilation is applied to five model components: the diffusion transformer, scheduler, text encoder, image encoder, and VAE. Static shapes are enforced (dynamic=False) to enable full graph capture, which means the first inference trajectory triggers multiple recompilations as the KV-cache shape evolves. From the second trajectory onward, no recompilation occurs. This optimization reduces latency by approximately 2× beyond the system-level optimizations (from 5.5× to 8.9× on H100, Table 1). To enable error-free compilation, the code is refactored to follow a functional programming paradigm where the KV-cache is explicitly passed as input and returned as output of compiled functions.

Post-Training Quantization. On the Blackwell (SM100) architecture (used in GB200 GPUs), model weights and activations are quantized to NVFP4 (E2M1 format — 4-bit floating point with 2-bit exponent and 1-bit mantissa). Sensitive operations — QKV projections and Softmax within the attention mechanism — are kept at FP8 (E4M3, 8-bit floating point with 4-bit exponent and 3-bit mantissa) to preserve numerical precision where it matters most. Non-linear operations (LayerNorm, RoPE positional embeddings) use FP16 accumulation. This mixed-precision strategy delivers significant speedup (14.8× → 16.6× in Table 1) with "negligible impact on generated video and action quality" (Appendix D.2). The Blackwell architecture's native FP4 support makes this possible; earlier GPU architectures would not benefit as much from this optimization.

Kernel and Scheduler Enhancements. Two low-level optimizations are applied: (a) the cuDNN backend is used for dot-product attention via PyTorch's Scaled Dot-Product Attention (SDPA) API, requiring PyTorch version ≥ 2.9; (b) the Flow UniPC scheduler (the numerical ODE solver that determines timestep sequences) is migrated from CPU to GPU execution. The original scheduler implementation required several operations that ran on CPU, causing GPU stalls while waiting for CPU results (CPU–GPU synchronization bottlenecks). Moving all scheduler operations to GPU eliminates these stalls. This yields approximately a 1.5× speedup (from 10.9× to 14.8× on GB200, Table 1).

Action Chunk Smoothing

After denoising, the raw action predictions may contain high-frequency noise from the diffusion process — rapid oscillations that would cause jerky, unstable robot motion. DreamZero applies a three-stage smoothing pipeline:

Upsample the action chunk to 2× temporal resolution using cubic interpolation. This increases the number of action steps from, say, 48 to 96, providing finer temporal granularity for the filter.
Apply a Savitzky-Golay filter — a polynomial smoothing technique that fits successive sub-sets of adjacent data points with a low-degree polynomial. The paper uses a window size of 21 and a polynomial order of 3. This means each filtered action value is computed by fitting a cubic polynomial to a sliding window of 21 consecutive action steps and evaluating the polynomial at the center of the window. The window size of 21 at 2× resolution corresponds to 10.5 original timesteps, providing moderate temporal smoothing.
Downsample the filtered action trajectory back to the original resolution. The smoothed action chunk is then sent to the robot's motion controller for execution.

Why Savitzky-Golay over alternatives: Savitzky-Golay filtering preserves higher moments of the trajectory (peak heights, curvature) better than a simple moving average, which would flatten acceleration profiles and potentially smooth away important motion features. The cubic polynomial fit (order 3) allows the filter to track position, velocity, acceleration, AND jerk without distortion, which is important for smooth and reactive robot motion. The window size of 21 represents a trade-off: larger windows would provide more aggressive smoothing but might delay response to rapid motion changes; smaller windows would preserve more detail but retain more noise.

Overall Inference Speedup Summary

Table 1 provides the cumulative speedup across optimization categories. Starting from a baseline of 5.7 seconds per action chunk on a single H100 GPU, the system achieves:

1.9× with CFG parallelism alone (distributing conditional/unconditional passes).
5.5× with DiT caching added (reducing effective denoising steps from 16 to 4).
8.9× with Torch Compile and CUDA Graphs (eliminating CPU overhead).
9.6× with kernel and scheduler optimizations (cuDNN attention, GPU scheduler).
16.6× with NVFP4 quantization on GB200 (exploiting Blackwell's FP4 support).
38× with DreamZero-Flash (reducing denoising steps from 4 to 1).

The final latency is approximately 150ms (5.7s ÷ 38) on 2 GB200 GPUs, achieving roughly 7Hz inference frequency. For the AgiBot and Franka robots with 1.6-second action chunks, this provides over 10× headroom — the robot can execute smoothly without ever waiting for inference.

Why these optimizations are necessary, not optional: without them, a 14B autoregressive diffusion transformer is fundamentally inoperable as a closed-loop policy. The baseline 5.7-second latency per chunk would mean the robot executes for 1.6 seconds, then sits idle for 5.7 seconds, then executes for 1.6 seconds, etc. — completely unusable for any real-world task. The optimization stack transforms DreamZero from a research demonstration to a practically deployable system, which the paper argues is part of the core contribution rather than mere engineering detail.

4. Key Insights and Innovations

Innovation 1: World Action Models as a New Problem Decomposition — Inverse Dynamics from Video Priors

The most conceptually distinctive move in this paper is not the joint video–action architecture itself — prior works (Kim et al., 2026; Pai et al., 2025; Zhu et al., 2025) have jointly trained video and action prediction — but rather the reframing of the policy learning problem from direct state-to-action imitation to inverse dynamics recovery from a pretrained world model. Equation 1 formalizes this: the joint video–action distribution factors into an autoregressive video prediction model (inherited from the pretrained backbone) times an implicit inverse-dynamics model that extracts motor commands from predicted visual futures.

This reframing matters because it shifts the source of generalization. In VLAs, generalization comes from the semantic content of vision–language pretraining — the model knows what objects are, what verbs mean, what spatial relationships look like. But this knowledge is fundamentally about identification (what is present in the scene, what task is requested), not about execution (how to physically manipulate objects to achieve the goal). The inverse-dynamics formulation inverts this: the model inherits spatiotemporal knowledge from video pretraining — how objects move, how they deform under contact, how 3D geometry evolves in camera space — and only needs to learn the comparatively simple mapping from visual trajectories to motor commands for a specific embodiment. The paper's finding that failures primarily stem from video generation errors rather than action extraction errors (Section 5.1, Appendix H) validates this framing: the bottleneck is visual planning quality, not inverse-dynamics learning.

The significance of this reframing extends beyond DreamZero's results. It implies that improving robot policies reduces to improving video generation models — a claim the paper explicitly makes and supports with model scaling evidence. The 14B backbone substantially outperforms 5B (50% vs. 21% task progress, Table 4), while scaling VLA backbones from 5B to 14B yields zero improvement (0% task progress for both, Table 4). This is not an incremental difference — it is a qualitatively different scaling relationship, suggesting that these architectures live on fundamentally different scaling curves where performance is bounded by different factors (video generation quality for WAMs, direct mapping capacity for VLAs).

The paper also applies this reframing to explain why diverse data works better than repetitive data for WAMs — another finding that distinguishes WAMs from VLAs. The inverse-dynamics interpretation is that learning a robust IDM requires seeing diverse state–action correspondences across varied visual contexts; repetitive demonstrations in similar settings provide narrow training for the inverse mapping. VLAs trained on the same diverse data collapse to near-zero performance because their direct observation-to-action mapping has no pretrained spatiotemporal prior to regularize it against distribution shifts. This diagnostic — that video prediction priors serve as regularization for action learning — is more explanatory than simply noting that diverse data helps, and it points toward a research program where the design of pretraining objectives and the design of data collection strategies are treated as coupled decisions.

Innovation 2: Data Diversity as a First-Class Design Principle for Robot Foundation Models

The paper makes a strong empirical case that the effectiveness of WAMs is determined not just by total training hours but by the distribution of those hours — specifically, that breadth across tasks, environments, and visual contexts matters substantially more than depth of repetitions within a narrow distribution. The ablation in Table 4 (Section 5.2) demonstrates this directly: at matched 500 hours of data, diverse training (many tasks, few repetitions each) yields 50% task progress vs. 33% for repetitive training (70 tasks with many repetitions each, similar object positions/configurations). This 1.5× improvement is larger than what is gained from architectural improvements or even model scaling in many contexts.

What makes this a genuine innovation rather than an unsurprising "more data diversity helps" observation is the mechanism through which diversity operates in WAMs versus VLAs, and the implications this has for how robot data collection should be designed. The paper's data collection strategy (Appendix E) is systematically different from standard robot learning pipelines: rather than collecting hundreds of demonstrations per task in controlled settings, operators continuously propose new tasks, tasks are deprecated after reaching 50 episodes, and each episode combines 3 coarse-grained tasks in sequence, yielding ~42 subtasks per episode (Figure 6b). This produces a long-tail distribution where the majority of behaviors appear in few demonstrations.

For VLAs, this data strategy is catastrophic — from-scratch VLAs achieve near-zero performance (Figure 8), and even pretrained VLAs struggle despite having seen thousands of hours of robot data. The reason, the paper argues, is that VLAs learn direct observation-to-action mappings without a dynamics prior to regularize across visual distribution shifts. When a VLA sees a "pick up cup" demonstration in 10 different environments, it learns 10 separate pattern associations that may not compose into a robust policy. WAMs, by contrast, learn an IDM that is conditioned on the visual context predicted by the world model — the video prediction side handles the environment variation, and the IDM only needs to map from "what the robot should see" to "what the joints should do." Because the video prediction is largely inherited from pretraining, it is far more robust to visual diversity.

This reframes the data collection problem for robot learning: rather than asking "how many repetitions per task for robust behavior cloning," the relevant question becomes "how diverse does the visual experience need to be for the IDM to generalize." The paper's finding that 500 hours of diverse data outperforms 500 hours of repetitive data on the same downstream tasks implies that data diversity is not merely helpful but is the dominating factor in WAM performance — more important than, say, architecture choices or training hyperparameters. This is a conceptual shift with direct implications for how research groups should allocate data collection resources, and it suggests that the scaling laws for WAMs may depend more on diversity metrics than on raw demonstration counts.

Innovation 3: Autoregressive Generation as a Solution to the Modality Alignment Problem in Closed-Loop Control

The choice of autoregressive over bidirectional generation might appear to be a minor architectural preference, but the paper's analysis in Appendix B (Figure 13) reveals that it addresses a fundamental modality alignment problem specific to closed-loop WAMs. When a language instruction describes a task that spans multiple seconds (e.g., "put the black objects into the drawer"), and the policy must generate actions from arbitrary mid-task states (not just task beginnings, as is standard in open-loop video generation), bidirectional architectures face an irreconcilable trade-off: either subsample video to match the language caption interval and distort native FPS (breaking video–action alignment), or preserve FPS and accept a modality mismatch where the language describes actions not yet visible in the generated frames.

The autoregressive solution — conditioning each generation step on the actual visual history rather than subsampling to match a text interval — is elegant in retrospect but represents a genuinely different problem formulation. It transforms the WAM from a model that generates video conditioned on a language caption into a model that generates video and actions conditioned on a running visual history, with the language serving as a persistent goal specification rather than a clip-level annotation. This is a more natural fit for closed-loop control, where the policy must continuously respond to the current state, and it has the additional benefit of 3–4× faster inference through KV-caching (Section 5.2).

The significance of this choice extends beyond the architecture. It reveals a mismatch between standard video generation evaluation paradigms and robot control requirements that prior WAM literature did not surface. Video generation models are typically trained and evaluated on generating complete clips from initial frames and text prompts — an open-loop, forward-prediction task. Robot control requires the model to generate from arbitrary mid-task states in a closed loop, where the language describes the overall goal but the current visual context may show a state partway through execution. The autoregressive formulation is better aligned with this requirement because it separates the persistent goal (text) from the transient state (visual context), allowing the model to attend to both without forcing temporal alignment between them. This insight — that the architectural choice between autoregressive and bidirectional generation is not merely an efficiency trade-off but addresses a deeper misalignment between the pretraining task and the control task — is a contribution to the emerging design principles for WAMs.

Innovation 4: DreamZero-Flash and the Decoupling of Video and Action Denoising as a General Strategy for Diffusion-Based Policies

DreamZero-Flash — the decoupled noise scheduling approach that enables single-step action denoising while video remains partially noisy — is more than an inference speed optimization. It is a training strategy that exposes a mismatch between standard diffusion training and the requirements of diffusion-based policies, and it provides a general template for how to close that gap.

Standard diffusion models (and flow matching variants) train with a shared timestep across all output modalities: video tokens and action tokens are denoised at the same rate. At inference, when denoising steps are reduced for latency reasons, the model must predict clean actions from video that is still partially noisy — a configuration it was never trained on. Naively reducing steps degrades action quality because the residual visual noise propagates into action predictions, even though the actions themselves could be denoised much faster if they were not coupled to video. DreamZero-Flash addresses this by changing the training distribution rather than the inference procedure: during training, video timesteps are biased toward high-noise states (Beta(7,1) distribution, yielding 𝔼[𝑡ᵛⁱᵈᵉᵒ] = 0.125), while action timesteps remain uniform. This exposes the model to configurations where clean actions must be predicted from heavily corrupted video, directly matching the few-step inference regime.

What makes this distinctive is the reversal of the standard approach to inference acceleration. Most prior work on fast diffusion inference (model distillation, progressive distillation, consistency models) modifies the inference process or the model itself to reduce denoising steps while keeping the training distribution fixed. DreamZero-Flash keeps the inference process simple (single-step denoising with the same model) and instead modifies the training distribution to cover the inference regime. This is a training-time solution to an inference-time problem, and it is effective because it exploits the specific structure of WAMs: the video tokens are never executed (they are discarded after the KV-cache update), so their quality matters only insofar as it affects action prediction. If actions can learn to be robust to noisy video, the video denoising can be short-circuited without downstream consequence.

Table 3 validates this: standard DreamZero drops from 83% to 52% task progress when going from 4 to 1 denoising steps, while DreamZero-Flash at 1 step recovers to 74% — reclaiming 71% of the lost performance while being 2.33× faster. The paper frames this as one possible instantiation of a broader principle: the decoupling of noise schedules can be tuned (through the Beta distribution parameters) to trade off video quality and action quality at different inference budgets. This opens a design space for diffusion-based policies that has not been systematically explored — alternative schedules, per-modality step budgets, or even training objectives that explicitly optimize for action prediction under visual uncertainty — and positions DreamZero-Flash as an early demonstration of that principle rather than a final solution.

Innovation 5: Empirical Discovery of a WAM-Specific Scaling Frontier — Video Quality, Not Model Capacity, Is the Policy Bottleneck

Perhaps the most consequential empirical finding in the paper is not a specific performance number but the emergent evidence that WAM performance is bounded by video generation quality rather than by model capacity or data volume in the conventional sense. This finding manifests across multiple experiments and constitutes a diagnostic insight that distinguishes WAMs from the broader class of robot learning approaches.

The evidence comes from three converging sources. First, the model scaling ablation (Table 4) shows that increasing the video backbone from 5B to 14B parameters yields a large performance jump (21% → 50%) for WAMs, while scaling a VLA backbone across the same range yields zero improvement (0% → 0%). The 5B WAM's failures are characterized as visual hallucinations that propagate to erroneous actions — the model predicts wrong video, and the policy faithfully executes that wrong plan. This suggests that the 5B model's bottleneck is video generation fidelity, not inverse-dynamics learning capacity. Second, the failure case analysis (Appendix H, Figure 16) shows qualitatively that DreamZero failures on both AgiBot and Franka arise from video prediction errors — the robot physically does exactly what the generated video shows, but the video plan itself is wrong (picking up bread before opening the oven, passing a marker between arms instead of drawing). Third, the diverse-vs-repetitive data ablation (Table 4) shows that diversity — which plausibly improves the IDM's robustness by providing varied visual contexts — yields a large improvement over repetitive data at matched hours (50% vs. 33%), but both are trained on the same video backbone, suggesting that the IDM's quality is the limiting factor once video generation is adequate.

Together, these findings paint a picture where WAM performance is determined by the product of video generation quality and inverse-dynamics robustness, and improvements to either factor yield gains. The paper's scaling evidence suggests that current video generation models (at the 14B scale) have crossed a threshold where their predictions are good enough for many manipulation tasks, but further improvements — either through larger backbones, better pretraining, or domain-specific fine-tuning — should directly translate to better policies. This is a different scaling relationship from VLAs, where more model capacity often yields diminishing returns because the pretrained knowledge repository (static vision–language) is mismatched to the physical control task. The implication is that investment in video generation model quality is investment in robot policy capability — a claim that, if validated at larger scales, could redirect significant research effort from policy architecture design toward video model development. The paper explicitly endorses this view in Section 6 and labels it as future work on "Scaling Laws of WAMs."

5. Experimental Analysis

Evaluation Methodology

Dataset. The primary real-robot dataset is an in-house collection of ~500 hours of teleoperation data on the AgiBot G1 mobile bimanual manipulator, spanning 22 unique environments (homes, restaurants, supermarkets, coffee shops, offices, etc.) across 7.2K episodes averaging 4.4 minutes and 42 subtasks each (Section 4.1, Figure 6). A secondary real-robot dataset is DROID (Khazatsky et al., 2024), a publicly available heterogeneous single-arm Franka manipulation dataset, used for reproducibility validation. Both train–test splits evaluate on unseen environments and unseen objects by design, since pretraining data were collected in different physical locations from evaluation sites (Section 4.1).
Base model(s). DreamZero initializes from Wan2.1-I2V-14B-480P (Team Wan, 2025), a 14B image-to-video diffusion transformer trained on web-scale video data. The backbone is pretrained on diverse internet video and is chosen to inherit rich spatiotemporal priors. Ablation studies additionally evaluate Wan2.1-I2V-5B-480P, a 5B variant, to test model scale effects (Section 5.2). The VAE, text encoder, and image encoder are frozen during robot training; all DiT blocks and action-related modules are updated.
Metrics. The primary metric is average task progress — a continuous score from 0 to 1 (or 0 to 100%) measuring partial task completion. For AgiBot seen tasks (10 tasks, 8 rollouts per task across 4 robots, 80 rollouts total), task progress is defined per task category: pick-and-place success, folding stages completed (0–5 for shirt folding), fruits packed (0–10 for fruit packing), and items cleared (for table bussing). For AgiBot unseen tasks (10 tasks, identical rollout structure), progress captures partial execution (e.g., grasping an object without completing the full motion). DROID evaluation uses 20 seen and 20 unseen tasks, 2 rollouts each, scored 0–1.0 based on partial completion with fixed object positions across checkpoints. Post-training evaluation (Section 4.2) adds task-specific progress metrics: folding stages (shirt folding), fruits packed (fruit packing), and items cleared (table bussing), across 10 rollouts per task.
Baselines. Two state-of-the-art VLAs serve as comparison points: GR00T N1.6 (Bjorck et al., 2025) and π₀.₅ (Physical Intelligence, 2025). Each baseline is evaluated in two initialization settings: (1) from-scratch — using pretrained VLM weights but no prior robot data, trained on exactly the same data as DreamZero (fair comparison of pretraining modality); (2) from-pretrained — using official checkpoints pretrained on thousands of hours of cross-embodiment robot data, then continually trained on DreamZero's data (stronger baseline that tests whether WAMs can outperform massive robot-data-pretrained VLAs). Training compute is matched via equal total batch size (128) and gradient steps (100K for pretraining, 50K for ablations). For DROID evaluation, the paper additionally compares against publicly released π₀.₅-DROID and an internally trained GR00T N1.6-DROID checkpoint.
Generation budget / compute accounting. The paper does not use FLOPs-matched comparisons between WAMs and VLAs in the main results — all methods are trained at matched data scale (500 hours) and matched training steps (100K). Test-time compute differences between DreamZero inference (diffusion denoising at 7Hz) and VLA inference (single forward pass) are not used to handicap either method; the evaluation measures policy quality, not inference speed. Ablation models in Section 5.2 are trained at reduced compute (50K steps, batch size 32) due to computational constraints, and are evaluated on a subset (PnP Easy tasks) for consistent comparison.
Cross-validation / statistical protocol. No cross-validation is applied to strategy selection (the paper does not optimize hyperparameters per difficulty bin as in the reference example paper). Instead, evaluation follows a fixed protocol: each model checkpoint is evaluated out-of-the-box after pretraining, on unseen environments and unseen objects, with 8 rollouts per task across 4 robots (AgiBot) or 2 rollouts per task (DROID). For post-training evaluation, an image overlay is applied to the initial scene to reduce variance across rollouts (following Barreiros et al., 2025). Standard error is reported for key results (Tables 2, 3, 4); for Figures 8, 9, 10, error bars are present but exact confidence intervals are not numerically specified.

Main Quantitative Results

Q1: Do WAMs Learn Better from Diverse, Non-Repetitive Data?

Headline result: DreamZero achieves 62.2% average task progress on seen AgiBot tasks in zero-shot environments — over 2× the best pretrained VLA baseline (27.4%) — while from-scratch VLAs score near zero across all categories. Figure 8 breaks this down by task category:

PnP Easy (pick-and-place fruit, wipe mess, take out fruit from bag): DreamZero achieves approximately 75–80% task progress. Pretrained GR00T N1.6 and π₀.₅ achieve roughly 45–55%. From-scratch VLAs are near zero.
PnP Hard (pick-and-place fork/spoon, put pen in holder, put cup on coaster, stack bowls/cups): DreamZero reaches approximately 55–65%. Pretrained baselines achieve roughly 15–25%.
Contact-Rich Manipulation (fold shirts, fold shorts, stack clothes): DreamZero reaches approximately 40–50%. Pretrained baselines achieve roughly 5–15%.

On DROID-Franka (Figure 8, right panel), DreamZero achieves approximately 42% task progress on seen tasks, outperforming pretrained GR00T N1.6 (~32%) and π₀.₅ (~28%).

DreamZero's dominant failure mode is video generation errors rather than action extraction errors: the policy faithfully executes whatever visual plan the video predicts, and when the video plan is wrong (e.g., incorrect object selection, wrong motion sequence), the robot executes that wrong plan correctly (Appendix H, Figure 16). This is a diagnostic insight: the bottleneck is world model quality (video prediction), not inverse-dynamics learning.

Q2: Do WAMs Generalize to Unseen Tasks?

Headline result: DreamZero achieves 39.5% average task progress on 10 AgiBot tasks entirely absent from pretraining, while pretrained VLAs achieve 16.3% and from-scratch VLAs achieve <1%. Figure 9 provides per-task detail:

Remove Hat from Mannequin: 85.7% (the strongest unseen task result).
Shake Hands: 59.2%.
Painting (with brush on notebook/paper): approximately 40–50%.
Ironing (shirts/shorts): approximately 30–40%.
Untie Shoelaces: approximately 30–40%.
Cube Stacking: approximately 25–35%.
Pulling Cart: approximately 20–30%.

The paper notes a qualitative difference in failure modes: pretrained VLAs often reach toward objects and attempt grasping regardless of instruction, "suggesting they overfit to dominant training behaviors (e.g., pick-and-place) rather than understanding novel task semantics" (Section 5.1). DreamZero, by contrast, performs visual planning for the unseen task — the generated video shows the intended novel motion, and the robot executes it. The paper also reports free-form testing on 100+ additional tasks including "Pop the balloon" and "Press elevator button" (Section 5.1, Q2), with results visible at the project website.

On DROID-Franka (Figure 9, right panel), DreamZero achieves 49% task progress and 22.5% success rate on unseen tasks, compared to 31% / 12.5% for GR00T N1.6 and 33% / 7.5% for π₀.₅.

Q3: Do WAMs Improve Post-Training Performance?

Headline result: DreamZero matches or outperforms VLA baselines across three post-training tasks while retaining environment generalization — the same gap seen in pretraining persists after fine-tuning. Figure 10 reports:

Shirt folding (5 sequential stages): DreamZero achieves approximately 70–75% task progress. Pretrained baselines achieve roughly 60–75% — comparable, with DreamZero slightly ahead of π₀.₅ and roughly tied with GR00T N1.6.
Fruit packing (pack 10 fruits from table into bag): DreamZero achieves approximately 70–75%, substantially outperforming all baselines (pretrained VLAs at ~40–55%, from-scratch VLAs near zero). The paper attributes this to fruit packing requiring diverse grasping and placement strategies that benefit from DreamZero's visual planning prior.
Table bussing (clear 5 trash items + 5 dishware items): DreamZero achieves approximately 65–70%. Pretrained baselines achieve roughly 55–70%, again comparable with DreamZero at parity or slightly ahead.

From-scratch VLAs consistently fail across all three tasks, often failing to grasp target objects due to distribution shift between training and evaluation environments (different table heights, object placements, lighting). The critical finding is that pretrained VLAs — despite having been pretrained on massive multi-embodiment robot data — do not consistently outperform DreamZero after task-specific fine-tuning, and on fruit packing they substantially underperform. This supports the paper's claim that WAM generalization is retained after post-training, not washed out by task-specific specialization.

Q4: Do WAMs Enable Strong Cross-Embodiment Transfer to Unseen Tasks?

Headline result: Video-only demonstrations from other robots (20 minutes, YAM) or humans (12 minutes, egocentric) yield a relative improvement of over 42% on unseen task performance — from 38.3% (baseline DreamZero) to 55.4% (robot-to-robot) and 54.3% (human-to-robot). Table 2 reports these numbers with standard error:

DreamZero baseline (no transfer): 38.3% ± 7.6%.
DreamZero + Human2Robot Transfer: 54.3% ± 10.4% (a 42% relative improvement over baseline).
DreamZero + Robot2Robot Transfer: 55.4% ± 9.5% (a 45% relative improvement).

These results are from 9 unseen tasks (the 10th, "Pulling Cart," excluded because teleoperation was infeasible with the YAM setup). The transfer data consists of only 72 multi-view trajectories per setting (8 demonstrations per task, 20 minutes for YAM, 12 minutes for human egocentric video), co-trained from the DreamZero-AgiBot checkpoint at a 1:1 mix with pretraining data for 10K steps (a small fraction of the 100K-step pretraining budget). The video-only nature of the transfer data is critical: the cross-embodiment trajectories contain no action labels — the WAM uses them purely to strengthen the world model's visual understanding of task dynamics, not to learn embodiment-specific motor commands.

The paper notes that robot-to-robot transfer yields slightly higher gains than human-to-robot, likely due to the narrower embodiment gap (YAM and AgiBot are both bimanual parallel grippers, while humans have different morphology and dynamic egocentric viewpoints). But the fact that human video — with fundamentally different kinematics, camera motion, and body morphology — transfers meaningfully at all is the surprising result. The paper frames this as "an early signal that cross-embodiment visual experience transfers meaningfully" and suggests that scaling up to large-scale egocentric human video datasets (Ego4D, Action100M) could yield substantially larger gains.

Q5: Do WAMs Enable Few-Shot New Embodiment Adaptation?

Headline result: Post-training the DreamZero-AgiBot checkpoint on only 30 minutes of play data (55 trajectories across 11 tasks) from an entirely new YAM robot yields a policy that retains strong language following and generalizes to novel objects never seen during the 30 minutes of adaptation. Figure 12 illustrates qualitative results on pick-and-place variants with novel objects (pumpkins, teddy bears, pens, cup noodles, paper bags).

The paper reports no quantitative task progress scores for this experiment — the evaluation is qualitative and focused on demonstrating that the adapted policy maintains language following (correctly identifying and manipulating objects specified in the instruction) and video–action alignment (tight correspondence between generated video and executed motions), despite the extremely limited exposure to the new embodiment. The paper hypothesizes two mechanisms enabling this efficiency: (1) visual similarity between AgiBot G1 and YAM (both bimanual parallel grippers), and (2) the implicit IDM formulation requiring the model only to learn a new visual-future-to-motor-command mapping while inheriting physical dynamics understanding from the pretrained video backbone.

Failures are reported as primarily stemming from video prediction errors rather than action extraction — consistent with the broader finding that video generation quality is the policy bottleneck. The paper acknowledges that only 11 short, global language annotations were used per task, and that diversifying language conditioning could further improve transfer.

Q6: Does DreamZero-Flash Maintain Performance with Fewer Denoising Steps?

Headline result: DreamZero-Flash with 1 denoising step achieves 74% ± 10.1% task progress on table bussing, compared to 83% ± 6.1% for standard DreamZero at 4 steps — recovering 89% of the 4-step performance while being 2.33× faster (150ms vs. 350ms per chunk). Standard DreamZero at 1 step drops to 52% ± 10.2%, confirming that decoupled noise scheduling is necessary for single-step inference. Table 3 reports these results with standard error.

The evaluation is on a single task (table bussing) rather than the full suite, representing a preliminary validation of the Flash approach. The 9 percentage point gap between DreamZero-Flash at 1 step and standard DreamZero at 4 steps suggests that while Flash recovers most of the performance, there remains a trade-off — the paper does not explore whether 2 or 3 steps with Flash could close the remaining gap while still being faster than 4-step standard DreamZero.

Ablation Studies and Robustness Checks

All ablation models are trained with 50K steps and batch size 32 (reduced from the full 100K/128 due to computational constraints) and evaluated on PnP Easy tasks for consistent comparison (Table 4).

Data diversity (Q1): DreamZero trained on 500 hours of diverse data achieves 50% ± 6.3% task progress vs. 33% ± 4.2% for 500 hours of repetitive data (70 tasks with many repeated demonstrations, similar object positions/configurations). The 1.5× improvement on even simple pick-and-place tasks supports the claim that data diversity is a dominating factor in WAM performance, not merely helpful. The paper hypothesizes this reflects IDM learning dynamics: a robust inverse-dynamics model requires diverse state–action correspondences across varied visual contexts, which repetitive data inherently lacks.
Model scale (Q2): DreamZero 14B achieves 50% ± 6.3% vs. 5B at 21% ± 4.2%. The 5B model's failures are characterized as visual hallucinations that propagate to erroneous actions — a diagnostic that the bottleneck is video generation quality, not IDM capacity. In contrast, VLAs scaled from 5B to 14B backbone parameters yield 0% task progress at both sizes, "often hovering near objects without making contact." This is the paper's strongest evidence that WAMs and VLAs live on fundamentally different scaling curves: WAM performance improves with backbone size because larger video models produce better visual plans; VLA performance does not improve with backbone size because the bottleneck is the mismatched pretraining modality, not model capacity.
Autoregressive vs. bidirectional architecture (Q3): Both architectures achieve 50% task progress at 14B (50% ± 6.3% for AR, 50% ± 14.4% for BD). The standard error is substantially higher for bidirectional (14.4% vs. 6.3%), suggesting more variance in bidirectional performance. The paper reports that autoregressive generation produces "substantially smoother motions" due to backpropagation through entire action sequences, and that AR inference is 3–4× faster due to KV-caching. These qualitative advantages — smoother motion and faster inference — are reported without quantitative smoothness metrics.
LoRA vs. full fine-tuning: The paper reports (Section 4.1, footnote 7) that LoRA fine-tuning "led to suboptimal results" compared to full-parameter training of DiT blocks, but provides no numerical comparison. This is a relevant negative result for practitioners considering parameter-efficient adaptation of video diffusion backbones for WAMs.
Oracle vs. predicted difficulty bins: Not applicable to this paper (DreamZero does not use difficulty-conditioned strategy selection).

Critical Assessment

Claim 1: "Over 2× improvement in zero-shot generalization to unseen tasks and environments compared to state-of-the-art VLAs."

What was tested: The 2× claim is supported on the AgiBot seen-task benchmark (62.2% DreamZero vs. 27.4% best pretrained VLA, Figure 8) and unseen-task benchmark (39.5% vs. 16.3%, Figure 9). The DROID results show smaller but still substantial margins (49% vs. 33% for unseen tasks, Figure 9 right).

What clouds the claim: The "2×" figure uses the best pretrained VLA as the denominator — but the from-scratch VLAs score near zero, and even pretrained VLAs achieve only 27.4% after continued training on DreamZero's data. The more striking finding is arguably that from-scratch VLAs completely fail on diverse data (Figure 8), which supports the paper's claim about data diversity being toxic for VLAs but is not captured by the 2× framing. Additionally, the cross-embodiment pretraining of the VLA baselines (GR00T N1.6, π₀.₅) is on thousands of hours of repetitive robot data from many embodiments — it is possible that this pretraining is partially mismatched to the diverse AgiBot data, making the "pretrained" baseline weaker than an idealized VLA pretrained on equally diverse data. The paper does not control for data distribution in the VLA pretraining phase.

What would strengthen the claim: A third baseline — a VLA pretrained from scratch on the same diverse AgiBot data but with more training steps or a larger VLM backbone — would disambiguate whether the VLA failure is due to data diversity per se or to insufficient training on that specific data distribution. Additionally, the 2× claim is on task progress, not success rate; success rate (binary completion of the full task) is likely lower for both methods, and the gap might differ.

Claim 2: "Effective learning from diverse, non-repetitive robot data without relying on repetitive demonstrations."

What was tested: The data diversity ablation (Table 4) shows that at matched 500 hours, diverse data yields 50% vs. 33% for repetitive data. The from-scratch VLA failure on the same diverse data (Figure 8, 0% task progress) demonstrates that VLAs cannot learn from this data distribution at all, while DreamZero can.

What clouds the claim: The diverse-vs-repetitive comparison in Table 4 uses 50K-step ablations on a subset of tasks (PnP Easy), not the full 100K models on the full task suite. The 33% → 50% gap may differ at full training scale or on harder tasks. More critically, the "repetitive" condition (70 tasks with many repetitions, similar object positions) is compared to the "diverse" condition (many tasks with few repetitions each) — but the paper does not report whether the set of tasks is matched between conditions. If the diverse condition simply covers more task types, the fair comparison would be: same tasks, but diverse vs. repetitive object arrangements, lighting, etc. The paper's description ("70 tasks with many repeated demonstrations per task using similar object positions and configurations") suggests the repetitive condition has both fewer tasks AND less intra-task diversity, confounding the two variables.

What would strengthen the claim: An ablation that holds the set of tasks constant and varies only the intra-task diversity (number of distinct object positions, backgrounds, lighting conditions per task). Or an ablation that holds total data hours constant and varies the number of tasks from 10 to 100, measuring generalization to held-out tasks.

Claim 3: "Cross-embodiment transfer: video-only data yields over 42% relative improvement with just 10–20 minutes of data."

What was tested: Table 2 shows baseline DreamZero at 38.3% on 9 unseen tasks, improving to 54.3% (human) and 55.4% (robot-to-robot) with video-only co-training. The relative improvements are indeed ~42% and ~45%.

What clouds the claim: The baseline 38.3% is from the pretrained DreamZero model BEFORE co-training; the transfer models receive an additional 10K training steps on a 1:1 mix of the original data plus the new video-only data. The improvement could be partially attributable to simply training longer on more data, not specifically to cross-embodiment transfer. The paper does not include an ablation where DreamZero is trained for 10K additional steps on only the original AgiBot data (without cross-embodiment video), which would control for the effect of extended training. Additionally, the 9-task evaluation set is small (8 rollouts per task = 72 total rollouts, with 4 robots providing 2 rollouts each per task), and the standard errors are large (±7.6–10.4%), making the 16–17 percentage point gap only ~1.5 standard errors above baseline. More rollouts would be needed for statistical confidence.

What would strengthen the claim: An extended-training control (10K steps on original data only), evaluation on more unseen tasks, and reporting of per-task results to identify which specific tasks benefit most from transfer vs. which show no improvement.

Claim 4: "Few-shot embodiment adaptation: adapts to an entirely new robot with only 30 minutes of play data, retaining zero-shot generalization."

What was tested: Qualitative evaluation on the YAM robot after 30 minutes of play data (Figure 12), showing the policy picking up novel objects (pumpkins, teddy bears, etc.) in response to language instructions.

What clouds the claim: This is the weakest empirical claim in the paper. There are NO quantitative results for the few-shot adaptation experiment — no task progress scores, no success rates, no comparison to any baseline (e.g., a VLA trained on the same 30 minutes). The claim of "retaining zero-shot generalization" cannot be evaluated without numbers. The paper's argument that the adaptation is "few-shot" (30 minutes, 55 trajectories) is meaningful only in comparison to how much data alternative methods would require for equivalent performance — and that comparison is absent. Additionally, the YAM and AgiBot G1 are both bimanual parallel gripper robots with similar visual appearances; the transfer may not generalize to more morphologically distinct embodiments (e.g., single-arm, dexterous hand, mobile manipulator with different kinematics).

What would strengthen the claim: Quantitative evaluation of the adapted policy on a set of standardized tasks with and without the 30-minute adaptation, compared to a VLA baseline adapted on the same data. Evaluation on more morphologically diverse target embodiments to test the limits of the approach.

General weaknesses in experimental design:

Single benchmark paradigm (real-robot evaluation only): All AgiBot results are from custom evaluation protocols with task progress as the metric. There is no standardized benchmark comparison (e.g., CALVIN, RLBench, LIBERO) that would enable comparison to the broader robot learning literature beyond the two VLA baselines. The paper mentions "non-trivial performance on Genie Sim 3.0" (footnote 1) but provides no numbers, and the DROID PolaRiS evaluation is noted but not reported with scores in the main text.
No combination of search and revisions: Not applicable (this paper does not use search or iterative revision mechanisms in the reference example's sense).
All comparisons are at matched data scale but not matched inference compute: DreamZero inference requires iterative denoising on 2 GB200 GPUs; VLAs require a single forward pass on (presumably) less hardware. The paper does not account for inference-time compute differences, making the policy quality comparison favorable to DreamZero if inference cost matters.
Standard error only for some results: Figures 8, 9, 10 show error bars but their exact values are not tabulated. The cross-embodiment transfer results (Table 2) are the only main results with numerically reported standard errors, and those errors are substantial (±7.6–10.4%). For the core 2× claim on seen tasks (62.2% vs. 27.4%), no standard error is provided.
Ablation models trained at half the steps and quarter the batch size: The 50K-step, batch-size-32 ablations in Table 4 may not reflect full-scale behavior. The 5B-vs-14B gap (21% → 50%) might narrow at 100K steps if smaller models converge more slowly (though the paper argues this is unlikely given the hallucination-dominant failure mode).
No systematic difficulty-conditioned analysis: Unlike the reference example paper's careful difficulty binning and strategy selection per bin, DreamZero reports aggregate task progress without analyzing which types of tasks (by complexity, required precision, horizon length) benefit most from the WAM formulation. The categorization into PnP-Easy, PnP-Hard, and Contact-Rich (Figure 8) is a step in this direction but lacks per-task breakdown and statistical analysis of difficulty effects.

6. Limitations and Trade-offs

The Cost of Difficulty Estimation Is Not Accounted For — and There Is No Difficulty Estimation

This is a structural omission, not a minor accounting oversight. The entire DreamZero policy operates with a single set of inference hyperparameters (fixed denoising steps, fixed chunk size, deterministic noise schedule) regardless of task difficulty, environment novelty, or required precision. Unlike the reference example paper — which conditions its allocation strategy on prompt difficulty and acknowledges the cost of difficulty estimation as a separate budget item — DreamZero never estimates task difficulty at all. The consequence is that every task, from "pick up banana and place on blue plate" (PnP Easy, 75–80% task progress, Figure 8) to "untie shoelaces" (30–40%, Figure 9) to "cube stacking" (25–35%), receives identical inference compute: 4 denoising steps (or 1 with Flash), 1.6-second action chunks, 6.6 seconds of visual context, executed at 7Hz. Easy tasks are likely wildly over-computed; hard tasks may be under-computed or fundamentally unsolvable within the fixed budget; the system has no mechanism to distinguish between these cases.

The paper provides indirect evidence for this problem. DreamZero-Flash (Table 3) reduces denoising steps from 4 to 1 and loses 9 percentage points on table bussing (83% → 74%) while being 2.33× faster. This suggests that on some tasks — table bussing requires clearing 10 items from a cluttered table, a relatively complex motion — 4 denoising steps genuinely help, and reducing to 1 step degrades performance. On simpler tasks (e.g., single-object pick-and-place), 1 step might be sufficient, but the current architecture cannot adapt per-task because it has no difficulty signal. Similarly, the autoregressive visual context is fixed at 6.6 seconds (4 chunks × 2 frames × 1.6s/chunk). For short-horizon tasks (grasping a single object), this context is excessive; for long-horizon tasks requiring memory (the paper explicitly notes in Section 3.1, footnote 2: "we do not explicitly evaluate or post-train DreamZero on tasks that can only succeed with memory"), it may be insufficient.

The paper does not address this limitation — difficulty estimation, adaptive compute allocation, and variable-horizon context are not discussed in the architecture, training, or inference sections. The system is a fixed-cost policy for all tasks, and the reported efficiency gains (38× speedup, 7Hz control) apply uniformly to all problem instances. A compute-optimal version of DreamZero — one that could scale denoising steps, context length, or even model capacity per-task — would likely achieve better accuracy-per-FLOP tradeoffs, but no framework for this exists in the current work. The reference example paper's compute-optimal scaling analysis (Section 3.4, prior analysis) demonstrates that unified allocation is deeply suboptimal, often by factors of 4× or more; DreamZero's fixed-budget design likely leaves similar efficiency on the table.

The 38× Speedup Is Achieved Only on GB200 Hardware with NVFP4 Quantization — Which Is Not Generally Available

Table 1 makes it clear: the headline 38× inference speedup (5.7s → 150ms) is achieved on GB200 GPUs with NVFP4 quantization (Blackwell architecture), and includes DreamZero-Flash. On H100 GPUs (the most widely available datacenter GPU at the time of writing), the cumulative speedup is 9.6× without quantization (NVFP4 is "not applicable to that hardware," per Table 1). With DreamZero-Flash but without quantization on H100, the speedup would be approximately 9.6 × 2.33 ≈ 22×, yielding roughly 260ms per chunk — still usable (3.8 Hz) but nearly half the headline inference rate. Without Flash AND without quantization on H100, inference takes roughly 5.7s / 9.6 ≈ 590ms, or about 1.7 Hz — which the paper itself might characterize as marginal for smooth control (the target is ~200ms to ensure sufficient overlap with the 1.6s execution window, Section 3.2.2).

The consequence is that the full 38× speedup and 7Hz control frequency are conditioned on access to hardware that was announced but not widely deployed at the time of publication. A practitioner attempting to reproduce DreamZero on H100 GPUs (or — far more commonly — on consumer GPUs such as RTX 4090s, which lack NVFP4 and have less memory bandwidth) will achieve substantially lower inference rates. The paper also requires 2 GPUs for CFG parallelism (Section 3.2.3: "We distribute these across two GPUs"), meaning the minimum deployment configuration is 2 GPUs, not 1. For the GB200 configuration, these are 2 GB200s; for H100, 2 H100s. The paper does not report single-GPU latency, so the cost floor for any deployment is at least doubled.

The paper does not attempt to mitigate this hardware dependency. No latency numbers are reported for single-GPU, non-quantized, or consumer-grade configurations. The Discussion (Section 6) acknowledges the broader issue: "DreamZero is still computationally expensive due to the large parameter size and the iterative denoising nature of video models" and notes that "if smaller video backbone models also have strong generalization capability, WAMs could potentially be utilized as a real-time System 1 model on a lightweight edge device." But this is aspirational — no 5B-model latency numbers are provided, and the 5B model's generalization is substantially worse (21% vs. 50% task progress, Table 4), so the smaller-model tradeoff is not quantified. The headline "real-time closed-loop control at 7Hz" claim in the abstract should be understood as applying to a specific, high-end hardware configuration that is not representative of typical robotics lab or deployment hardware in early 2026.

Cross-Embodiment Transfer Is Evaluated on Only 9 Tasks with No Extended-Training Control, and the Few-Shot Adaptation Claim Has No Quantitative Baseline

The cross-embodiment transfer results (Table 2) and few-shot adaptation experiment (Figure 12, Q5) represent some of the paper's most forward-looking claims, but their empirical support is notably weaker than the core pretraining and post-training evaluations. Three specific issues limit the strength of these claims.

First, no extended-training control for cross-embodiment transfer. The transfer experiments co-train the DreamZero-AgiBot checkpoint on a 1:1 mix of original AgiBot data plus new video-only cross-embodiment data for 10K additional steps. The improvement from 38.3% to 54.3–55.4% is attributed to the cross-embodiment visual experience. However, the paper does not include a control condition where DreamZero is trained for 10K additional steps on only the original AgiBot data — without cross-embodiment video — and evaluated on the same 9 tasks. It is possible that simply training longer improves performance, and that some fraction of the 16–17 percentage point gain is attributable to extended optimization rather than transfer. The paper does not report training curves or training loss for the co-training phase, so there is no evidence that the original model had converged and that the gain is specifically from the new data.

Second, small evaluation set with large standard errors. The transfer evaluation covers 9 unseen tasks (8 rollouts per task = 72 rollouts total, with 4 robots providing 2 rollouts each per task). The standard errors are ±7.6% (baseline), ±10.4% (human transfer), and ±9.5% (robot transfer). The 16–17 percentage point improvement is approximately 1.5–2.2 standard errors above baseline depending on the comparison — meaningful but not overwhelmingly so. A per-task breakdown is not provided, so it is unknown whether the improvement comes from a few tasks with large gains and others with zero, or from consistent small improvements across all tasks. The former case would suggest that cross-embodiment transfer helps only when the target task's visual dynamics are well-represented in the source embodiment's videos; the latter would suggest a more general regularization effect. The paper does not distinguish between these mechanisms.

Third, the few-shot adaptation experiment (Q5) has no quantitative results at all. Section 5.1 describes this as demonstrating "very efficient cross-embodiment transfer" with "strong language following ability" and "tight video-action alignment," but no task progress scores, success rates, or any numerical metric are reported. There is no comparison to a VLA baseline trained on the same 30 minutes of YAM play data, so the claim that this level of adaptation efficiency is distinctive to WAMs cannot be evaluated. The paper's own hypothesis — that the efficiency arises from (1) visual similarity of the two embodiments and (2) sample-efficient IDM learning — is speculative without a baseline showing that alternative methods require more data for equivalent performance. The absence of quantitative evaluation for what the paper frames as a core contribution ("few-shot embodiment adaptation") is a significant gap.

The paper does not acknowledge these limitations in the Discussion. The cross-embodiment section (Section 5.1, Q4–Q5) is presented as a positive result without caveats about sample size, control conditions, or missing quantitative baselines. For a practitioner considering whether WAMs enable practical embodiment transfer, the current evidence is suggestive but insufficient for deployment decisions.

All Evaluation Is on Two Bimanual Parallel-Gripper Embodiments from the Same Rough Morphological Family, with No Single-Arm, Dexterous-Hand, or Mobile-Only Manipulation Tasks

The paper's two primary embodiments — AgiBot G1 (Figure 7) and YAM (Figure 12) — are both bimanual mobile manipulators with parallel-jaw grippers. Both have similar kinematic structures (two arms, torso lift, mobile base), operate in similar tabletop manipulation settings, and present similar visual appearances (robot arms in camera view). The Franka DROID evaluation adds a single-arm parallel-gripper setting, but the main cross-embodiment and generalization claims are built on the AgiBot and YAM results. The paper does not evaluate on: single-arm tasks requiring fine dexterity (e.g., key insertion, screwdriver use, pipetting), dexterous multi-fingered hands, mobile-only navigation without manipulation, whole-body loco-manipulation, or any embodiment where the visual appearance differs substantially from a humanoid-torso-plus-arms configuration.

The consequence is that the paper's generalization claims — particularly cross-embodiment transfer and few-shot adaptation — may be specific to embodiments within a narrow morphological envelope. The paper's own hypothesis about embodiment factors (Section 6, "Embodiment Design for WAMs") acknowledges this tension explicitly:

"We hypothesize two key factors will shape the best robot embodiments for future WAM development: (1) Degrees of freedom: Higher-DOF robots will require more play data to learn an accurate implicit IDM, as the mapping from visual futures to motor commands grows combinatorially with kinematic complexity... (2) Human similarity: Embodiments that more closely resemble humans — particularly humanoids with dexterous manipulation capabilities — may transfer more efficiently despite higher DOF"

This is an explicit acknowledgment that the current results do not cover higher-DOF or morphologically distinct embodiments, but the paper provides no empirical evidence about where the boundary lies. The few-shot adaptation from AgiBot to YAM (both bimanual parallel grippers) succeeds with 30 minutes of data; the same adaptation to a dexterous 5-fingered hand or a single-arm robot with a suction gripper might require orders of magnitude more data or fail entirely. The human-to-robot transfer (Table 2) is a step toward testing morphological distance, but the 12 minutes of egocentric video is used for visual experience only (no action labels), so it tests the world model's ability to learn task dynamics from human video — not the IDM's ability to map human kinematics to robot kinematics.

The paper does not provide evidence about scaling with degrees of freedom, about the data requirements as a function of embodiment distance, or about failure modes on non-parallel-gripper or single-arm tasks. The DROID Franka evaluation is the only single-arm setting, and it does not include cross-embodiment transfer or few-shot adaptation — it is a pure pretraining comparison. For a practitioner considering deploying WAMs on a specific robot platform, the current evidence provides guidance only if that platform is a bimanual parallel-gripper manipulator with similar visual characteristics to AgiBot/YAM.

The Paper Does Not Ablate Whether Joint Video–Action Training Outperforms a Two-Stage Pipeline (Video Prediction → Separate IDM), Leaving the Core Architectural Claim Unvalidated

Equation 1 in Section 3.1 decomposes DreamZero's joint video–action objective into a video prediction model times an inverse-dynamics model. The paper argues that end-to-end joint training is superior: "We believe that this end-to-end design enables better video-action alignment through a deep integration between the two modalities" and "we train a single model end-to-end with joint prediction objective" rather than using two separate models. This claim — that sharing representations between video prediction and action prediction improves alignment — is central to the WAM concept, yet it is never tested empirically within the paper.

The obvious ablation — train a video-only DreamZero (predict video from context, no action output), then train a separate IDM on top of the frozen or fine-tuned video predictions, and compare to the joint model — is absent. Several prior works cited by the paper (UniPi by Du et al., 2023; GR-2 by Cheang et al., 2024; Dreamitate by Liang et al., 2024) use exactly this two-stage approach: generate video first, then extract actions from the generated video via a separately trained IDM. The paper discusses these works in Related Work (Section 2.2) but never compares DreamZero's joint training against a two-stage baseline using the same Wan2.1-I2V-14B backbone. The notation in Equation 1 even includes the two-stage decomposition explicitly:

"Instead of using two separate models (video prediction model and inverse dynamics model) to model the decomposed objective (Li et al., 2026; Pai et al., 2025), we train a single model end-to-end with joint prediction objective"

This sentence acknowledges the alternative and dismisses it without empirical justification. The paper's evidence for the benefit of joint training is indirect: the observation of "tight alignment between generated videos and real-world execution, even for suboptimal behaviors" (Section 5.1, Q1) and the failure case analysis showing that execution faithfully follows predicted video (Appendix H). But these observations would also hold for a two-stage pipeline where a separate IDM is trained to extract actions from the same video predictions — tight video–action alignment is a property of the IDM's training, not necessarily of joint representation learning.

Without this ablation, a practitioner cannot determine whether the computational cost of jointly denoising video and action (which requires coordinating two modalities in the same DiT backbone, sharing timesteps, and managing attention masking) is justified by alignment benefits over the simpler two-stage alternative. The two-stage approach would also enable video prediction and action extraction to run at different frequencies or with different compute budgets — an architectural flexibility that the joint approach forecloses. The paper's contribution would be substantially stronger with this ablation, or with an explicit argument for why end-to-end training is necessary that goes beyond the belief stated in Section 3.1.

Video Generation Quality Is the Policy Bottleneck, but the Paper Provides No Decomposition of Error Sources Between Video Model, IDM, and Closed-Loop Dynamics

The paper repeatedly asserts — and provides qualitative evidence in Appendix H (Figure 16) — that "most DreamZero failures stem from video generation errors rather than action prediction" (Section 5.1, Q1). This is a central diagnostic claim that shapes the paper's research agenda: if video quality is the bottleneck, then "improvements to the video backbone would directly translate to better WAM performance" (Section 5.1, Q1) and the scaling laws should focus on video model size and training (Section 6). However, the evidence for this claim is qualitative only — two cherry-picked failure examples in Appendix H — and no quantitative decomposition of failure sources is provided.

A rigorous decomposition would require measuring: (1) given perfect video predictions (ground-truth future frames), how accurately does the IDM extract correct actions? (2) given the actual video predictions, how often do prediction errors cause action errors that would not occur with perfect video? (3) in closed-loop execution, what fraction of errors arise from the policy (video → action) versus from external factors (unmodelled dynamics, perception noise, execution inaccuracies)? None of these measurements appear in the paper.

The consequence is that the claim "improving video generation is the path forward" — which the paper treats as a conclusion — is actually a hypothesis that could be wrong in specific ways. For example, if the IDM produces systematically incorrect actions even given perfect video (e.g., it consistently misjudges grasp force or approach angle for certain object geometries), then improving video quality would hit a ceiling where the IDM, not the video model, becomes the bottleneck. If closed-loop execution errors (e.g., object slipping, unexpected contact dynamics) dominate on contact-rich tasks, then neither video quality nor IDM quality would be the primary limitation — the system would need better dynamics modeling or reactive control. The paper's failure analysis in Appendix H shows one example where the video plan is wrong (picking up bread before opening oven) and the robot faithfully executes that wrong plan — this demonstrates video prediction as the error source in that instance, but does not establish it as the dominant source across the distribution.

The model scaling ablation (Table 4: 5B → 14B improves from 21% to 50%) provides indirect evidence that video quality matters, since the 5B model produces visual hallucinations and the 14B model does not (or does so less frequently). But this shows that video quality can be a bottleneck at the 5B scale — it does not show that video quality remains the bottleneck at the 14B scale, or that further scaling the video backbone would yield proportional policy improvements rather than revealing other bottlenecks (IDM accuracy, context length, proprioceptive state encoding). The paper does not discuss this ceiling effect or attempt to estimate how much headroom remains before the IDM becomes the limiting factor.

For practitioners deciding where to invest engineering effort, this ambiguity matters. If the IDM is already near-optimal at 14B and further video improvements would yield minimal policy gains, effort is better spent on action representation, smoothing, or task-specific fine-tuning. If video quality is indeed the binding constraint, effort should go toward larger backbones, better pretraining, or domain-specific video fine-tuning. The paper's current evidence does not distinguish between these cases.

7. Implications and Future Directions

How This Work Changes the Landscape

DreamZero does not introduce a fundamentally new model architecture — the autoregressive DiT backbone, the flow matching objective, and the VAE-based video encoding are all borrowed from prior work in video generation and robot learning. What it does introduce is a diagnostic reframing of the robot policy learning problem that changes which research questions are considered central, which experiments are considered informative, and which bottlenecks are considered binding. The magnitude is a significant reframing rather than a paradigm shift: the basic components are familiar, but their assembly and the empirical relationships they reveal point the field in a direction it was not systematically pursuing.

The core reframing is captured in Equation 1 and validated through the diversity, scale, and failure-mode analyses: policy learning is, for WAMs, fundamentally a problem of inverse-dynamics recovery from a pretrained world model, not a problem of direct state-to-action mapping. This matters because it redefines the relationship between pretraining and policy training. In the VLA paradigm, pretraining provides semantic knowledge (what objects are, what verbs mean) and policy training provides everything else (how to move, how to interact, how to adapt to visual variation). In the WAM paradigm, pretraining provides spatiotemporal knowledge (how objects move, how 3D scenes evolve, how contact changes visual appearance) and policy training only needs to connect predicted visual trajectories to a specific embodiment's motor commands. The paper's strongest evidence for this reframing is the scaling asymmetry: WAM performance improves dramatically with backbone size (21% → 50% from 5B to 14B) while VLA performance does not improve at all (0% at both sizes, Table 4), because the VLA's pretrained knowledge is of the wrong modality to help with the core policy learning challenge.

This reframing has immediate consequences for research prioritization. Video generation model quality becomes a first-class policy objective, not a separate research area. The paper's finding that failures primarily stem from video prediction errors rather than action extraction errors (Section 5.1, Q1; Appendix H) means that every improvement to the video backbone — better architectures, larger pretraining datasets, longer context windows, higher resolution, improved temporal consistency — is a direct investment in robot policy capability. This is a different relationship than the VLA world, where improvements to the VLM backbone (larger models, more diverse image–text pretraining) have shown diminishing returns for physical task performance. The paper explicitly endorses this direction in Section 6 by calling for "Scaling Laws of WAMs" and noting that "improving robotic capabilities reduces to improving video generation," but the implication is broader: the wall between the video generation research community and the robot learning community becomes porous. Advances in video models are advances in robot policies, and robot policy evaluation becomes a meaningful quality signal for video models.

The paper also reconciles a contradiction in the literature about data requirements for generalist robot policies. Prior VLAs demonstrated that large-scale robot data (thousands of hours across embodiments, as in GR00T N1 and π₀.₅) could produce policies with some generalization. But those datasets were predominantly repetitive — many demonstrations per task, collected to ensure consistent behavior cloning. DreamZero shows that with the right pretraining modality, data diversity matters more than repetition, and that from-scratch VLAs trained on diverse data collapse entirely (0% task progress, Figure 8) while WAMs thrive on the same data (62.2%, Figure 8). This resolves a tension between the VLA literature's implicit assumption that scale requires repetition and the intuitive desideratum that generalist policies should learn from broad experience. The resolution is that the pretraining modality determines which data distribution a policy architecture can absorb: VLAs need structured, repetitive data because they have no spatiotemporal prior to regularize against visual diversity; WAMs can absorb diverse, heterogeneous data because the video prediction prior already encodes how the world changes visually, and diversity only improves the IDM's robustness.

Less visibly but perhaps more consequentially, the paper shifts the Overton window for what constitutes an acceptable inference compute budget in robot learning. The 14B autoregressive DiT with iterative denoising and 2-GPU deployment is enormously more expensive per inference than any VLA (which requires a single forward pass). By demonstrating that this cost can be driven down to 150ms through systematic optimization — and by open-sourcing the model and code — the paper sets a precedent that diffusion-based policies at billion-parameter scale are practical, not just conceptually appealing. This lowers the barrier for other groups to adopt video diffusion backbones, knowing that the inference cost can be managed rather than being a dealbreaker. The 38× speedup is simultaneously a systems contribution and a signal to the community that the cost axis is solvable.

Finally, the paper introduces cross-embodiment transfer without action labels as a capability unique to the WAM formulation. While the empirical evidence is preliminary (Section 6 assesses its limitations), the demonstration that video-only data from humans and other robots improves unseen task performance opens a conceptual pathway that did not exist in the VLA paradigm: leveraging the massive scale of human egocentric video (Ego4D, Action100M, YouTube) to continuously improve robot policies without requiring paired action annotation. This is not a solved problem — the gains are moderate and the transfer is only tested over short morphological distances — but it establishes that the world model can absorb visual experience from other embodiments, which is a necessary precondition for scaling this approach.

Follow-Up Research This Work Enables

Scaling laws for WAMs: mapping the relationship between video backbone capacity, data diversity, and policy performance. The paper's Section 6 explicitly calls for this and provides initial data points (5B vs. 14B at 500 hours diverse data yields 21% vs. 50% task progress; diverse vs. repetitive at 14B yields 50% vs. 33%). The concrete follow-up is a systematic sweep: train DreamZero variants at 1B, 5B, 14B, and larger backbone sizes (if Wan or similar models become available at those scales), on datasets of 100, 500, 1000, and 5000 hours, varying both data diversity (number of unique tasks, environments, object configurations) and total hours. Measure: task progress on seen and unseen tasks as a function of backbone size and data scale. The key hypothesis to test is whether WAM performance follows a power-law scaling relationship (as LLMs do) or saturates at some video quality ceiling (suggesting video generation is the bottleneck only up to a point, after which IDM accuracy or closed-loop dynamics dominate). The paper's scaling ablation at 5B vs. 14B shows a steep slope (2.4× parameter increase yields 2.4× performance increase), but a single data point cannot distinguish between a power law and a threshold effect. A negative result — performance saturates at 14B regardless of data scale — would redirect investment toward IDM improvements and action representation rather than larger video backbones.

Quantitative failure decomposition: measuring the separate contributions of video prediction errors, IDM errors, and execution dynamics to overall policy failure. The paper claims that video prediction errors dominate (Section 5.1, Q1; Appendix H) but provides only qualitative, cherry-picked evidence. The concrete experiment: run DreamZero in open-loop mode where the ground-truth future video (from a held-out teleoperation trajectory) is provided as the "predicted" video to the IDM, and measure action prediction accuracy compared to the closed-loop case where DreamZero generates its own video. The difference isolates the contribution of video prediction quality. Separately, measure the accuracy of the closed-loop policy when executed in simulation with perfect dynamics vs. on real hardware, to isolate execution errors. Report per-task and per-difficulty-bin decomposition. A strong follow-up would also measure when failures occur within a trajectory — early in execution (suggesting poor initial visual planning) vs. late (suggesting compounding errors or context limitations). If IDM errors are substantial even given perfect video on certain task categories (e.g., contact-rich manipulation), that would refine the paper's claim that "improving video generation is the path forward" to "improving video generation is the path forward for tasks where visual planning is the bottleneck," with a measurable boundary.

Joint optimization of pretraining and policy training: does co-training on internet video and robot data during pretraining improve downstream policy performance over staged training (pretrain on video, then fine-tune on robot data)? DreamZero freezes the pretrained Wan2.1-I2V-14B backbone and fine-tunes on robot data with the joint video–action objective. The concrete experiment: during the final phase of video backbone pretraining, introduce robot data (video + actions) as a small fraction of the training mixture, with a joint objective that includes both pure video prediction (on internet video) and joint video–action prediction (on robot data). Compare the resulting model's robot policy performance to DreamZero's staged approach. The hypothesis is that joint pretraining would produce video representations that are better aligned with the robot's specific visual perspective (camera angles, gripper appearance, task-relevant objects), potentially reducing the data requirements for downstream fine-tuning. This is analogous to how instruction tuning during LLM pretraining improves downstream task performance over staged fine-tuning, and it tests whether the WAM formulation benefits from similar integration. The cost is substantial — pretraining from scratch or near-scratch with robot data is expensive — but the paper's open-source release makes the robot data component accessible.

Cross-embodiment transfer at morphological distance: does the benefit of video-only transfer data depend on the kinematic and visual similarity between source and target embodiments? The paper shows successful transfer from YAM to AgiBot (both bimanual parallel grippers) and from human egocentric video to AgiBot (different morphology but similar task semantics). The concrete experiment: collect video-only demonstrations on the same set of unseen manipulation tasks from a spectrum of source embodiments — another bimanual parallel-gripper robot (close), a single-arm parallel-gripper robot (intermediate), a dexterous multi-fingered hand (far, kinematically), and a mobile manipulator with different camera perspective (far, visually) — and measure the improvement in DreamZero's unseen task performance after co-training with each. The key hypothesis is that transfer benefit decays with morphological distance, and the goal is to characterize that decay function. A flat function (all source embodiments provide similar benefit) would suggest that the world model is extracting task-level visual dynamics independent of embodiment kinematics, which is a much stronger claim about the generality of video pretraining priors. A steep decay would bound the approach to near-kinematic-transfer scenarios and redirect attention toward methods that explicitly handle embodiment gaps (e.g., learning embodiment-invariant visual representations). The human transfer result (54.3% vs. 55.4% for robot-to-robot, Table 2) already shows that human video provides nearly as much benefit as same-morphology robot video, which is evidence for task-level transfer — but the sample size is small and the morphological range is narrow.

Adaptive compute allocation for WAMs: can per-task difficulty estimation and variable denoising budgets improve the accuracy-per-FLOP tradeoff? The paper operates a fixed-compute policy: 4 denoising steps (or 1 with Flash) regardless of task complexity. The concrete experiment: implement a lightweight difficulty estimator — for example, use the video prediction model's reconstruction loss on the first few frames of context, or train a small classifier on the model's internal activations — to predict task difficulty before the full denoising budget is committed. Then implement a compute-optimal strategy: easy tasks use 1 denoising step (DreamZero-Flash), medium tasks use 2–3 steps (trading off speed for quality), hard tasks use 4+ steps or trigger a larger context window. Measure the Pareto frontier of accuracy vs. average inference time compared to the fixed-budget baseline. This is a direct adaptation of the reference example paper's compute-optimal scaling framework to the WAM setting. The paper's existing data suggests this could be effective: Table 3 shows that 4-step DreamZero outperforms 1-step DreamZero by 31 percentage points on table bussing (83% vs. 52%), while 1-step Flash recovers to 74%. This means the cost of over-computing easy tasks is generating unnecessary denoising steps, and the cost of under-computing hard tasks is degraded action quality. An adaptive policy could route easy tasks to Flash (fast) and hard tasks to multi-step (accurate), achieving better average accuracy at lower average latency. The challenge is cheap difficulty estimation — the paper does not address this, and the cost of estimation must be amortized over the execution budget.

Long-horizon memory and multi-task composition: can WAMs be extended to tasks that require remembering past events beyond the fixed visual context window? DreamZero's maximum visual context is 6.6 seconds (4 chunks × 2 frames/chunk × 1.6s/chunk), and the paper explicitly states that memory-dependent tasks are not evaluated. The concrete experiment: design a benchmark of manipulation tasks requiring memory — for example, "put the object you picked up earlier into the drawer" where the pickup event occurred >6.6 seconds ago, or "sort the objects by the order they appeared" requiring sequential memory. Measure DreamZero's performance as the delay between the memory-forming event and the memory-requiring action increases beyond 6.6 seconds. Then test architectural extensions: (1) increase the visual context window by training with more chunks (from M=4 to M=8 or 16), measuring the tradeoff between memory horizon and inference latency (longer context = more KV-cache, slower inference); (2) add a learned memory module — a separate set of latent tokens that persist across chunks and are updated via cross-attention, analogous to the memory tokens in Transformer-XL or memorizing transformers. The hypothesis is that WAMs are bottlenecked on visual context length for long-horizon tasks, and that extending context or adding explicit memory would unlock tasks currently out of reach. The negative result — long-horizon tasks fail even with extended context, due to video prediction quality degrading over long horizons — would indicate that the world model's predictive fidelity, not memory capacity, is the binding constraint for temporally extended tasks.

Practical Applications and Downstream Use Cases

Data-efficient fine-tuning of generalist policies for specific deployment environments. The paper's post-training results (Figure 10, Q3; Table 2, Q4) demonstrate that DreamZero can be adapted to specific tasks with moderate additional data: 12–40 hours of task-specific teleoperation for fruit packing, shirt folding, and table bussing; 10–20 minutes of video-only cross-embodiment data for unseen task improvement; 30 minutes of play data for new-embodiment adaptation. For a commercial deployment where a generalist robot must be customized for a specific warehouse, restaurant, or home environment, this data efficiency is the primary practical value. Rather than collecting hundreds of hours of environment-specific action-labeled demonstrations (the VLA approach), a deployment team could: (1) deploy the pretrained DreamZero checkpoint, (2) collect a small amount of task-specific teleoperation or play data in the target environment (tens of minutes to tens of hours depending on task complexity), (3) fine-tune, and (4) deploy with zero-shot generalization to novel objects and configurations within that environment. The paper's finding that environment generalization is retained after post-training (Section 5.1, Q3) means the fine-tuned policy does not overfit to the exact training configurations — it can handle varied object placements, lighting, and object instances, which is the practical requirement for production deployments.

Video-only demonstration pipelines for rapid task expansion. The cross-embodiment transfer results (Table 2) suggest a deployment model where new tasks are taught to the robot through video demonstration rather than teleoperation. A human (or another robot) performs the task while being recorded; the video — with no action labels, no joint tracking, no special sensors — is co-trained with the existing robot data for a small number of steps; the policy improves by ~42% relative on those tasks. For a logistics or manufacturing setting where the set of required tasks changes frequently (seasonal products, new packaging, facility reconfiguration), this pipeline eliminates the bottleneck of collecting action-labeled demonstrations. A video of the new task can be captured in minutes from a handheld camera; teleoperation data collection for the same task might require hours of expert operator time plus data processing. The paper's result is preliminary (small task set, modest absolute performance), but the scaling hypothesis — that more human video data yields monotonically better transfer — is directly testable with existing large-scale egocentric video datasets, and if validated at scale would make WAM-based policies expandable through video contribution rather than only through robot operation.

Generalist robot deployment across visually diverse environments without per-environment data collection. The paper's central empirical claim — that DreamZero generalizes to unseen environments and objects by design, because pretraining and evaluation occur in different geographic locations (Section 4.1) — enables a deployment scenario where a single model checkpoint is shipped to multiple sites without site-specific fine-tuning. The 62.2% seen-task progress and 39.5% unseen-task progress on AgiBot (Figures 8, 9) are achieved in evaluation environments with different furniture, lighting, object instances, and room layouts compared to the training data. For a robotics company deploying manipulation capabilities across customer sites (warehouses, retail stores, fulfillment centers), this means the model does not need to be retrained or fine-tuned for each new site's visual appearance — it handles the distribution shift zero-shot. The paper's qualitative free-form testing on 100+ diverse tasks (Section 5.1, Q2) further suggests that the policy can handle open-ended language instructions beyond the structured evaluation tasks. The caveat is that all evaluation environments are drawn from a distribution of indoor tabletop manipulation settings — outdoor, underwater, aerial, or extreme-industrial environments would require separate validation.

When to Prefer This Method

The paper provides explicit evidence on where WAMs outperform VLAs and where they remain limited, enabling a conditional decision framework grounded in the reported results:

Prefer a WAM (specifically, DreamZero or a similar joint video-action model built on a pretrained video diffusion backbone) when your robot training data is diverse, heterogeneous, and non-repetitive — the paper shows from-scratch VLAs collapse to near-zero performance on such data (Figure 8) while WAMs achieve strong results (62.2% seen-task progress). If your data collection prioritizes breadth over repetition (many tasks with few demonstrations each, varied environments, coarse-grained annotations), the WAM's video prediction prior provides the regularization that VLAs lack.
Prefer a WAM when you need zero-shot generalization to unseen physical motions and skills not present in the robot training data — the paper shows DreamZero achieving 39.5% task progress on 10 entirely novel tasks (Figure 9) while pretrained VLAs achieve 16.3%, and from-scratch VLAs achieve <1%. If your deployment requires the robot to attempt tasks like "untie shoelaces" or "iron a shirt" that were never demonstrated during training, the visual planning prior from video pretraining provides a capability that observation-to-action VLAs cannot match without explicit task demonstrations.
Prefer a WAM when you have access to video-only data from other embodiments (humans or different robots) and want to improve your robot's performance without collecting action-labeled demonstrations — the paper shows 42% relative improvement from 10–20 minutes of video-only data (Table 2). If you can record humans performing the target tasks or have access to egocentric video datasets, the WAM can absorb that visual experience to strengthen its world model without requiring paired joint-angle labels.
Prefer a VLA instead when inference latency is the primary constraint and you cannot deploy on high-end multi-GPU hardware — the paper's 7Hz inference requires 2 GB200 GPUs with NVFP4 quantization; on H100 GPUs without quantization, inference drops to ~1.7 Hz (5.7s / 9.6× speedup, per Table 1). If your deployment runs on a single consumer GPU or embedded device with strict latency requirements (<50ms per action), current VLA architectures (single forward pass, no iterative denoising) are faster by a large margin, even if they generalize less well.
Prefer a VLA instead when the target embodiment is morphologically very distant from the pretraining embodiment and you have limited adaptation data — the paper's few-shot adaptation from AgiBot to YAM succeeds (both bimanual parallel grippers, 30 minutes of data) but provides no evidence for adaptation across larger morphological gaps (single-arm, dexterous hand, suction gripper, mobile-only). If you need to deploy on a novel embodiment that shares no visual or kinematic similarity with the pretraining robot, the implicit IDM would need to learn a fundamentally new visual-future-to-motor-command mapping, and the 30-minute data budget may be insufficient — but the paper provides no data to bound this.
Prefer a VLA instead when your tasks require sub-centimeter precision (key insertion, fine assembly, surgical manipulation) — the paper explicitly acknowledges this limitation (Section 6: "it inherits limitations common to behavior cloning on tasks requiring sub-centimeter precision") and does not evaluate on high-precision tasks. The video prediction at 5 FPS and latent resolution (480P VAE encoding) may not capture the visual detail needed for millimeter-scale manipulation, and the implicit IDM may not achieve the required joint-level accuracy from video predictions at this resolution.

Dependency tree

Papers this one builds on, walking backwards through the same domain and shared topics.

MolmoAct: Action Reasoning Models that can Reason in Space2025· uncategorized← LLM-judged similar
- ThinkAct: Vision-Language-Action Reasoning via Reinforced Visual Latent Planning2025· agents← LLM-judged similar
- V2V-LLM: Vehicle-to-Vehicle Cooperative Autonomous Driving with Multimodal Large Language Models2025· llm-systems← LLM-judged similar
- GR-3 Technical Report2025· uncategorized← LLM-judged similar
- GUI-Actor: Coordinate-Free Visual Grounding for GUI Agents2025· vision← LLM-judged similar
- PIVOT: Iterative Visual Prompting Elicits Actionable Knowledge for VLMs2024· agents← LLM-judged similar
- RVT-2: Learning Precise Manipulation from Few Demonstrations2024· agents← LLM-judged similar
- RoboVQA: Multimodal Long-Horizon Reasoning for Robotics2023· uncategorized← LLM-judged similar
- REINA: Regularized Entropy Information-Based Loss for Efficient Simultaneous Speech Translation2025· uncategorized← in-domain predecessor
- Qwen-Image Technical Report2025· multimodal← topic thread
- NVIDIA Nemotron Nano 2: An Accurate and Efficient Hybrid Mamba-Transformer Reasoning Model2025· reasoning← topic thread
GLM-5: from Vibe Coding to Agentic Engineering2026· uncategorized← in-domain predecessor
- BitDance: Scaling Autoregressive Generative Models with Binary Tokens2026· uncategorized← in-domain predecessor
Cosmos-H-Surgical: Learning Surgical Robot Policies from Videos via World Modeling2025· uncategorized← similar topic
- Deep Research: A Systematic Survey2025· uncategorized← in-domain predecessor
- Web World Models2025· architecture← topic thread
- LIVE: Long-horizon Interactive Video World Modeling2026· uncategorized← similar topic

What it influenced

Later papers in the same chain. Direction reversed.

TOPReward: Token Probabilities as Hidden Zero-Shot Rewards for Robotics2026· uncategorized→ in-domain predecessor
- MolmoB0T: Large-Scale Simulation Enables Zero-Shot Manipulation2026· uncategorized→ in-domain predecessor
Cosmos-H-Surgical: Learning Surgical Robot Policies from Videos via World Modeling2025· uncategorized→ similar topic
- Web World Models2025· architecture→ LLM-judged similar
- Nested Browser-Use Learning for Agentic Information Seeking2025· uncategorized→ in-domain predecessor
- Visual Generation Unlocks Human-Like Reasoning through Multimodal World Models2026· reasoning→ topic thread
- DreamDojo: A Generalist Robot World Model from Large-Scale Human Videos2026· uncategorized→ similar topic
- LIVE: Long-horizon Interactive Video World Modeling2026· uncategorized→ similar topic