SOUSResearch notesAll notes

Executable world models

Can you win a game without knowing the rules?

ARC-AGI-3 gives the agent a world but no manual. We ask whether a model written, tested, and revised during play can turn uncertainty into a plan.

Note
01 / 02
Published
Updated
Reading
5 min read

Abstract / ARC-AGI-3

Two games. Fourteen completed levels.

With no stated controls or objective, the agent builds a runnable account of each game, checks it against every new state, and plans through it. Across our broader local public-game runs, the system reached about 85% completion. These two complete trajectories show the behavior directly.

14 / 14Levels completed across both runs · no reset
Run 01 / lp858 / 8 levels
0196.77% completion · 119 actions · no reset
Run 02 / cd826 / 6 levels
0290.97% completion · 130 actions · no reset

Recorded environment states from two complete local public-game runs. The ≈85% aggregate below is local and is not an ARC Prize verified result.

≈85%Sous · local public-game completion
7.8%Sol Max · verified semi-private

The task

The game starts before the instructions arrive.

ARC-AGI-3 starts without a manual. The agent sees an unfamiliar interactive world, chooses an action, and receives the next state. There is no description of the controls, no stated objective, and no guarantee that the first plausible interpretation is the right one. A capable language model can still wander here because recognizing a scene is different from learning the rules that make it move.

Our system treats every game as a small scientific problem. It forms a hypothesis about the environment, turns that hypothesis into something it can execute, and tests it before spending another real action. When reality disagrees, the disagreement is not discarded as a bad sample. It becomes the evidence used to change the model.

The learning loop

Write the rules. Let the next frame audit them.

  1. 01ObserveRead the current state.
  2. 02ModelWrite a runnable rule.
  3. 03VerifyReplay known transitions.
  4. 04PlanSearch before acting.
  5. 05ReviseTurn mismatch into evidence.

A model is useful only when it produces consequences that can be checked against the real environment.

The mechanism

The model has to earn the next action.

The executable model begins incomplete. Early actions identify which objects respond, which changes persist, and which apparent regularities were coincidences. The controller then searches inside the updated model for a short route forward. Better models produce more informative actions; more informative actions produce better models.

Each hypothesis is translated into runnable code and checked against the transitions already observed. A mismatch blocks further action until the account of the world changes. Once a usable model exists, the next real move is chosen by planning through it rather than by guessing directly from the screen.

The two trajectories in this note are complete runs from that process. The opening lp85 recording completed all eight levels in 119 actions; cd82 completed all six in 130. The case below makes the learning process inside one of those trajectories concrete.

Inside cd82

A painting game that reveals its rules one stamp at a time.

cd82 is a 10×10 stamp-painting puzzle. The image in the upper left is the target; the lower grid is an editable canvas. Palette clicks change the paint color, moving the large stencil changes the footprint it will cover, and stamping overwrites the cells beneath it. A level ends when the canvas matches the target exactly.

The agent began without any of those facts. Level 1 established the target, palette, and basic half-plane stamps. Level 2 forced it to discover a missing lower-right diagonal pose. Level 3 introduced a smaller secondary stamp; level 5 revealed the symmetric lower-left pose. By level 6, the world supplied no new mechanic—the shared planner could compose the learned footprints and finish from the model it had built.

01cd82 · complete trajectorycd82 · 6 of 6 levels · 90.97% completion · 130 actions · no reset

Watch the target in the upper left, the editable canvas below it, and the large stencil changing pose before each overwrite. Later levels add colors and a smaller secondary stamp, but retain the same learned objective.

The system-level result

About 85% locally; 7.8% on the verified semi-private track.

Across broader public-game runs completed on our machines, the system reaches roughly 85% overall completion. ARC Prize lists GPT-5.6 Sol Max at 7.8% on the verified semi-private evaluation. Numerically, our local result is 77.2 percentage points higher and 10.9 times as large.

The evaluations are not identical. Ours uses an executable-world-model harness on public games and allows the system to learn through interaction; Sol Max is a verified frontier model result on ARC Prize's semi-private set. This is therefore a comparison between complete systems under different tracks, not a claim that our base model is intrinsically 10.9 times stronger.

The useful question is narrower: what changes when a model can build, test, and revise an account of the environment while the task is unfolding? On our local public-game runs, that mechanism changes the scale of the result. Verification on the semi-private track remains a separate test.

Numerical comparison

A large difference, with the boundary kept visible.

Completion rate reported by each system on its respective ARC-AGI-3 track.

10.9× higher
Sous executable world modelBroader local public-game runs
≈85%
GPT-5.6 Sol MaxARC Prize verified semi-private result
7.8%

Different tracks, tools, and allowances; values are shown without normalization. The ≈85% local public-game result is not ARC Prize verified. The 7.8% semi-private result is.

Prediction asks what comes next. Learning asks what must change inside the system after it was wrong.

What we learned

The best model is the one that is easiest to correct.

The best internal model is not the most elaborate one. It is the smallest model that makes a useful distinction, exposes its own failure, and can be revised before the action budget disappears. In these games, testability mattered more than eloquence and targeted experiments mattered more than long unconstrained exploration.

This is why we describe the system as continually learning. It does not receive one training phase and then freeze into a polished answer machine. It repeatedly converts surprise into a new executable belief while the task is still unfolding.

The next step is harder: carry useful abstractions from one unfamiliar world into another without carrying over brittle assumptions. We want the system to begin each game less naive, while remaining willing to discard everything the new world disproves.