README.md

---
license: cc-by-4.0
viewer: false
tags:
  - reinforcement-learning
  - offline-reinforcement-learning
  - unity-ml-agents
  - minari
  - causal-gpt-rl
---

# Causal GPT-RL — Unity ML-Agents trajectories

Recorded Unity ML-Agents trajectories packaged as
[Minari](https://minari.farama.org) datasets — **offline-RL datasets** spanning
continuous and discrete action spaces. Any offline-RL method can train on them; we
built them to develop **Causal GPT-RL**, our new approach that works across both
space types. All eight environments ship an `expert` tier and a full
**quality ladder** (`expert` + calibrated `medium`/`simple`) synthesized by
degrading the stock policy — Gaussian action-noise ranges for the continuous
scenes, softmax-temperature ranges on the policy logits for the discrete goal
games.

Tiers are keyed to Minari-normalized skill between a random-policy `0.0` anchor
and the stock expert `1.0` — **targets `simple` 0.60 / `medium` 0.80 / `expert`
1.0** (envs land at simple 0.58–0.62, medium 0.77–0.85). The degradation is not a
single constant: it is drawn **per episode from a calibrated range** (the group/team
scenes — DungeonEscape, SoccerTwos — draw per match instead), so each tier's *mean*
hits its target while the episodes span a continuous band of skill instead of piling
at one point.

**한국어 카드 / Korean edition** — this card in full:
[README.ko.md](https://huggingface.co/datasets/ccnets/causal-gpt-rl-unity-datasets/blob/main/README.ko.md)

**Companion repos**
- Model-removed Unity builds + matching stock ONNX policies:
  [ccnets/causal-gpt-rl-unity-envs](https://huggingface.co/datasets/ccnets/causal-gpt-rl-unity-envs)
- Causal GPT-RL policy checkpoints (Pyramids, PushBlock):
  [ccnets/causal-gpt-rl-unity](https://huggingface.co/ccnets/causal-gpt-rl-unity)

## Data-quality notice — action labels (resolved 2026-08-01)

**Every dataset in this repo now carries the action Unity actually executed.**
ML-Agents agents decide only every *k*-th physics step and Unity repeats the last
decision through the gap; the collector stored a placeholder `0` on those
in-between steps instead of the action still being repeated, so the action column
disagreed with the policy that produced the trajectory. **Observations, rewards,
terminations and the trajectories themselves were never affected**, so every
published return, step-reward and tier calibration held throughout.

The collector was fixed on **2026-07-30** — it now carries each agent's last real
decision forward across a gap. All 21 affected datasets have been re-recorded and
replaced: the twelve discrete-environment tiers on 2026-07-30, the nine continuous
ones on 2026-08-01. Share of rows that carried a placeholder in the files they
replaced (tier range: `expert` – `simple`):

| env | placeholder rows (replaced files) | status |
|---|---:|---|
| the four discrete envs — `pushblock`, `dungeon-escape`, `soccer-twos`, `pyramids` | 3–72% | **all twelve tiers re-recorded 2026-07-30** |
| `crawler` | 0.57–1.03% | **all three tiers re-recorded 2026-08-01** |
| `walker` | 1.05–1.62% | **all three tiers re-recorded 2026-08-01** |
| `3dball-hard` | 0.02–1.46% | **all three tiers re-recorded 2026-08-01** |
| `worm` | 0% | never affected — its agents never terminate |

One cause, two very different rates. In the discrete goal games the gap steps are
recorded like any other, so the placeholder simply follows the decision period and
comes to dominate the column. In the continuous scenes a step on which *no* agent
has either a decision or a terminal observation is dropped whole, so a pure gap step
never enters the data at all — one survives only when another agent in the scene
happened to terminate on that same step. The rate there tracks the scene's reset
frequency and stays under 2%. `worm` is the limiting case of exactly that: its
agents never terminate (every episode runs the full 1000 steps), so no gap step ever
survives and its three tiers were clean as published.

Because a collection run is not bit-reproducible — agents finish episodes
asynchronously, so the boundaries fall differently — each re-recorded tier has
slightly different episode/transition counts and tier metrics than the file it
replaced. Bands and noise seed were left untouched; this was a label repair, not a
recalibration, and the metric movement is sampling noise rather than a change in the
recorded policy. The tables below carry the new figures throughout.

## Contents

| Dataset id | Episodes | Transitions | Observation | Action |
|---|---:|---:|---|---|
| `unity/crawler/expert-v0` | 1,043 | 1,000,000 | `Tuple(Box(126), Box(32))` | `Box(20, [-1, 1])` |
| `unity/crawler/medium-v0` | 1,120 | 1,000,000 | `Tuple(Box(126), Box(32))` | `Box(20, [-1, 1])` |
| `unity/crawler/simple-v0` | 1,325 | 1,000,000 | `Tuple(Box(126), Box(32))` | `Box(20, [-1, 1])` |
| `unity/pushblock/expert-v0` | 53,039 | 1,000,000 | `Tuple(Box(105), Box(105))` | `Discrete(7)` |
| `unity/pushblock/medium-v0` | 39,033 | 1,010,016 | `Tuple(Box(105), Box(105))` | `Discrete(7)` |
| `unity/pushblock/simple-v0` | 26,666 | 1,010,016 | `Tuple(Box(105), Box(105))` | `Discrete(7)` |
| `unity/soccer-twos/expert-v0` | 14,692 | 1,001,676 | ego `Dict` wrapping `Tuple(Box(264), Box(72))` | ego `Dict` wrapping `MultiDiscrete([3, 3, 3])` |
| `unity/soccer-twos/medium-v0` | 12,940 | 1,002,368 | ego `Dict` wrapping `Tuple(Box(264), Box(72))` | ego `Dict` wrapping `MultiDiscrete([3, 3, 3])` |
| `unity/soccer-twos/simple-v0` | 11,820 | 1,001,564 | ego `Dict` wrapping `Tuple(Box(264), Box(72))` | ego `Dict` wrapping `MultiDiscrete([3, 3, 3])` |
| `unity/dungeon-escape/expert-v0` | 35,505 | 1,007,206 | ego `Dict` wrapping `Tuple(Box(10), Box(360), Box(1))` | ego `Dict` wrapping `Discrete(7)` |
| `unity/dungeon-escape/medium-v0` | 28,314 | 1,012,457 | ego `Dict` wrapping `Tuple(Box(10), Box(360), Box(1))` | ego `Dict` wrapping `Discrete(7)` |
| `unity/dungeon-escape/simple-v0` | 22,542 | 1,001,594 | ego `Dict` wrapping `Tuple(Box(10), Box(360), Box(1))` | ego `Dict` wrapping `Discrete(7)` |
| `unity/3dball-hard/expert-v0` | 1,011 | 1,000,008 | `Tuple(Box(27), Box(18))` | `Box(2)` |
| `unity/3dball-hard/medium-v0` | 1,311 | 1,000,008 | `Tuple(Box(27), Box(18))` | `Box(2)` |
| `unity/3dball-hard/simple-v0` | 1,701 | 1,000,008 | `Tuple(Box(27), Box(18))` | `Box(2)` |
| `unity/pyramids/expert-v0` | 5,392 | 1,000,000 | `Tuple(Box(56), Box(56), Box(56), Box(4))` | `Discrete(5)` |
| `unity/pyramids/medium-v0` | 4,174 | 1,000,000 | `Tuple(Box(56), Box(56), Box(56), Box(4))` | `Discrete(5)` |
| `unity/pyramids/simple-v0` | 3,065 | 1,000,000 | `Tuple(Box(56), Box(56), Box(56), Box(4))` | `Discrete(5)` |
| `unity/worm/expert-v0` | 1,000 | 1,000,000 | `Box(64)` | `Box(9, [-1, 1])` |
| `unity/worm/medium-v0` | 1,000 | 1,000,000 | `Box(64)` | `Box(9, [-1, 1])` |
| `unity/worm/simple-v0` | 1,000 | 1,000,000 | `Box(64)` | `Box(9, [-1, 1])` |
| `unity/walker/expert-v0` | 1,464 | 1,000,000 | `Box(243)` | `Box(39, [-1, 1])` |
| `unity/walker/medium-v0` | 1,695 | 1,000,000 | `Box(243)` | `Box(39, [-1, 1])` |
| `unity/walker/simple-v0` | 2,306 | 1,000,000 | `Box(243)` | `Box(39, [-1, 1])` |

All environments, datasets, and stock policies use **ML-Agents `release_23`**.
Each dataset is stored at `<name>/<tier>/data/main_data.hdf5` with a sibling
`metadata.json` (`minari_version` 0.5.3). SoccerTwos and DungeonEscape use an
ego-agent schema — `observations["agents"]["agent_0"]`,
`actions["agents"]["agent_0"]` — one ego episode per physical agent; split by
`match_id` (see [docs/reproduction.md](docs/reproduction.md)).

## Loading

```python
from pathlib import Path
from huggingface_hub import snapshot_download
import minari

snapshot_download(
    repo_id="ccnets/causal-gpt-rl-unity-datasets",
    repo_type="dataset",
    allow_patterns="worm/**",                       # one env; drop to fetch all
    local_dir=Path.home() / ".minari" / "datasets" / "unity",
)
dataset = minari.load_dataset("unity/worm/expert-v0")
# calibrated tiers: minari.load_dataset("unity/worm/medium-v0" | ".../simple-v0")
print(dataset.observation_space, dataset.action_space)
```

## Quality ladders

**Why these tiers look the way they do.** In a normal RL pipeline, `medium`/`simple`
data would come from *early training checkpoints* on the way to the expert. We don't
have those checkpoints — only the final expert policy — so each tier is **reduced
backward from the expert**: instead of one constant perturbation (a single degraded
point), every episode draws its skill from a calibrated *range*, so the tier
reproduces the *distribution* of skill a checkpoint spread would have.

Each ladder is a monotone skill sequence built from ONE stock policy: `expert` is
the unmodified policy, `medium`/`simple` degrade it progressively. The degradation
is calibrated so the tier mean hits its normalized target while episodes cover a
continuous skill band (seed 2310000):

- **continuous** scenes (crawler, worm, walker, 3dball-hard) add Gaussian action
  noise, `noise_std` sampled per episode from a calibrated range;
- **discrete goal games** sample the policy's own action distribution via
  `softmax(logits/T)` on the exposed discrete logits — higher `T` picks plausible
  2nd/3rd-best actions (smooth, in-distribution degradation, unlike epsilon-style
  uniform-random swaps which are bimodal and off-distribution). PushBlock and
  Pyramids each sample `T` **per episode** from a calibrated range (each episode
  its own skill level, like a spread of early-training checkpoints);
- **cooperative** discrete DungeonEscape samples a softmax temperature `T` **per
  group per match** from a calibrated range — all three agents in a group share one
  `T`, so each match is one coherent skill level (like an early-training checkpoint);
  competitive self-play SoccerTwos samples a softmax temperature `T` **per team per
  match** from a (wider) calibrated range — the two teams draw independently, so each
  match pairs two skill levels (a random gap, like cross-checkpoint league play).

Normalization is `(candidate − random) / (expert − random)` on each env's tier
metric.

| env | tier metric | medium | simple | noise method |
|---|---|---:|---:|---|
| `crawler` | episode return | 0.83 | 0.62 | per-episode `noise_std` range |
| `worm` | episode return | 0.80 | 0.60 | per-episode `noise_std` range |
| `walker` | episode return | 0.85 | 0.59 | per-episode `noise_std` range |
| `3dball-hard` | episode return | 0.77 | 0.58 | per-episode `noise_std` range |
| `pushblock` | step-reward | 0.80 | 0.60 | per-episode softmax temperature range |
| `pyramids` | step-reward | 0.79 | 0.60 | per-episode softmax temperature range |
| `dungeon-escape` | step-reward | 0.80 | 0.61 | per-group softmax temperature range |
| `soccer-twos` | match score | ≈0.80 | ≈0.60 | per-team softmax temperature range |

`soccer-twos` figures are approximate: self-play stays balanced, so tier skill
cannot be read off the shipped returns and comes from side-swapped calibration.
Sparse-reward scenes (pyramids, pushblock, dungeon, soccer) have a physically
bimodal per-episode outcome (solve vs. time-out), so the episode-return histogram
barely separates the tiers. For the goal games (`pushblock`, `pyramids`, `dungeon-escape`) the tier metric is
therefore **mean step-reward** = `return / episode length`, which grades *how
efficiently* the goal is reached — a continuous skill signal — normalized
`expert = 1 / random = 0` against the shipped `expert-v0` step-reward anchor
(pushblock 0.3537, pyramids 0.01263, dungeon-escape 0.01936). `simple` targets 0.60
and the shipped tiers sit at **0.58–0.62** (SoccerTwos, scored by side-swapped match
score rather than step-reward, is approximate); `medium` spans 0.77–0.85.

**How precisely these are known.** Every tier figure is a sample mean over the
episodes of one recording, so it carries sampling error. The return-scored
continuous scenes are the loosest, because a million transitions buys only one to
two thousand episodes there: measured over the shipped files that is about ±0.01
normalized for 3DBallHard, ±0.015 for Crawler and ±0.03 for Walker, whose
per-episode return has a standard deviation roughly as large as its mean.

Those are *within-run* errors. The run-to-run spread has also been measured
directly: the 2026-07-30 label repair re-recorded the continuous scenes from
**identical bands and seed**, so the two recordings differ only by the collection
run itself. Across the six degraded tiers the normalized figure moved by
0.01–0.03, and both Walker `medium` and 3DBallHard `medium` moved a full 0.03 —
three times the within-run figure quoted above for 3DBallHard. **Treat 0.03 as
the reproducibility of a continuous-scene tier number.**

Read the second decimal as indicative rather than exact — a tier sitting at 0.83
instead of 0.80 is within what re-recording the *same* band moves, not evidence of
a differently-calibrated band. The bands themselves are fixed constants of the
recipe (listed per env below) and are the reproducible part.

"termination rate" below = fraction of episodes ending on the env's terminal
condition — a fall for Crawler/Walker/3DBallHard, a solved push for PushBlock,
maze solve ("reach") for Pyramids; Worm never terminates (truncated at 1000).

<details>
<summary><b>Per-environment ladder tables</b> — exact ranges, anchors, mean returns, rates</summary>

**Crawler** — anchors: expert 2575.8405, random −0.88

| tier | norm. return | noise_std range | mean return | term. rate | mean ep length |
|---|---:|---:|---:|---:|---:|
| `expert-v0` | 1.00 | -- | 2575.8405 | 0.073 | 958.77 |
| `medium-v0` | ≈0.83 | 0.15–0.23 | 2141.5175 | 0.193 | 892.86 |
| `simple-v0` | ≈0.62 | 0.21–0.32 | 1605.4283 | 0.435 | 754.72 |

**Worm** — anchors: expert 1044.1063, random 0.80 (never terminates)

| tier | norm. return | noise_std range | mean return | term. rate | mean ep length |
|---|---:|---:|---:|---:|---:|
| `expert-v0` | 1.00 | -- | 1044.1063 | 0.000 | 1000.00 |
| `medium-v0` | ≈0.80 | 0.09–0.15 | 839.4910 | 0.000 | 1000.00 |
| `simple-v0` | ≈0.60 | 0.15–0.22 | 632.4776 | 0.000 | 1000.00 |

**Walker** — anchors: expert 1354.5654, random −0.49 (high intrinsic return variance)

| tier | norm. return | noise_std range | mean return | term. rate | mean ep length |
|---|---:|---:|---:|---:|---:|
| `expert-v0` | 1.00 | -- | 1354.5654 | 0.525 | 683.06 |
| `medium-v0` | ≈0.85 | 0.05–0.11 | 1154.9421 | 0.651 | 589.97 |
| `simple-v0` | ≈0.59 | 0.09–0.15 | 797.0197 | 0.827 | 433.65 |

**3DBallHard** — anchors: expert 98.9095, random 0.84 (capped balance: near-bimodal)

| tier | norm. return | noise_std range | mean return | term. rate | mean ep length |
|---|---:|---:|---:|---:|---:|
| `expert-v0` | 1.00 | -- | 98.9095 | 0.003 | 989.13 |
| `medium-v0` | ≈0.77 | 0.28–0.38 | 75.8680 | 0.373 | 762.78 |
| `simple-v0` | ≈0.58 | 0.31–0.44 | 58.0994 | 0.627 | 587.89 |

**PushBlock** — tier metric is **mean step-reward** (`return / length`); step-reward anchors: expert 0.353699 (shipped `expert-v0`, 53,039 ep), random ≈−0.0005 (soft). Each tier samples `T` **per episode** from a calibrated range (each episode its own skill level, like a spread of early-training checkpoints). Higher `T` still solves but wanders more, so the return stays high (≈4.9) while step-reward falls with efficiency. term. rate = solved.

| tier | norm. step-reward | `T` (per episode) | mean step-reward | mean return | solved rate | mean ep length |
|---|---:|---:|---:|---:|---:|---:|
| `expert-v0` | 1.00 | -- | 0.353699 | 4.972780 | ≈1.00 | 18.85 |
| `medium-v0` | 0.80 | `U(2.1, 3.2)` | 0.282037 | 4.961591 | 0.997 | 25.88 |
| `simple-v0` | 0.60 | `U(3.25, 4.75)` | 0.213119 | 4.942463 | 0.996 | 37.88 |

**Pyramids** — tier metric is **mean step-reward** (`return / length`); step-reward anchors: expert 0.012633 (shipped `expert-v0`, 5,392 ep), random −0.001 (sparse: policy always times out at random). Each tier samples `T` **per episode** from a calibrated range (each episode its own skill level, like a spread of early-training checkpoints). Higher `T` reaches the goal less directly (longer episodes) so step-reward falls while return stays near expert. term. rate = mazes reached/solved.

| tier | norm. step-reward | `T` (per episode) | mean step-reward | mean return | reach rate | mean ep length |
|---|---:|---:|---:|---:|---:|---:|
| `expert-v0` | 1.00 | -- | 0.012633 | 1.797730 | 0.9911 | 185.46 |
| `medium-v0` | 0.79 | `U(2.7, 4.9)` | 0.009784 | 1.742249 | 0.990 | 239.58 |
| `simple-v0` | 0.60 | `U(4.8, 7.1)` | 0.007201 | 1.636223 | 0.981 | 326.26 |

**DungeonEscape** — cooperative goal game; tier metric is **mean step-reward** (`return / length`); step-reward anchors: expert 0.019355 (shipped `expert-v0`, 35,505 ego ep), random ≈0.00015. A softmax temperature `T` is sampled **per cooperative group per match** from a calibrated range and shared by all three agents (one coherent skill level per match, like an early-training checkpoint); higher `T` reaches the exit less efficiently so step-reward falls while the group still often succeeds. Group success `any(agent_return > 0)` (`group_metadata.jsonl`) therefore stays high across tiers and no longer separates them — step-reward does.

| tier | norm. step-reward | `T` range (per group) | mean step-reward | group success | mean ep length |
|---|---:|---|---:|---:|---:|
| `expert-v0` | 1.00 | stock (no noise) | 0.019355 | 0.9604 | 28.37 |
| `medium-v0` | 0.80 | `U(1.5, 3.0)` | 0.015446 | 0.9183 | 35.76 |
| `simple-v0` | 0.61 | `U(3.0, 4.0)` | 0.011950 | 0.8585 | 44.43 |

**SoccerTwos** — tier metric is **side-swapped match score** vs the fixed stock policy (self-play, so mean shipped return ≈ −0.04 for both tiers and does not track skill; figures are calibration estimates). Each **team** draws a softmax temperature `T` **independently per match** from a (wide) calibrated range on the exposed MultiDiscrete logits, shared by its two agents — so each match pairs two independently-drawn skill levels (a random gap = cross-checkpoint league play). A tier is set by the ego team's own drawn `T`; the norm is that band's mean side-swapped match score vs the fixed expert. term. rate = matches always terminate.

| tier | approx. norm. skill | `T` (per team/match) | matches | mean ep length |
|---|---:|---|---:|---:|
| `expert-v0` | 1.00 | stock (no noise) | 3,673 | 68.18 |
| `medium-v0` | ≈0.80 | `U(1.3, 2.6)` | 3,235 | 77.46 |
| `simple-v0` | ≈0.60 | `U(2.1, 3.4)` | 2,955 | 84.73 |

</details>

## Episode lengths

Offline-RL and sequence models need the *distribution* of episode length, not just
its mean: it sets the context window, how much padding is wasted, and whether
length bucketing is worth it. Measured over the published files — `cv` is
`sd / mean`, a quick read on how heavy the tail is.

The datasets fall into two regimes that behave very differently.

- **Locomotion scenes** (Crawler, Worm, Walker, 3DBallHard) run until the agent
  falls and truncate at 1000 steps, so the stronger tiers pile up against that cap:
  Crawler `expert` and 3DBallHard `expert`/`medium` have a *median* of exactly 1000.
  Read their mean ± sd as a spike at the cap with a left tail, not a bell curve —
  Crawler `expert` still reaches down to a 2-step episode. Worm is the degenerate
  case: its agents never terminate, so all 3,000 of its episodes are exactly 1000
  steps and its sd is exactly 0 in every tier.
- **Goal games** (PushBlock, Pyramids, DungeonEscape, SoccerTwos) end when the goal
  is reached, so they are short and right-skewed. PushBlock is the extreme — mean
  18.85, median 15, max 1000, `cv` near 2. Padding a PushBlock batch to the longest
  episode wastes roughly 50x; bucket by length instead.

Degradation moves the two regimes in **opposite directions**. Lower tiers fall
sooner in the locomotion scenes (Crawler 958.77 → 892.86 → 754.72) but take longer
to reach the goal in the goal games (PushBlock 18.85 → 25.88 → 37.88). If you use
episode length as a feature or to size buffers, that sign flip matters.

**DungeonEscape is the only environment that exceeds 1000 steps**, and only barely:
3 of its 35,505 `expert` episodes run past the cap, the longest at 1,213 steps. Its
other two tiers stay under. Everywhere else 1000 is a hard ceiling — the locomotion
scenes, PushBlock and Pyramids all reach it exactly, while SoccerTwos matches end
well short of it (longest 832). Size fixed buffers off this column, not off 1000.

<details>
<summary><b>Per-dataset episode-length distribution</b> — episodes, mean, sd, cv, min/median/max</summary>

| dataset | episodes | mean | sd | cv | min | median | max |
|---|---:|---:|---:|---:|---:|---:|---:|
| `unity/crawler/expert-v0` | 1,043 | 958.77 | 157.56 | 0.16 | 2 | 1,000 | 1,000 |
| `unity/crawler/medium-v0` | 1,120 | 892.86 | 245.88 | 0.28 | 16 | 1,000 | 1,000 |
| `unity/crawler/simple-v0` | 1,325 | 754.72 | 332.53 | 0.44 | 7 | 1,000 | 1,000 |
| `unity/worm/expert-v0` | 1,000 | 1000.00 | 0.00 | 0.00 | 1,000 | 1,000 | 1,000 |
| `unity/worm/medium-v0` | 1,000 | 1000.00 | 0.00 | 0.00 | 1,000 | 1,000 | 1,000 |
| `unity/worm/simple-v0` | 1,000 | 1000.00 | 0.00 | 0.00 | 1,000 | 1,000 | 1,000 |
| `unity/walker/expert-v0` | 1,464 | 683.06 | 365.05 | 0.53 | 9 | 886 | 1,000 |
| `unity/walker/medium-v0` | 1,695 | 589.97 | 372.74 | 0.63 | 9 | 611 | 1,000 |
| `unity/walker/simple-v0` | 2,306 | 433.65 | 348.79 | 0.80 | 10 | 323 | 1,000 |
| `unity/3dball-hard/expert-v0` | 1,011 | 989.13 | 89.59 | 0.09 | 42 | 1,000 | 1,000 |
| `unity/3dball-hard/medium-v0` | 1,311 | 762.78 | 354.63 | 0.46 | 13 | 1,000 | 1,000 |
| `unity/3dball-hard/simple-v0` | 1,701 | 587.89 | 391.43 | 0.67 | 6 | 636 | 1,000 |
| `unity/pushblock/expert-v0` | 53,039 | 18.85 | 37.09 | 1.97 | 1 | 15 | 1,000 |
| `unity/pushblock/medium-v0` | 39,033 | 25.88 | 47.08 | 1.82 | 3 | 20 | 1,000 |
| `unity/pushblock/simple-v0` | 26,666 | 37.88 | 60.35 | 1.59 | 2 | 27 | 1,000 |
| `unity/pyramids/expert-v0` | 5,392 | 185.46 | 119.83 | 0.65 | 9 | 157 | 1,000 |
| `unity/pyramids/medium-v0` | 4,174 | 239.58 | 142.40 | 0.59 | 22 | 201 | 1,000 |
| `unity/pyramids/simple-v0` | 3,065 | 326.26 | 191.25 | 0.59 | 13 | 275 | 1,000 |
| `unity/dungeon-escape/expert-v0` | 35,505 | 28.37 | 26.31 | 0.93 | 1 | 25 | 1,213 |
| `unity/dungeon-escape/medium-v0` | 28,314 | 35.76 | 34.99 | 0.98 | 1 | 28 | 889 |
| `unity/dungeon-escape/simple-v0` | 22,542 | 44.43 | 48.03 | 1.08 | 1 | 31 | 969 |
| `unity/soccer-twos/expert-v0` | 14,692 | 68.18 | 63.14 | 0.93 | 6 | 48 | 574 |
| `unity/soccer-twos/medium-v0` | 12,940 | 77.46 | 71.27 | 0.92 | 7 | 55 | 479 |
| `unity/soccer-twos/simple-v0` | 11,820 | 84.73 | 83.51 | 0.99 | 7 | 59 | 832 |

</details>

**Build & reproduction steps** (per-env recording recipe): see
[docs/reproduction.md](docs/reproduction.md).

## Provenance & attribution

- Trajectories were generated by running Unity ML-Agents material (the builds and
  stock policies are Apache-2.0; see the envs repo for provenance and licenses).
- The **trajectory data in this repo** is an original recording licensed
  **CC-BY-4.0**. Please attribute *ccnets — Causal GPT-RL* and note the Unity
  ML-Agents source environment.

## License

Creative Commons Attribution 4.0 International (CC-BY-4.0). See `LICENSE`.