---
license: bsd-3-clause
size_categories:
- 100K<n<1M
task_categories:
- time-series-forecasting
pretty_name: AutoWorldModel-Bench
tags:
- world-model
- game-simulation
- reinforcement-learning
- timeseries
configs:
- config_name: asteroids
  data_files:
  - split: train
    path: data/asteroids/train.parquet
  - split: validation
    path: data/asteroids/val.parquet
  - split: test
    path: data/asteroids/test.parquet
  - split: scenario
    path: data/asteroids/scenario.parquet
- config_name: breakout
  data_files:
  - split: train
    path: data/breakout/train.parquet
  - split: validation
    path: data/breakout/val.parquet
  - split: test
    path: data/breakout/test.parquet
  - split: scenario
    path: data/breakout/scenario.parquet
- config_name: frogger
  data_files:
  - split: train
    path: data/frogger/train.parquet
  - split: validation
    path: data/frogger/val.parquet
  - split: test
    path: data/frogger/test.parquet
  - split: scenario
    path: data/frogger/scenario.parquet
- config_name: kong
  data_files:
  - split: train
    path: data/kong/train.parquet
  - split: validation
    path: data/kong/val.parquet
  - split: test
    path: data/kong/test.parquet
  - split: scenario
    path: data/kong/scenario.parquet
- config_name: platformer
  data_files:
  - split: train
    path: data/platformer/train.parquet
  - split: validation
    path: data/platformer/val.parquet
  - split: test
    path: data/platformer/test.parquet
  - split: scenario
    path: data/platformer/scenario.parquet
- config_name: pong
  default: true
  data_files:
  - split: train
    path: data/pong/train.parquet
  - split: validation
    path: data/pong/val.parquet
  - split: test
    path: data/pong/test.parquet
  - split: scenario
    path: data/pong/scenario.parquet
- config_name: racer
  data_files:
  - split: train
    path: data/racer/train.parquet
  - split: validation
    path: data/racer/val.parquet
  - split: test
    path: data/racer/test.parquet
  - split: scenario
    path: data/racer/scenario.parquet
- config_name: snake
  data_files:
  - split: train
    path: data/snake/train.parquet
  - split: validation
    path: data/snake/val.parquet
  - split: test
    path: data/snake/test.parquet
  - split: scenario
    path: data/snake/scenario.parquet
---

# AutoWorldModel-Bench

Game state sequences for training and evaluating action-conditioned world models.
8 classic game environments with a unified entity-based tensor schema, deterministic train/val/test/scenario splits, and 152,000 total episodes.

