World Action Models (WAMs) provide a promising alternative to Vision-Language-Action (VLA) policies by using video-based world modeling as dense supervision for robot action learning. Existing WAMs excel at physically grounded execution, but typically lack the explicit language-level planning interface in VLM-based VLAs for decomposing coarse instructions. Such decomposition becomes important when household tasks involve complex multi-step goals, where coarse user commands need to be converted into sequences of fine-grained executable subtasks. Meanwhile, the field still lacks a fair real-robot comparison between VLA and WAM execution capabilities, since existing systems often differ in data, robot embodiments, and task protocols. To address both the decomposition gap and the need for a controlled WAM-VLA comparison, we introduce DSWAM, a Dual-System World Action Foundation Model for fine-grained robot manipulation. DSWAM keeps a System 1 WAM executor as the default control path and optionally activates a System 2 vision-language subtask planner only when task decomposition is useful. The planner predicts executable subtasks from short-term visual history and a global task prompt, while the WAM executor performs world-aware action generation for each instruction or subtask. The executor is trained with action prediction and video co-training, but inference directly predicts action chunks without explicit future video generation. To provide a fair real-robot comparison with VLA policies, we build and evaluate DSWAM under the DeMaVLA real-world deformable manipulation setting with matched robot platform, pretraining data, post-training data, and evaluation criteria. In this folding benchmark, DSWAM runs in WAM-only mode with the System 2 planner disabled. Under this setting, DSWAM improves average real-world folding success rate from 92.5% to 96.3% and reduces completion time from 2'18'' to 1'44''.
World Action Models (WAMs) have recently emerged as a promising alternative to Vision-Language-Action (VLA) policies for robotic manipulation. Existing VLA policies convert visual observations and language instructions into executable robot actions, but their common single-frame, observation-to-action formulation provides limited temporal context for modeling scene evolution during robot manipulation. WAMs address this limitation by learning how visual states evolve under actions, providing world-aware representations of physical dynamics.
However, when household tasks involve complex multi-step goals, physically grounded execution alone is not enough. Coarse user commands often need to be converted into sequences of fine-grained executable subtasks. VLM-based VLAs provide a natural language-level interface for semantic grounding, planning, and instruction decomposition, whereas existing WAMs are mainly designed as execution policies and typically lack this capability.
To address these issues, we present DSWAM, a Dual-System World Action Foundation Model for fine-grained robot manipulation. DSWAM instantiates the above decoupling by preserving a System 1 WAM executor as the default control path and adding a System 2 vision-language subtask planner only as an optional high-level module.
DSWAM is a dual-system framework for fine-grained robot manipulation. The framework combines large-scale real-world robot training, an optional high-level planner, and an efficient WAM executor. System 1 is the default execution path: it conditions on current multimodal observations, language, and proprioception to predict action chunks through a video-model-based WAM executor and an action expert. System 2 is an optional vision-language subtask planner that is invoked only when a command benefits from explicit decomposition.
When the planner is not activated, DSWAM conditions System 1 directly on the original prompt and runs the WAM policy without an additional planning step. When the planner is activated, System 2 uses short-term visual history and the global task prompt to decompose a coarse multi-step command into fine-grained executable subtasks, which are then passed to System 1 as language conditions.
The executor is trained with action prediction and video co-training, but inference directly predicts actions without explicit future-video generation. This execution-first design keeps planning out of the control path when it is unnecessary, while TensorRT acceleration and asynchronous chunk execution make the same policy practical for real-world deployment.
We organize the experiments from simulation to real-world deployment. We first evaluate broad bimanual manipulation capability on RoboTwin 2.0, then use the matched DeMaVLA folding protocol to compare WAM-style execution with VLA policies under aligned robot platform, training data, task definitions, and evaluation criteria. DSWAM runs in WAM-only mode in this folding benchmark, with the System 2 planner disabled, so the comparison focuses on policy execution capability.
DSWAM reaches 92.38% average SR under the clean setting and 91.90% under the randomized setting, achieving the best average performance in both settings. The gains are not limited to comparisons with WAM-style baselines: DSWAM also outperforms the VLA baselines by a clear margin.
To provide a controlled real-robot comparison with VLA policies, we follow the household folding protocol introduced by DeMaVLA. The benchmark uses an ALOHA-style dual-arm platform and evaluates four deformable manipulation tasks: folding a shirt, folding a skirt, folding pants, and folding a towel.
Table 2 shows the matched real-world comparison. DSWAM achieves the best average result, reaching 96.3% SR and 1'44'' average completion time. Relative to DeMaVLA, DSWAM improves average SR by 3.8 percentage points and reduces average completion time by 34 seconds. Relative to pi0, it improves average SR by 20.0 percentage points and reduces average completion time by 42 seconds.
We next isolate the effect of the optional System 2 branch using the sorting protocol. This study does not assume that every instruction should be decomposed; instead, it asks whether subtask-level supervision helps when a coarse command has a clear task structure.
Table 3 shows that subtask-level supervision improves execution stability in this setting. Averaged over the reported evaluations, the raw sorting instruction achieves 75.7% SR with 3.53 mistakes per rollout, while subtask-level instructions reach 100.0% SR and reduce mistakes to 0.65 per rollout.