---
license: apache-2.0
pretty_name: "OpenWorld · ARC-AGI-3 Source-Free Solving Traces"
task_categories:
  - reinforcement-learning
  - other
tags:
  - arc-agi
  - arc-agi-3
  - agents
  - world-models
  - code-world-models
  - reasoning
  - reproducibility
  - source-free
  - claude
language:
  - en
size_categories:
  - n<1K
configs:
  - config_name: runs
    data_files: runs.jsonl
---

# OpenWorld · ARC-AGI-3 Source-Free Solving Traces

**The full telemetry behind solving [ARC-AGI-3](https://arcprize.org/) _source-free_ — every game cracked by an agent that writes and _verifies_ a small [**code world model**](https://github.com/quome-cloud/openworld) of the game, then reasons the win from pixels alone. It never reads the game's source.**

[![Built with OpenWorld](https://img.shields.io/badge/built%20with-OpenWorld-0f766e.svg)](https://github.com/quome-cloud/openworld)
[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-1d4ed8.svg)](https://opensource.org/licenses/Apache-2.0)
[![Runs: 806](https://img.shields.io/badge/runs-806-b45309.svg)](#whats-in-a-record)
[![Games: 25](https://img.shields.io/badge/games-25-1d4ed8.svg)](#the-benchmark)
[![Verified: real-engine replay](https://img.shields.io/badge/verified-real--engine%20replay-brightgreen.svg)](#how-every-outcome-is-verified)

|  |  |  |  |  |
|:--:|:--:|:--:|:--:|:--:|
| <img src="assets/arc3/ar25.gif" width="140"/><br/>`ar25` | <img src="assets/arc3/bp35.gif" width="140"/><br/>`bp35` | <img src="assets/arc3/cd82.gif" width="140"/><br/>`cd82` | <img src="assets/arc3/cn04.gif" width="140"/><br/>`cn04` | <img src="assets/arc3/dc22.gif" width="140"/><br/>`dc22` |
| <img src="assets/arc3/ft09.gif" width="140"/><br/>`ft09` | <img src="assets/arc3/g50t.gif" width="140"/><br/>`g50t` | <img src="assets/arc3/ka59.gif" width="140"/><br/>`ka59` | <img src="assets/arc3/lf52.gif" width="140"/><br/>`lf52` | <img src="assets/arc3/lp85.gif" width="140"/><br/>`lp85` |
| <img src="assets/arc3/ls20.gif" width="140"/><br/>`ls20` | <img src="assets/arc3/m0r0.gif" width="140"/><br/>`m0r0` | <img src="assets/arc3/r11l.gif" width="140"/><br/>`r11l` | <img src="assets/arc3/re86.gif" width="140"/><br/>`re86` | <img src="assets/arc3/s5i5.gif" width="140"/><br/>`s5i5` |
| <img src="assets/arc3/sb26.gif" width="140"/><br/>`sb26` | <img src="assets/arc3/sc25.gif" width="140"/><br/>`sc25` | <img src="assets/arc3/sk48.gif" width="140"/><br/>`sk48` | <img src="assets/arc3/sp80.gif" width="140"/><br/>`sp80` | <img src="assets/arc3/su15.gif" width="140"/><br/>`su15` |
| <img src="assets/arc3/tn36.gif" width="140"/><br/>`tn36` | <img src="assets/arc3/tr87.gif" width="140"/><br/>`tr87` | <img src="assets/arc3/tu93.gif" width="140"/><br/>`tu93` | <img src="assets/arc3/vc33.gif" width="140"/><br/>`vc33` | <img src="assets/arc3/wa30.gif" width="140"/><br/>`wa30` |

<p align="center"><sub>All 25 public ARC-AGI-3 games, each a <b>verified source-free solve</b> replayed against the real engine. The winning action trace for every one is in <code>solutions/</code>.</sub></p>

---

## What this is

A reproducible, fully-annotated dataset of **agent and algorithmic attempts to solve interactive ARC-AGI-3 games source-free**, produced by the [OpenWorld](https://github.com/quome-cloud/openworld) *hybrid world models* pipeline. Each record is one **run** — one method's attempt at one game — carrying the exact **prompt**, a pointer to the full structured **transcript** (every model message + tool call), the **model / version / effort** that produced it, token usage and cost, host + git provenance, the **source-free integrity audit**, and a **verified outcome** (replay against the real engine + a round-trip through an OpenWorld `World`).

The intent is to let others **see and reproduce** how these games were solved — and to isolate artifacts by the exact `(model, version, effort)` tuple.

## Load it

```python
from datasets import load_dataset

runs = load_dataset("Quome/openworld-arc-agi-3", "runs", split="train")
print(len(runs), "runs")
r = runs[0]
print(r["run_id"], r["game"], r["tier"], r["outcome"]["full_solve"])
```

The `runs` config is the index (`runs.jsonl`). The per-run **prompt**, **transcript**, and **solution** live in `prompts/`, `transcripts/`, and `solutions/`, keyed by `run_id` (see [Files](#files)). Full field docs are in [`SCHEMA.md`](SCHEMA.md).

## What's in a record

One JSON object per run: identity & routing (`run_id`, `game`, `tier`, `method`, `source_free`, `fairness`), timing, `model_config` (`requested_model` / `resolved_model` / `effort` / CLI version — the artifact-isolation key), token/cost stats, host + `git` provenance, `pipeline` file SHA-256s, the source-free `knowledge_audit`, and the verified `outcome`. See [`SCHEMA.md`](SCHEMA.md) for every field.

## Why "source-free"

The downloadable ARC-AGI-3 environment ships each game's Python source. An agent in the same process/dir can read the win condition — *reading the answer key*. The invariant enforced here is: **the solver never reads the game's source**. Two independent routes guarantee it, recorded per run in `fairness`:

- **`by-construction`** (agent tier): the agent runs in a process-isolated sandbox (`SandboxGame` pipe client); the game object and its source never exist in the agent's process or working dir.
- **`by-audit`** (cheap tier): a fixed, pixel-only search whose ~100 lines provably read only frames (statically verified — no `inspect.getsource` / `environment_files` / `spec_from_file_location`).

Stepping the env to *act* is the legitimate API (leaderboard agents do the same); only *reading source* is the cheat. Every run records its audit result in `outcome.audit`.

## Routing (hybrid world models)

Each game is first attempted by the **cheap** tier (fast pixel-only frontier search). Games it does not fully solve are routed to the **agent** tier (a live coding agent that discovers dynamics by acting and reasons the win from frames). `tier` and `method` record which solved each game.

## How every outcome is verified

A run's `outcome` is trustworthy because it is recomputed independently of the solver:

1. **Source-free audit** — `outcome.audit.clean` (see above).
2. **Real-engine replay** — the action trace is replayed from `reset()` in the real `arc_agi` engine and must raise `levels_completed` to the claimed depth (`outcome.replay_verified`).
3. **OpenWorld `World` round-trip** — the discovered masked-frame state graph is built into an OpenWorld `World` (`FunctionTransition` over the learned table + induced `CodeObjective` reward = levels); the solution is replayed through `world.step` and must reproduce the depth with **0 misses**, plus `validate_spec() == []` and a renderable card (`outcome.openworld_roundtrip.pass`).

A run is a **full solve** (`outcome.full_solve`) only if audit-clean, replay-verified, round-trip-passing, and `levels >= win`.

## Files

| File | Committed | Contents |
|------|-----------|----------|
| `runs.jsonl` | ✅ | One JSON record per run (the dataset index; see `SCHEMA.md`). |
| `prompts/<run_id>.md` | ✅ | The exact prompt given to the agent (agent runs only). |
| `solutions/<run_id>.json` | ✅ | The action trace the run produced (`[[a] \| [6,x,y], ...]`). |
| `meta/<run_id>.json` | ✅ | Per-run sidecar written at launch (pre-outcome); source of `runs.jsonl`. |
| `transcripts/<run_id>.jsonl` | ✅ | Full `claude -p` stream-json transcript (every message + tool call). |
| `assets/arc3/<game>.gif` | ✅ | A short replay of a verified solve for each game (the grid above). |

`run_id` = `<game>__<tier>__<UTC ISO-8601 timestamp>`, unique and immutable.

## The benchmark

ARC-AGI-3: 64×64 grids, 16 colors; actions are directional `1..5,7` plus a click `ACTION6(x, y)` with `x`=column, `y`=row in `0..63`. Environments are replay-deterministic. Reward = `levels_completed`. The 25 public games span click and directional control, and many wins are **goal-as-*procedure*** (an ordered protocol) rather than a single high-scoring frame — which is exactly why an observation-only score fails and a *reasoned* world model is needed.

## Reproduce

```bash
# cheap tier (arc venv has arc_agi):   <arcv>/bin/python scripts/run_cheap_tier.py <game...>
# agent tier (pinned model + effort):  MODEL=claude-opus-4-8 EFFORT=high bash scripts/run_arc_agent_sandbox.sh <game> agent
# join verified outcomes -> runs.jsonl: <arcv>/bin/python scripts/finalize_traces.py
# bank deepest verified per game:       <arcv>/bin/python scripts/bank_from_runs.py
```

The full overnight pipeline is `scripts/sweep_routed.py`. Pipeline file SHA-256s are recorded in each record's `pipeline` field so a run can be tied to the exact code that produced it.

## Limitations / honesty

The cheap tier is shallow (pixel search; often 0–1 levels). Depth comes from the agent tier. Some levels are goal-as-*procedure* walls where the win is an ordered protocol no observation-only score expresses; a run reaching a partial depth is reported as such (`full_solve=false`), never inflated. Records with `tier=cheap` have no prompt/transcript (deterministic algorithm) — their reproducibility rests on the solver code SHA + seed in `params`/`pipeline`.

## From the OpenWorld project

This dataset is produced by **OpenWorld** — a framework for *verified symbolic world models*, where a world's dynamics are explicit, auditable Python code an LLM writes and verifies (no training, no GPU). The ARC-AGI-3 agent is one application: it builds a code world model of an unseen game **purely by playing it**.

- 💻 **Code & docs:** https://github.com/quome-cloud/openworld
- 🧩 Every solve round-trips into a runnable OpenWorld `World` — viewable in `openworld serve /view`.

## Citation

```bibtex
@software{openworld_arcagi3_2026,
  title  = {OpenWorld: ARC-AGI-3 Source-Free Solving Traces},
  author = {Schwoebel, Jim},
  year   = {2026},
  url    = {https://github.com/quome-cloud/openworld},
  note   = {Hugging Face dataset: Quome/openworld-arc-agi-3}
}
```