What that 99 actually means

It's not "how many of the 25 games got solved." RHAE measures step efficiency, with a heavy squared penalty built in.

Here's the formula: for each level, take "human step count ÷ AI step count," square it, capped at 1.15. Later levels within a game carry more weight (increasing from 1 to n), and there's a completion cap tied to that weight — miss even one level, and the whole game can't score full marks. Every action the AI actually takes in the game, including exploratory steps taken just to probe the environment, counts toward its step total. Because it's squared, extra steps tank the score fast.

So "mostly cleared" can mean wildly different scores depending on efficiency. The source gives a paired example:

So this 98.98 is a composite score of "how much got completed" and "how efficiently" — not a solve rate. It forces the AI not just to play the game, but to play it as economically as a skilled human.

Think like a physicist

Before a physicist can write down a law, they first have to decide what that law is even about: out of a pile of observations, which things count as "objects," and which properties define a "state." Only once that's settled does "how does the state change" become a meaningful question. Schema splits this into two problems that have to be solved together.

The first is state grounding: turning raw pixels into trackable objects, variables, and relationships. Nothing tells the AI which pixels are itself, which are a wall, and which are a "steps remaining" counter — it has to figure that out on its own. The second is mechanism discovery: finding out how those states change under a given action, and writing that rule as an actual runnable program.

Crucially, these two problems can't be solved separately. A state representation that looks sound can still fall apart later: no matter how you try, you can't find a consistent rule that explains what happens next. When that happens, tweaking the rule isn't enough — you have to revisit what "state" even is.

Write the program first, act only once it's verified

Having a program isn't enough on its own — Schema enforces very strict rules about how that program gets used. It runs a four-step outer loop: observe → deliberate → execute → record.

Record is the system's immutable interaction history. The AI can revise its own hypotheses and notes any time it wants, but it cannot change screens it has already received, or actions it has already taken. This append-only timeline is the one and only source of truth.

Each time it deliberates, the AI updates its theory of the game — that step(state, action) program. It uses run_backtest to run that program against the full interaction history; wherever the prediction diverges from what actually happened, that mismatch pinpoints the error. Then run_bfs searches inside that model for a route, and the conclusion goes into its notes. None of these operations touch the real environment — only commit_actions ever sends a move to the game, which cleanly separates "internal modeling and search" from "actual interaction with the outside world."

There's also a counterintuitive part: the AI doesn't only act to clear the game — it also acts specifically to figure out hidden mechanisms. When several candidate rules all still fit the history, it looks for an experiment that would tell them apart: an action where the competing hypotheses predict different outcomes. It presses it, compares the result, and updates step(). Because RHAE squarely punishes wasted steps, the best experiment is exactly the one that "eliminates the most uncertainty using the fewest real interactions." Once step() can reproduce every transition in the recorded history, solving the rest of the level moves entirely into the model's internal search — no more real steps spent.

Same model, different use — 43 to 99

To prove that the 99 comes from the harness and not from a stronger model, you need a controlled comparison: hold the model fixed, swap only the harness. The source did exactly this using the same Opus 4.8 plus Fable 5 pairing.

Taking the final draft snapshot from the stock Claude Code harness as a baseline output scores 42.83. The exact same model pairing, wrapped in Schema, scores 98.98 — a net gain of 56.15 points.

Claude Code itself is a strong general-purpose harness, good at file operations and long-context management, and in principle it could mimic Schema's process — but it doesn't force the model to. Under a general-purpose harness, the model can act on the game directly, keeping its own reasoning entirely in context without ever committing it to code. Schema hard-codes three additional constraints:

Under this controlled setup, Schema delivers a 56.15-point gain over the Claude Code baseline. Switching to GPT-5.6, Schema's Sol xhigh and Sol max pairing scores 95.35 — but note that its closest official reference point (Sol max: 13.33 public, 7.78 semi-private) isn't a controlled comparison on the same harness, so the 82-point gap shown is a "reference," not a measured gain.

Breaking down the 25 games individually: in the set kept for Claude — 14 games on Opus, 11 on Fable — 19 hit a perfect 100. In the Sol set, 20 hit a perfect 100. The remaining games that fell short of 100 clustered between 89 and 99 — small gaps, tightly bunched.

Get the object right, and you win

Where does the efficiency actually come from? The source offers two observations — and along the way, they reveal a real difference between Opus 4.8 and Fable 5 under this harness.

Observation one: get the program right, and action gets cheap

Across the 14 games where the AI derived a program world model that could exactly reproduce the entire history, it used between 1/1.6 and 1/5 of the human reference step count. The reason is where the cost lands: real steps are spent once, to discover a mechanism, and after that, planning happens for free inside the model instead of repeatedly re-discovering the same mechanism through trial and error. The harder a spot is for humans, the bigger this edge gets: on M0R0 level 4, humans needed 500 steps; the AI needed 42.