This dataset accompanies the [AutoWorldModel-Bench](https://github.com/AutoWorldModelBench/Benchmark) benchmark for evaluating frontier coding agents on open-ended world-model research.

Paper: [AutoWorldModel-Bench: A State-Centric Benchmark for Automated World-Model Research](https://huggingface.co/papers/2608.11216) | Project: [AutoWorldModelBench](https://electronicarts.github.io/AutoWorldModelBench/)

## Dataset Structure

```
data/                                # Parquet training data
└── {game}/
    ├── train.parquet                # 10,000 episodes
    ├── val.parquet                  #  3,000 episodes
    ├── test.parquet                 #  3,000 episodes
    ├── scenario.parquet             #  3,000 episodes
    └── meta.json                    # max_entities, dimensions, total_frames

scenarios/                           # Curated scenario archives (tar.gz per game)
└── {game}.tar.gz
    └── {game}/
        └── {scenario_name}/         # e.g. ball_hits_paddle, ship_dies
            └── data_ep_{id}/
                ├── frames.jsonl.gz  # Per-frame entity states
                ├── manifest.json    # Game schema, entity kinds, action/global fields
                ├── meta.json        # Episode metadata, event info, rollout params
                └── rollout.mp4      # Visual replay
```

## Games

| Game | Max Entities | Total Frames | Size | Data Version |
|------|:---:|---:|---:|:---:|
| asteroids | 20 | 5.6M | 0.9 GB | v2 |
| breakout | 52 | 33.0M | 0.7 GB | v2 |
| frogger | 28 | 6.2M | 0.8 GB | v2 |
| kong | 16 | 23.0M | 0.5 GB | v2 |
| platformer | 24 | 10.6M | 0.3 GB | v2 |
| pong | 5 | 42.5M | 1.7 GB | v1 |
| racer | 6 | 21.1M | 0.9 GB | v1 |
| snake | 48 | 15.9M | 0.2 GB | v1 |

**Total: 152,000 episodes (19,000 per game), 158.0M frames**

All games share a unified tensor schema: `registry_dim=34`, `state_dim=23`.

Each game has 10,000 train / 3,000 val / 3,000 test / 3,000 scenario episodes.

### Data Collection Policy

v2 games (asteroids, breakout, frogger, kong, platformer) use a 3-policy mix for diverse behavioral coverage:
- **Random** — uniform random actions
- **Heuristic** — hand-crafted game-specific strategies
- **RL checkpoint** — DQN/PPO agents at various training stages

v1 games (pong, racer, snake) use a 50/50 heuristic + random mix.

## Scenarios

Hand-picked and categorized episodes that isolate specific game events — sourced from the scenario split and augmented with synthetically collected episodes. Each episode captures a short rollout around a key event (e.g., collision, scoring, death) with history context.

| Game | Scenarios | Episodes | Archive Size |
|------|---:|---:|---:|
| asteroids | 14 | 420 | 41 MB |
| breakout | 6 | 160 | 9 MB |
| frogger | 5 | 180 | 27 MB |
| kong | 5 | 180 | 7 MB |
| platformer | 5 | 160 | 10 MB |
| pong | 15 | 460 | 14 MB |
| racer | 5 | 140 | 6 MB |
| snake | 5 | 160 | 11 MB |

Each episode contains 32 history frames + 1 pre-event frame, followed by up to 20 rollout frames (including the event). Rollouts are truncated early on termination.

Each game includes a `same_state_different_actions` scenario that tests action-conditioning by replaying the same initial state with varied actions.

### Downloading scenarios

```python
from huggingface_hub import hf_hub_download
import tarfile

path = hf_hub_download(
    "AutoWorldModel/AutoWorldModelBench",
    "scenarios/pong.tar.gz",
    repo_type="dataset",
)
with tarfile.open(path) as tar:
    tar.extractall("./scenarios")
# ./scenarios/pong/ball_hits_left_paddle_moving/data_ep_.../frames.jsonl.gz
```

## Tensor Schema

Each Parquet row stores one episode as serialized numpy arrays:

| Tensor | Shape | Description |
|--------|-------|-------------|
| registry | (N, 34) | Static entity properties (collider, scale, physics) |
| states | (T, N, 23) | Dynamic: pos_xy, alive, vel_xy, gameplay(14), pos_history(4) |
| actions | (T, 7) | Unified action vector (7 fields across all games) |
| globals | (T, 17) | Global game state (17 fields across all games) |
| terminals | (T,) | Episode termination flags |
| mutable_mask | (N,) | Which entities are prediction targets |
| type_ids | (N,) | Global entity type IDs |
| slot_ids | (N,) | Original 64-slot table indices |
| rewards | (T,) | Per-frame rewards |

Where N = max_entities (game-specific), T = episode length.

## Usage

### With the `datasets` library

```python
from datasets import load_dataset

ds = load_dataset("AutoWorldModel/AutoWorldModelBench", "pong")
print(ds["train"][0].keys())
```

### Direct download with `huggingface_hub`

```python
from huggingface_hub import hf_hub_download
import pyarrow.parquet as pq
import numpy as np, json

path = hf_hub_download(
    "AutoWorldModel/AutoWorldModelBench",
    "data/pong/train.parquet",
    repo_type="dataset",
)

table = pq.read_table(path)
row = table.to_pydict()
states = np.frombuffer(
    row["states"][0], dtype=row["states_dtype"][0]
).reshape(json.loads(row["states_shape"][0]))
```

## Evaluation

Models trained on this data are evaluated on multi-step open-loop rollouts at horizons {1, 10, 20}:

- **Position L1**: Mean absolute error on entity (x, y) positions (lower is better)
- **Alive F1**: F1 score on entity alive/dead classification
- **Composite**: `0.9 * (1 - pos_l1) + 0.1 * alive_f1` (higher is better)

## Citation

If you use this dataset, please cite:

```bibtex
@misc{autoworldmodelbench2025,
  title={AutoWorldModel-Bench: A Benchmark for Evaluating Coding Agents on World Model Research},
  author={AutoWorldModel Team},
  year={2025},
  url={https://github.com/AutoWorldModelBench/Benchmark}
}
```