Quome/openworld-arc-agi-3

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

The full telemetry behind solving ARC-AGI-3 source-free — every game cracked by an agent that writes and verifies a small code world model of the game, then reasons the win from pixels alone. It never reads the game's source.

ar25	bp35	cd82	cn04	dc22
ft09	g50t	ka59	lf52	lp85
ls20	m0r0	r11l	re86	s5i5
sb26	sc25	sk48	sp80	su15
tn36	tr87	tu93	vc33	wa30

_{All 25 public ARC-AGI-3 games, each a verified source-free solve replayed against the real engine. The winning action trace for every one is in solutions/.}

---

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 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

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). Full field docs are in 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 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

# 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

@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}
}