Masked Visual Actions for Unified World Modeling
Abstract: Video models absorb rich priors over how the visual world moves, interacts, and responds to contact, making them promising substrates for robotic world modeling. The central challenge is how to communicate action to such models in a form aligned with the visual space in which they learned these interaction priors, yet still grounded in physical manipulation. We introduce Masked Visual Actions, a pixel-space control interface that expresses action as a partially revealed trajectory of an arbitrary entity in a video. Revealing robot motion makes the model act as a forward dynamics model that predicts the scene's response to low-level robot actions, while revealing desired object motion makes the same model recover robot behavior consistent with that outcome. Finetuned with only 15 hours of masked examples from real videos and simulation, a single checkpoint achieves strong visual fidelity and controllability across diverse scenes and multiple embodiments. In downstream manipulation settings, the model produces imagined rollouts whose outcomes correlate with real-world execution for policy evaluation, improves decision making by ranking candidate futures in model-based planning, and supports inverse modeling by synthesizing robot motion from desired object motion.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What is this paper about?
This paper shows a new, simple way to tell a video-making AI how things in the world should move so it can help control robots. The key trick is to “mask” (show) parts of a video that represent actions in pixel form—like drawing the robot’s future path right on the video—so the AI can imagine what will happen next or figure out what the robot should do to make something happen.
What questions did the researchers ask?
- Can we talk to a video model using visuals (pixels) instead of robot-specific numbers, so it works across many kinds of robots?
- If we reveal the robot’s future motion in the video, can the model predict what the objects will do (a “forward” prediction)?
- If we reveal how we want the objects to move, can the same model figure out how the robot should move to make that happen (an “inverse” prediction)?
- Can this help with practical robot tasks like planning moves, judging if a policy is good, and turning a desired object motion into real robot actions?
How did they do it?
The big idea: “Masked Visual Actions”
Imagine a video of a scene (a robot in a kitchen). Now imagine painting over the parts where something will move, like tracing the robot’s arm path or the object’s desired motion. That painted area is the “mask.” The model sees:
- The first frame of the scene (where everything starts).
- A masked, partially revealed motion track (in pixels) for either the robot or the object.
Then it fills in the rest of the video in a realistic way.
- If you reveal the robot’s motion, the model predicts how the world responds (does the mug slide, does the drawer open?). This is like cause → effect (forward modeling).
- If you reveal the object’s desired motion, the model figures out how the robot must move to make that outcome happen. This is like effect → cause (inverse modeling).
Think of it like giving directions on a map:
- Forward: “Here’s where the car (robot) will drive—what will the traffic (objects) do?”
- Inverse: “I want to end up here (desired object motion)—what route (robot motion) should the car take?”
Training the model in plain terms
- They started with a strong video-generating AI (already good at understanding how things move in the real world).
- They fine-tuned it with about 15 hours of robot videos and simulation. That’s small and efficient.
- To make the “masked actions,” they used:
- Segmentation: automatically cutting out the robot from real videos (like tracing around it).
- Rendering: drawing a 3D robot model over the video using known camera info, so you can supply any motion you want later.
- They used a lightweight tuning method (you can think of it like adding small adjustable “knobs” to the big model) so training is fast and doesn’t need massive compute.
What did they find?
- One model, two jobs:
- As a forward model: Given robot motion in pixels, it realistically predicts what objects will do.
- As an inverse model: Given desired object motion in pixels, it produces a believable robot motion to achieve it.
- It works across different robot bodies (single-arm, two-arm) better than methods that rely on robot-specific numbers. Because the input is “just pixels,” it’s not tied to one robot type.
- Higher visual quality and better control than previous methods that use text prompts, point tracks, or raw robot commands.
- Useful for real tasks:
- Planning: Sample several action ideas from a policy, “imagine” each future with the video model, then pick the best one. This improved success rates.
- Policy evaluation: The model’s imagined success closely matches real-world success trends, so you can estimate how good a policy is without always running the real robot.
- Action extraction: Tell the model how you want an object to move; it imagines a matching robot motion. A learned “inverse dynamics” module then turns that imagined motion into actual robot commands. On a mug-serving task, this reached about 90% success, competing with popular learning baselines.
Why this matters:
- Pixel-based action prompts line up with how the video model already “thinks,” making it easier for the model to generalize and follow instructions.
- The same model can swap between forward and inverse thinking just by changing what you reveal in the mask.
What’s the impact?
- A unified, simple interface: You “draw” either the robot’s move or the object’s goal into the video, and the same model handles both planning and control-like tasks.
- Works across different robot types without redesigning the action format.
- Cuts costs and risks: You can try and compare many imagined futures before touching the real robot.
- Could speed up robot development, enable safer testing, and help robots learn from fewer examples.
Limits and what’s next
- The model learns patterns and correlations from videos, not true cause-and-effect physics, so it can still make realistic-looking but wrong guesses.
- It’s limited by the base video model’s speed and what it can depict.
- Sometimes you need good masks or camera info; making that easier and faster would help.
- Future work: stronger physics grounding, faster inference, and even better tools to turn imagined videos into reliable low-level robot commands.
Overall, the paper shows that “masking” actions directly in video pixels is a powerful, general way to guide a video model to think like a world model—predicting what will happen and planning what should happen—using the same simple visual interface.
Knowledge Gaps
Below is a single, concrete list of gaps, limitations, and open questions that remain unresolved by the paper and could guide follow-up research.
- Causal fidelity: the model is acknowledged to learn correlations rather than causal dynamics; no interventional or counterfactual evaluation is presented to verify that predicted outcomes reflect true cause–effect under action perturbations.
- Mask quality sensitivity: robustness to segmentation errors, partial/temporal mask misalignment, and user-provided noisy or sparse masks is not quantified; no ablation on mask corruption or leakage is reported.
- Rendering dependency: the rendering-based conditioning requires accurate camera calibration and URDF; it is unclear how the system behaves with imperfect calibration or unknown intrinsics/extrinsics, or how to automatically align meshes without ground-truth calibration.
- Camera assumptions: evaluations appear to use mostly fixed third-person cameras; generalization to moving cameras, egocentric views, multi-camera inputs, and time-varying intrinsics is not studied.
- Training mask distribution: the choice of mask sampling strategy during training (which entities, fraction of pixels/time revealed, partial vs full masks) is not analyzed for its impact on forward/inverse generalization; learning or optimizing the mask distribution remains open.
- Multi-entity conditioning: scalability to multiple simultaneously active agents (e.g., bimanual + mobile base, or human–robot collaboration) and to conditioning on mixed subsets of active/passive entities is not systematically evaluated.
- Physical accuracy metrics: evaluation uses perceptual video metrics (LPIPS/SSIM/PSNR) and VLM judges; there is no measurement of physical plausibility (contact timing, penetration, frictional slip, momentum/energy consistency), nor benchmarks for physics faithfulness.
- Long-horizon stability: the effective planning/prediction horizon, error accumulation over many steps, and strategies for temporal decomposition or memory are not quantified.
- Real-time control: inference latency, throughput, and feasibility for closed-loop control at practical control rates (10–50 Hz) on commodity hardware are not reported; trade-offs between sampling temperature, number of samples, and latency are unclear.
- Uncertainty calibration: how well the model’s rollouts represent multimodal futures and how to obtain calibrated uncertainty/confidence for risk-aware planning are not addressed.
- VLM-judge reliability: planning success depends on Gemini scoring; sensitivity to prompts, biases, and inconsistencies, and comparisons to automatic physics-based or task-specific reward functions are missing.
- Policy evaluation bias: the paper observes a positive bias (over-optimism) of imagined success but does not propose calibration/correction methods or quantify when this bias becomes harmful for selection/planning.
- Inverse modeling generality: zero-shot inverse use is shown on one task; breadth across tasks, embodiments, cluttered scenes, and hard contact-rich manipulation is untested; conditions under which inverse completes become unreliable are unknown.
- Executability guarantees: there is no mechanism to ensure the generated robot motion is kinematically/ dynamically feasible or collision-free; integrating joint limits, self-/environment-collision constraints, and torque/velocity bounds remains open.
- Action extraction details: the learned inverse dynamics model (architecture, training regimen, alignment/temporal synchronization with generated videos, robustness to domain shift) is under-specified; ablations and generalization studies are missing.
- 2D-to-3D consistency: the approach is 2D video–based; consistency of predicted depth/3D structure across views and leveraging 3D representations (e.g., 4D occupancy, radiance fields) for physically grounded planning are not explored.
- Deformables and fluids: handling deformable/soft objects, granular media, liquids, transparent/reflective materials, and small or thin objects is not evaluated.
- Generalization coverage: although cross-embodiment generalization is highlighted, breadth across novel object categories, extreme clutter, texture/lighting changes, and out-of-distribution household layouts is not quantified.
- Specifying object-goal masks: practical interfaces for users to specify desired object trajectories (e.g., strokes, keyframes, text) and robustness to under-specified or ambiguous goals are not addressed.
- Data scaling laws: only ~15 hours of data are used; scaling behavior with more/less data, with different real/sim mixes, and across more embodiments is unknown.
- Training objective design: alternatives to pure masked completion (e.g., inverse-dynamics rewards, physics priors, preference optimization, consistency training) to improve executability or causal accuracy are not investigated.
- Failure mode characterization: systematic analysis of where the model fails (e.g., heavy occlusions, transparent objects, fast motions, tight clearances) and targeted mitigations are absent.
- Safety and alignment: methods to enforce safety envelopes during generation/planning (keep-out zones, human proximity, compliance) and formal verification of generated behaviors are not provided.
- Benchmarking fairness: some baselines are trained on different data scopes (e.g., Ctrl-World on full DROID); controlled data-equalized comparisons and confidence intervals are not reported.
- Reproducibility and variance: statistical reporting (trial counts, seeds, CIs) for key results is limited; sensitivity to hyperparameters (LoRA rank, conditioning strength, sampling steps) is not explored.
- Multi-task and compositional goals: capabilities for composing multiple subgoals, tool use, or interleaving tasks are not evaluated; mechanisms for hierarchical planning via mask sequences are open.
- Closed-loop integration: the paper primarily uses open-loop rollouts and Best-of-N; integrating the model into receding-horizon MPC, online replanning, or RL with model-based rollouts is left unexplored.
- Human-in-the-loop editing: interactive mask editing, constraint injection, and preference feedback to iteratively refine plans are not supported or evaluated.
- Theoretical identifiability: conditions under which masked visual actions guarantee identifiable inverse solutions (uniqueness/ambiguity of robot motions given object trajectories) are not analyzed.
Practical Applications
Immediate Applications
Below are deployable use cases that can be implemented now using the paper’s methods and findings.
- Visual policy evaluation harness for robot manipulation
- Sectors: robotics, manufacturing, logistics, household robotics, education
- Tools/workflow: plug a stochastic policy (e.g., Diffusion Policy) into the Masked Visual Actions (MVA) forward model to generate imagined rollouts; auto-score via a rubric or VLM judge; compare with ground-truth to track policy progress and regression across tasks
- Why now: the paper shows strong correlation (r≈0.98) between simulated and real/sim success rates with only ~15 hours of finetuning
- Assumptions/dependencies: single-camera view of the scene; domain similarity to training (DROID/Robocasa-like); VLM judge quality and bias management; compute for video inference; acceptance that the simulator can be positively biased toward success
- Best-of-N model-based planning via video rollouts
- Sectors: manufacturing, warehouse automation, service robotics
- Tools/workflow: sample N candidate action sequences from a base policy; simulate with MVA forward model; rank candidates using a VLM judge or task-specific heuristics; execute the top-ranked plan (test-time scaling)
- Why now: demonstrated gains from ranking imagined futures; generic to many policies
- Assumptions/dependencies: reliable segmentation or rendered masks of robot motion; VLM judge or deterministic scoring rules; action timing alignment between policy and video frames; added latency from simulating N branches
- Inverse modeling for skill extraction from desired object motion
- Sectors: flexible automation, lab automation, home robotics, training/teleoperation aids
- Tools/workflow: specify goal as object motion masks (e.g., sketch trajectories); the same checkpoint synthesizes robot motion; a learned inverse dynamics model (IDM) extracts executable actions
- Why now: the paper reports 90% success on a constrained manipulation task without task-specific video-model finetuning
- Assumptions/dependencies: learned IDM per robot/controller; object masks or trajectories come from a user, tracker, or planner; closed-loop stabilization may still be needed downstream
- Cross-embodiment simulation and visualization for task feasibility studies
- Sectors: systems integration, robotics OEMs, solution engineering
- Tools/workflow: render or segment different robot embodiments into a common pixel-space interface and simulate scenes to check reachability, occlusions, and contact plausibility without full dynamics modeling
- Why now: paper shows generalization to unseen embodiments (e.g., bimanual robots) where action-vector models collapse
- Assumptions/dependencies: initial scene image; coarse camera calibration if using rendering; realism limited to video-model priors (correlational, not causal)
- Data-efficient world-model finetuning for new cells or products
- Sectors: SMEs in manufacturing/logistics; academia
- Tools/workflow: LoRA finetune a pretrained video model on ~10–20 hours of local data combining segmentation- and rendering-based masked examples; deploy a site-specific forward/inverse simulator
- Why now: paper achieves strong controllability with only ~15 hours of mixed data and rank-256 LoRA
- Assumptions/dependencies: access to a base video model (e.g., Wan 2.2); 8×H200-scale compute or cloud equivalent (can be reduced with smaller backbones/slower inference); data curation for masks (SAM or URDF rendering)
- No-code “object-trajectory programming” for simple tasks
- Sectors: light manufacturing, labs, maker spaces, education
- Tools/workflow: a UI to draw/paint desired object motion on a reference frame; MVA inverse mode synthesizes robot motion; IDM converts to joint or end-effector commands; human verifies an imagined rollout before execution
- Why now: same checkpoint supports inverse use without retraining; reduces expert programming burden for structured skills
- Assumptions/dependencies: IDM availability; conservative execution with safety interlocks; tasks that do not require complex 3D reasoning beyond the video model’s priors
- Visual debugging and postmortems for policy failures
- Sectors: robotics R&D, MLOps for robotics
- Tools/workflow: compare actual vs imagined rollouts conditioned on the same initial frame and action masks to locate where physics/contact understanding diverged; use for failure triage and data collection prioritization
- Assumptions/dependencies: synchronized policy actions and camera frames; storage of initial state snapshots; analysts interpret correlational diagnostics
- Curriculum and coursework modules
- Sectors: academia, corporate training
- Tools/workflow: hands-on labs showing forward vs inverse modeling with masks; assignments on planning with Best-of-N and VLM judges; exercises in segmentation vs rendering masks and embodiment generalization
- Assumptions/dependencies: access to teaching compute; datasets (DROID/Robocasa) and released code/weights
Long-Term Applications
These use cases are feasible but need further research, scaling, or productization.
- Real-time closed-loop “video-as-policy” control in unstructured homes and factories
- Sectors: home robotics, service robotics, manufacturing
- Tools/workflow: run the video model and IDM in the loop at high frequency; optionally fuse with proprioception and force feedback; continual replanning with short-horizon visual rollouts
- Why later: current inference speed and latency of large video models; need for robust safety envelopes and recovery behaviors
- Assumptions/dependencies: acceleration via distillation, smaller backbones, or hardware; multi-sensor fusion; robust tracking between generated and real frames
- Unified multi-robot, multi-embodiment planning and transfer
- Sectors: integrators, fleet orchestration, AMRs + manipulators
- Tools/workflow: a shared pixel-grounded “visual action” API enabling heterogeneous robots to simulate joint interactions; plan handoffs and collaboration (e.g., bimanual or human–robot)
- Why later: needs larger, diverse training data across embodiments and interaction modes; coordination logic and role assignment
- Assumptions/dependencies: standardized mask schemas; time synchronization; multi-view/multi-agent conditioning
- Visual digital twins for factory cell design and optimization
- Sectors: manufacturing, semiconductor, energy asset maintenance
- Tools/workflow: photoreal visual simulators that predict contact outcomes from CAD/URDF and camera placements; optimize fixture layouts and cycle times by ranking imagined plans
- Why later: requires stronger causal grounding and calibration to match forces, friction, and tolerances; integration with CAD/PLM stacks
- Assumptions/dependencies: calibrated multi-camera setups; domain adaptation to specific materials and tools; metrics beyond visual plausibility
- No-code robot programming via sketch/video demonstrations for end users
- Sectors: consumer/home robotics, SMB automation
- Tools/workflow: users paint object goals on smartphone video; cloud generates imagined execution; device executes safest validated plan
- Why later: trustworthy goal interpretation, safety verification, and fail-safes; UX and liability frameworks
- Assumptions/dependencies: robust object tracking/segmentation in the wild; conservative action synthesis; certification pathways
- Safety assurance and policy governance via pre-deployment “imagination tests”
- Sectors: safety engineering, regulators, insurers
- Tools/workflow: standardized adversarial scenario suites run in the video world model; risk scoring before on-robot trials; audit trails of imagined vs realized outcomes
- Why later: needs benchmarks, guardrails for sim bias, and agreed scoring protocols
- Assumptions/dependencies: coverage of long-tail hazards; independent validation; procedures for discrepancies between imagined and real behavior
- General-purpose inverse modeling for skill acquisition from internet videos
- Sectors: robotics foundation models, content-to-action pipelines
- Tools/workflow: condition on passive entities in web videos to synthesize embodiment-specific motions; IDM maps to actions for target robots
- Why later: domain gaps, camera geometry ambiguity, and licensing/governance; robustness to occlusions and multi-view inconsistencies
- Assumptions/dependencies: strong segmentation/tracking; camera pose estimation or self-calibration; scalable IDM training
- Human-in-the-loop planning with counterfactual exploration
- Sectors: field robotics, agriculture, construction, healthcare
- Tools/workflow: operators branch multiple “what-if” futures by painting interventions (e.g., moving a ladder, opening a cabinet) and choose a safe plan
- Why later: needs stable, interactive UIs and fast branching; reliability in cluttered, deformable, or outdoor scenes
- Assumptions/dependencies: responsive inference; uncertainty visualization; integration with teleop overrides
- Standardized “visual action” APIs for video foundation models
- Sectors: software platforms, ML tooling, ROS ecosystem
- Tools/workflow: spec for mask formats, timing, and conditioning channels; ControlNet-like adapters for robot stacks; evaluation suites for embodiment generalization
- Why later: requires community adoption, vendor support, and benchmarks
- Assumptions/dependencies: interoperable codecs; licensing for base models; governance over misuse
- Automated data selection and active learning driven by imagination gaps
- Sectors: robotics MLOps
- Tools/workflow: mine cases where imagined and real rollouts diverge; prioritize new data collection or sim augmentation; continuous LoRA updates
- Why later: needs reliable discrepancy metrics that predict real gains; automated pipelines
- Assumptions/dependencies: storage/compute budgets; monitoring for catastrophic forgetting; change-management processes
Notes on cross-cutting dependencies
- Base model capability and licensing: relies on access to a strong video backbone (e.g., Wan 2.2 14B) and permission to finetune/distribute.
- Compute and latency: current results used 8×H200 GPUs and LoRA rank 256; real-time control will require acceleration/distillation.
- Perception inputs: single reference frame and robust masks; segmentation (SAM-like) or URDF rendering with camera calibration.
- Physics fidelity: models are correlational; physical realism must be validated for safety-critical deployments.
- Evaluation and ranking: VLM judges add bias; task-specific, deterministic rubrics reduce variance for production.
- IDM quality: inverse modeling depends on an accurate, well-calibrated IDM per robot/controller.
- Generalization limits: embodiment and domain shifts can degrade performance; monitor and adapt with data from the target environment.
Glossary
- 4D occupancy: A spatiotemporal volumetric representation indicating which regions are occupied over time. "ORV~\citep{yang2025orv} conditions on 4D occupancy;"
- Best-of-N: A planning strategy that samples N candidate action sequences and selects the best by a scoring function. "Best-of-N as the simplest model-based planning algorithm."
- bimanual: Refers to robots with two arms or end-effectors. "a bimanual robotic embodiment that's unseen for all methods."
- binary mask: A 0/1-valued tensor specifying revealed versus predicted pixels. "be a binary mask indicating which spatiotemporal pixels are revealed to the model () versus predicted ()."
- camera calibration: Estimating camera intrinsics/extrinsics to align 3D states with images. "we require the robot state corresponding to the input video and the camera calibration."
- conditional distribution: A probability distribution over variables given others. "Conditioning on a subset of entities yields the conditional distribution"
- ControlNet: A network used to inject structured control signals into generative models. "inject the resulting masks or pointmaps via ControlNet;"
- counterfactuals: Hypothetical rollouts showing what would happen under alternative actions. "synthesize counterfactuals by conditioning on a subset of scene entities."
- Diffusion Policy: A control policy that generates actions via a diffusion model. "We use Diffusion Policy~\cite{chi2023diffusionpolicy, chi2024diffusionpolicy} as the stochastic policy"
- embodiment-agnostic: Not tied to any particular robot morphology or hardware. "pixel-aligned, embodiment-agnostic, native to video"
- end-effector: The tool or gripper at the tip of a robot arm. "End-effector poses or robot skeletons are more visual, but remain sparse and require the model to infer geometry, contact, and interaction effects."
- forward dynamics model: Predicts scene evolution given agent actions. "acts as a forward dynamics model that predicts the scene's response to low-level robot actions"
- inpainting: Filling in missing or masked regions in images/videos. "learn to inpaint missing regions"
- inverse dynamics model: Maps observed motion to the low-level actions that would produce it. "a learned inverse dynamics model extracts the resulting actions."
- inverse-dynamics problem: Inferring actions from observed or desired motion. "Action extraction can then be cast as an inverse-dynamics problem: given the synthesized robot video, recover an executable low-level action sequence"
- inverse modeling: Recovering agent behavior that achieves a specified outcome. "supports inverse modeling by synthesizing robot motion from desired object motion."
- inverse model: A model that infers actions needed to reach a target state. "act as an inverse model that synthesizes the robot motion needed to achieve the desired outcome."
- LPIPS: Learned Perceptual Image Patch Similarity; a perceptual metric for image/video fidelity. "Method & LPIPS & SSIM & PSNR "
- LoRA finetuning: Low-Rank Adaptation; an efficient method to fine-tune large models. "we use LoRA finetuning with rank 256"
- masked modeling: Training by hiding parts of the input and predicting them from context. "We draw inspiration from masked modeling in language"
- Masked Visual Actions: A pixel-space action interface using masked trajectories as control signals. "We introduce Masked Visual Actions, a pixel-space control interface that expresses action as a partially revealed trajectory of an arbitrary entity in a video."
- model-based planning: Selecting actions by simulating candidate futures with a predictive model. "improves decision making by ranking candidate futures in model-based planning"
- open-loop: Executing a precomputed action sequence without feedback during execution. "we use an open-loop diffusion policy across tasks"
- policy evaluation: Assessing a policy’s performance, often via simulated rollouts. "In policy evaluation, the model's imagined rollouts exhibit consistent correlation with real-world outcomes"
- PSNR: Peak Signal-to-Noise Ratio; a reconstruction fidelity metric. "Method & LPIPS & SSIM & PSNR "
- rollout: A trajectory generated by executing a policy in simulation or the real world. "By rolling out multiple trajectories from a pretrained diffusion policy"
- spatiotemporal: Involving both spatial and temporal dimensions. "partially revealed spatiotemporal patterns in pixel space"
- SSIM: Structural Similarity Index Measure; an image/video similarity metric. "Method & LPIPS & SSIM & PSNR "
- test-time scaling: Improving performance by using more computation or samples at inference. "This approach can be viewed as a form of test-time scaling"
- translucent rendering: Rendering objects with partial transparency. "we render the robot only with translucent rendering"
- URDF: Unified Robot Description Format; a standard for robot kinematic and visual models. "render the robot URDF that matches the original video to construct masked visual actions."
- video-as-policy: Using a video generation model directly to produce control behavior. "direct video-as-policy \citep{kim2026cosmos,hu2024video};"
- VLM judge: A vision-LLM used to score or rank generated rollouts. "using a VLM judge to pick the best action trajectory."
- world model: A predictive model of environment dynamics for planning and control. "Robotic world models should similarly support both directions of reasoning in a single predictive framework."
- zero-shot: Generalizing to tasks or settings without task-specific training. "generalizes to queries conditioned on passive entities in a zero-shot manner."
Collections
Sign up for free to add this paper to one or more collections.