# AW-0

> Source: https://aiwiki.ai/wiki/aw_0
> Updated: 2026-11-04
> Categories: AI Models, AI Research, Robotics, World Models
> License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/) - attribute to "AI Wiki (aiwiki.ai)"
> Cite as: AI Wiki. "AW-0." aiwiki.ai, 4 Nov 2026. https://aiwiki.ai/wiki/aw_0
> From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution.

**AW-0** is a robotic learning framework introduced in the October 2026 research paper *Agentic World Action Models*. It combines the generation of short skill programs, predicted future video, and robot actions in one model. The work comes from researchers affiliated with the University of California, Berkeley, [NVIDIA](https://aiwiki.ai/wiki/nvidia), and the University of Pennsylvania.[1][2]

AW-0 belongs to the [world action model](https://aiwiki.ai/wiki/world_action_model) family: it learns to predict how a scene changes while producing actions for a robot. Its added code stream represents a task as reusable skill calls. In the default execution mode, that code guides video and action generation; a separate hybrid mode can execute selected generated programs through perception and control APIs.[1][2]

## Architecture

The framework has three transformer experts connected by joint attention. Each expert retains its own attention projections, layer normalization, and feed-forward layers. Information flows in the order code, video, then action: the video expert can attend to the code, and the action expert can attend to both. The input includes camera observations, a language instruction, the robot state, and a compressed memory of earlier program slices.[1]

| Stream | Representation | Role |
| --- | --- | --- |
| Code | Discrete program tokens | Selects skills, objects, arguments, and control logic for the current subtask |
| Video | Continuous latent representations of future frames | Predicts the visual consequences of interaction |
| Action | Continuous action chunks | Produces a sequence of robot controls |

The streams undergo denoising together. Code tokens use masked-token prediction, while video and actions use flow matching. A generated program therefore conditions the predicted scene and motor commands during generation, rather than being added as an explanation after an action has been chosen.[1]

The released implementation uses a Cosmos-Predict2.5-2B video expert, a Wan2.2 variational autoencoder, an SDAR-1.7B code-expert body, and a separate diffusion action head. A frozen [Qwen3-VL](https://aiwiki.ai/wiki/qwen3_vl) vision tower supplies visual information to the code expert. The paper describes the code generation procedure as [LLaDA](https://aiwiki.ai/wiki/llada)-style masked-token diffusion. These component identities do not imply a single published total parameter count for the complete system.[1][3][4]

## Skill programs and annotation

Training requires demonstrations paired with programs for the subtask taking place in each time window. The annotation pipeline first samples demonstrations and writes programs against predefined primitive APIs. A coordinating agent identifies recurring routines and turns them into reusable skills. After the library is frozen, the pipeline reuses cached programs when the observed contact and motion pattern matches; otherwise it requests a new annotation.[1][2]

The resulting library contains 50 skills: 23 for YAM robot demonstrations and 27 for egocentric human demonstrations. A skill is a Python function over lower-level robot primitives. Examples include folding a cloth edge, transporting an object with both hands, pouring into a target, and wiping a surface. A function can take different object names and motion arguments, allowing the same routine to label multiple demonstrations.[1][2]

During training, the code stream contains a conditioning prompt and an active program slice for the current subtask. The model supervises the slice and uses a compact memory of prior slices to represent progress through the episode. This supplies task structure beyond what a single camera frame reveals.[1]

### Default and hybrid execution

The default policy executes the action expert's predicted chunk. The generated code acts as a plan that the other experts read; the robot does not directly run that program in this mode.[1][3]

Hybrid execution considers the generated slice at each replanning step. It can execute code through a library of perception and control primitives when the slice passes checks for task stage, dependencies, syntax, permitted calls, and nonempty work. Otherwise, it falls back to the action chunk. Passing these checks does not establish that a program has correct arguments or will complete the task.[1][2]

The simulation implementation uses perception components including Molmo, SAM 3, and Contact-GraspNet alongside RoboTwin's control interfaces. The paper states that evaluation programs and primitives do not access privileged simulator state. Its demonstration collection does use privileged object states and annotated grasps to make collection more efficient.[1]

## Training data

The authors pretrain AW-0 on bimanual robot demonstrations and egocentric human manipulation data. Both sources provide instructions and aligned program slices. The paper reports the following corpus statistics.[1]

| Source | Episodes | Tasks | Duration |
| --- | ---: | ---: | ---: |
| YAM robot teleoperation | 73,101 | 279 | About 1,919.3 hours |
| Egocentric human manipulation | 175,541 | 327 | About 993.9 hours |
| Combined | 248,642 | 606 | About 2,913 hours |

YAM recordings use three RGB cameras. Human demonstrations use one head-mounted camera, with its view replicated across the model's three input slots; tracked hand motion is retargeted to dexterous-hand joint targets. The framework uses a shared 64-dimensional state and action representation for the real-world data, while its RoboTwin implementation uses the simulator's 14-dimensional joint representation.[1][3]

For downstream tasks, the pipeline annotates task demonstrations under the frozen skill library, followed by joint fine-tuning on program, video, and action targets. This is a demonstration-based training procedure related to [imitation learning](https://aiwiki.ai/wiki/imitation_learning); the reported system does not learn continuously from its own deployed interactions.[1]

## Reported evaluations

The results below are the authors' experiments. The paper compares particular trained configurations and evaluation protocols; the numbers are not a general ranking of [vision-language-action models](https://aiwiki.ai/wiki/vision_language_action_model) or a guarantee of performance on other robots.[1]

### RoboTwin 2.0 simulation

The paper evaluates 50 tasks with 50 rollouts per task. Training uses 50 clean demonstrations per task. The clean setting has controlled scene conditions; the random setting varies backgrounds, textures, lighting, tabletop height, and distractors.[1]

| Method | Clean success rate | Random success rate | Average |
| --- | ---: | ---: | ---: |
| pi0.5 | 54.9% | 27.7% | 41.3% |
| DreamZero | 33.6% | 17.6% | 25.6% |
| EgoScale | 26.2% | 2.9% | 14.5% |
| WLA | 64.8% | 3.6% | 34.2% |
| AW-0, default | 80.8% | 20.6% | 50.7% |
| AW-0, hybrid | 63.1% | 29.2% | 46.2% |

The default configuration has the highest average in this comparison, but its performance drops substantially under scene randomization. Its 20.6% random-setting success rate is below pi0.5's 27.7%. The hybrid configuration performs better in that setting while scoring lower in clean scenes.[1]

A qualification in the paper's Appendix J.2 concerns training data: the default configuration uses demonstrations collected with RoboTwin's native motion planner, while the hybrid configuration uses code-as-policy demonstration collection. The comparison therefore changes both data collection and execution. It does not isolate the effect of switching execution modes on an otherwise identical simulation policy.[1]

The released evaluation guide has a separate default of 100 episodes per task and setting for a complete benchmark run. That software default should not be confused with the paper's 50-rollout protocol.[1][5]

### Physical robot experiments

The authors evaluate eight manipulation tasks across a YAM station with parallel grippers and a Tianji-Sharpa platform with dexterous hands. The tasks include arranging fruit, packing a backpack, replacing a lightbulb, folding towels, dealing cards, and manipulating a scoreboard. They use 100 demonstrations per task for post-training and evaluate three training seeds with 16 rollouts each.[1]

The metric is an average task-progress rubric score expressed as a percentage. It is not the fraction of complete successes used in the simulation table.[1]

| Method | Average real-world rubric score |
| --- | ---: |
| pi0.5 | 43.6% |
| DreamZero | 46.0% |
| EgoScale | 35.9% |
| WLA | 39.9% |
| AW-0 | 71.1% |

On the YAM towel-folding task, the authors also report a hybrid score of 90.6%, compared with 84.4% for action-chunk execution using the same post-trained model. Real-world hybrid evaluation was limited to YAM; the paper does not establish the same result for dexterous-hand code execution.[1][2]

## Released resources and reproduction

The official repository includes pretraining and post-training code, code annotation tools, RoboTwin evaluation, and real-robot support. It links a pretrained checkpoint and a RoboTwin post-training release with separate default and hybrid weights. The pretrained checkpoint is a starting point for task-specific post-training, rather than a ready-to-use policy for an arbitrary robot or instruction.[3][4][5]

The release does not include the pretraining corpora or the Cosmos-Predict2.5-2B initialization checkpoint used to start pretraining. Reproducing the complete pretraining run from scratch therefore requires resources beyond the published code and AW-0 checkpoint.[3][6]

Installation documentation specifies Python 3.10, CUDA 12.8, PyTorch 2.7.1, and H100-class GPUs; training scripts default to eight GPUs per node. It also lists separately downloaded components, including the video autoencoder, instruction encoder, code-model body, and vision tower. These are the maintainers' documented environment and defaults, not a verified minimum hardware requirement.[6]

The real-world guide includes a YAM model server and robot-side client. It documents training for Tianji-Sharpa but states that a corresponding deployment implementation is not included. Tactile data in the Tianji-Sharpa recordings supports annotation tools, rather than serving as an input to the learned model.[7]

The repository uses the BSD 2-Clause license. The pretrained model card also declares BSD 2-Clause and states that external components retain their own licenses.[4][8]

## Limitations

AW-0 depends on the quality of its automatic annotations and the coverage of its fixed skill library. A program may choose a suitable skill but bind it to the wrong object or use incorrect arguments. The authors' examples also include unstable grasping, misaligned insertion, tool collisions, and loss of contact.[1][2]

Visual distribution shift remains a substantial weakness in the reported simulation results. Hybrid execution can use more structured control, but errors in its perception and control primitives also introduce failures. The authors identify arbitration based on expected execution reliability as future work; the current checks largely establish whether code is admissible, rather than whether it is preferable to the predicted action.[1]

The research demonstrates a particular combination of program generation, [world modeling](https://aiwiki.ai/wiki/world_model), and learned control. Its published experiments do not establish unrestricted autonomous manipulation, continual self-improvement, or reliable operation across arbitrary [robotics](https://aiwiki.ai/wiki/robotics) platforms.[1]

## References

1. Liu, Zhuoyang, et al. ["Agentic World Action Models"](https://arxiv.org/html/2610.30136v1). arXiv:2610.30136v1, October 21, 2026. Sections 2-3 and Appendices B, J, and L.
2. AW-0 authors. ["Agentic World Action Models," official project page](https://agentic-wam.github.io/). Architecture, demonstrations, evaluation tables, and limitations. Accessed November 4, 2026.
3. ZhuoyangLiu2005. ["AW-0: Agentic World Action Models," official repository README](https://github.com/ZhuoyangLiu2005/agentic-wam/blob/main/README.md). Release scope, implementation, and model links. Accessed November 4, 2026.
4. miniFranka. ["AW-0 pretrained checkpoint (yam + ego)"](https://huggingface.co/miniFranka/agentic-wam-pretrain-yamego3k-soup-e1). Model card and component licenses. Accessed November 4, 2026.
5. AW-0 maintainers. ["RoboTwin," evaluation and training guide](https://github.com/ZhuoyangLiu2005/agentic-wam/blob/main/docs/ROBOTWIN.md). Accessed November 4, 2026.
6. AW-0 maintainers. ["Installation"](https://github.com/ZhuoyangLiu2005/agentic-wam/blob/main/docs/INSTALL.md). Environment requirements and checkpoint availability. Accessed November 4, 2026.
7. AW-0 maintainers. ["Real-world robots: YAM and Tianji + Sharpa"](https://github.com/ZhuoyangLiu2005/agentic-wam/blob/main/docs/REALWORLD.md). Supported training and deployment paths. Accessed November 4, 2026.
8. Liu, Zhuoyang. ["BSD 2-Clause License," agentic-wam repository](https://github.com/ZhuoyangLiu2005/agentic-wam/blob/main/LICENSE). Copyright 2026.