RE86 shows the full pipeline in action: run_backtest replayed the model against 393 recorded transitions, matching every single one exactly, and the verified model then produced one plan that cleared the whole level with zero extra trial and error: a 61-step plan, zero prediction errors during execution, a clean win. This ability — checking hundreds of exact frames in a single pass — has no real counterpart in unassisted human play.

Cumulative step count (x-axis) vs. levels cleared (y-axis) across all 25 games: magenta is Schema, gray is a human playing for the first time. In most games the magenta line sits above the gray line — reaching the same level count with fewer steps. Officially, Schema is faster than humans on 96% of levels, for an overall 99.0 RHAE. Source: Impossible Research

Observation two: Fable is quicker to suspect it "misidentified the object"

Comparing Opus 4.8 Max and Fable 5 on games both models attempted, Fable achieved higher RHAE through two mechanisms: in some games it discovered models that cleared levels Opus couldn't; in others both cleared, but Fable reached the same endpoint using fewer real steps.

Paired trajectories point to the same explanation: after a failed prediction, Fable more often questions the representation itself, identifies the specific uncertainty that actually matters, then picks an action where competing hypotheses predict different results, tests it, and turns the observation into a reusable rule. Opus usually arrives at the same mechanism eventually, but first spends more steps testing various goals, conditions, and configurations within its existing representation.

In FT09, the board satisfies the current goal logic but doesn't advance — Fable instead tests a more basic question: can the object treated as decoration, a "checker," actually be clicked? Clicking it reveals a plus-shaped button that flips itself and its four neighbors. Fable codes this observation, clears the level in 11 steps, and clears the next in 13. Opus notices the same contradiction but spends roughly 240 steps testing other goal-state interpretations before finally clicking the checker at step 287 and recording the same hidden mechanism. Both models can express and use the rule once found; the difference is purely which model picks the experiment that surfaces the missing clue faster.

All three cases land on the same point: a general mechanism doesn't mean "never changes." It means the kind of mechanism where every revision preserves the previous explanatory framework while cutting the cost of future levels. Search is only complete relative to the world model it's built on: once the missing object, state variable, or transition gets represented, the existing verifier and planner are usually enough. But when the observations can't distinguish the right representation from a wrong one, that same machinery will just as happily verify and exhaustively search a wrong one.

A new starting point

ARC-AGI-3 is an important benchmark in a fast-moving field. When it launched in March, the leading frontier agent scored just 0.51. By July, the best official Sol Max reached 13.33 on the public set and 7.78 on the semi-private set, while self-reported results had briefly climbed to an average RHAE of 58.12 per game.

Schema's self-reported 98.98 continues that trajectory — it isn't a break from it. The source is upfront about this: every number here was only measured on the 25 public games. Sol max offers the only official calibration point across both evaluation sets (13.33 public vs. 7.78 semi-private), but that isn't enough to numerically extrapolate a near-perfect public score onto the semi-private set — what the public 98.98 would become on the semi-private set is unknown until it's actually measured. The available run materials only cover the public set, so this release makes no claim about "fixed harness" or "held-out set" performance. It's also worth noting both scores are self-reported and haven't been independently verified by ARC Prize, and the Sol curve in the figure was pulled from a raw chart as a provisional value before the complete evaluation materials were released.

The researchers read a saturated ARC-3 as a new starting point: making "mechanism discovery" a general capability — grounding a world's causal structure through an agent's loop of action and perception, in a world far richer than a 64×64 grid. That's the direction they say they're headed.

The key ingredients were already emerging: frontier models that adapt to unfamiliar environments, coding-agent harnesses, and programmatic world models. Schema is the system that pulls them together. Impossible Research, Schema release blog post

Schema is a "harness" (a mechanism that doesn't touch the model itself, just how visuals get fed in, how it's made to think, and how that becomes an action). It forces the AI to change how it plays: first write this game's rules as a small program that actually runs, replay every past step against it to verify, and only once everything checks out, search inside that program for the next move.

Same Opus 4.8 plus Fable 5, not a single byte of the model changed — just swapping the harness took the score from 43 to 99. So why does "writing it as a program" make that much difference?

AI playing games used to mean "guess as you go, keep going after mistakes." Schema forces a different loop: write the rules as a program first, verify it, then act.

This 99 isn't "how many of 25 games got solved" — it's the AI's step count per level compared against a human's first playthrough, with more savings meaning a higher score, plus a squared penalty. Converted into "how many steps to clear the same level," it looks like this: