ARC‑AGI‑3 gives an agent a game environment, without an explanation of what it is seeing. At each step, the agent receives a 64×64 grid of 16 color indices and a set of legal actions. The environment supplies no object list, rule sheet, stated goal, or shaped reward. There is only one way to make progress: the physicist’s way. The agent must act while its model of the game is still provisional, forming hypotheses about what the grid represents, how actions change it, and what counts as success, then revising both its model and its plan as new observations arrive.

ARC‑AGI‑3 has proved exceptionally difficult for frontier models. Its official metric, Relative Human Action Efficiency (RHAE)：https://arcprize.org/media/ARC_AGI_3_Technical_Report.pdf, compares an agent’s per-level action count with a first-exposure human baseline and aggregates the result across environments; 100% means completing every level of every environment at or above human-baseline action efficiency. On the Semi‑private set, verified frontier-model performance rose from 0.51% at launch in March：https://arcprize.org/blog/arc-agi-3-launch to 7.78% with GPT‑5.6 Sol at max reasoning：https://arcprize.org/results/openai-gpt-5-6 in July. Sol also scored 13.33% on Public set, but still far from the human reference.

Schema , the harness we introduce today, reaches 99% on the ARC‑AGI‑3 Public set using Claude Opus 4.8 and Fable 5, and 95.35% using GPT‑5.6 Sol：https://huggingface.co/datasets/schema-harness/arc-agi-3-schema-traces. It does not change the underlying model weights. Instead, it changes the process around them: how observations are turned into a working model of the game, how predictions are tested against the interaction history, and how plans are executed and revised.

Both scores come from a fixed fallback rule: Opus 4.8 and Sol xhigh run first; games scoring below 80 are rerun with Fable 5 and Sol max, respectively, and the higher per-game score is retained.

The takeaway: how you use the model matters a lot. The rest of this post shows the arrangement.

Schema thinks like a physicist. Before a physicist can write down a law, they must decide what the law is about. Which parts of an observation are objects? Which properties define the state? Only then can they ask how that state changes. Schema formalizes these questions as two problems. State grounding turns raw observations into objects, variables, and relations that can be tracked. Mechanism discovery finds how that state changes under an action and writes the rule as an executable program. Our earlier system, VIGA：https://fugtemypt123.github.io/VIGA-website/, focused on the first problem. Through analysis-by-synthesis against a graphics engine, it recovered scene programs from continuous visual input far richer than an ARC grid. Other systems like WorldCoder：https://arxiv.org/abs/2402.12275 focus on the second: they learn transition programs from trajectories but begin with an already structured state representation. We believe these two problems must be solved jointly, with the agent constructing the state representation and the transition rules.

State grounding and mechanism discovery cannot be resolved independently. A state representation that appears plausible at first may prove inadequate when no consistent transition rule can explain the outcomes of subsequent experiments. In Schema, the state representation and transition rules are jointly encoded in the same editable program. When an observation contradicts a prediction, the agent can revise either the representation or the rule, then update the other to restore a consistent model. This mirrors how physicists work : when predictions fail persistently, they do not only adjust the law. They change what the state is . The cleanest case is the birth of special relativity. When Michelson and Morley could not detect the medium light was supposed to wave in, Lorentz took the first route: keep the aether, patch the rules with contraction hypotheses that absorbed the null result. Einstein took the second: in special relativity, he discarded the aether as part of the state and made simultaneity frame-relative, yielding a simple electrodynamics of moving bodies.

ARC‑AGI‑3 requires the agent to construct both layers from raw observations. The grid identifies neither objects nor goals, so the agent must decide which patterns correspond to entities such as the player, walls, and counters, infer how actions transform them, and determine which configurations count as progress or completion. Even the goal predicate—implemented in Schema as is_goal —must be inferred from interaction.

The metric, in full. The official ARC‑AGI‑3 evaluates performance in Relative Human Action Efficiency (RHAE)：https://arcprize.org/media/ARC_AGI_3_Technical_Report.pdf, which compares the number of actions used by the agent with an upper-median first-time human baseline for each completed level. The per-level score is (human actions ÷ agent actions)² , capped at 1.15 . Within each game, levels receive increasing weights from 1 to n , so later levels contribute more to the game score. A completion cap based on the same weights prevents a game from receiving 100% unless every level is cleared. The benchmark score is the average of the game scores. All environment actions, including exploratory ones, count toward the agent’s total; because the efficiency ratio is squared, additional actions reduce the score sharply. Thus, 98.98% is an aggregate measure of completion and action efficiency—not the percentage of games solved.

The Claude row (Figure 5) provides a controlled comparison with the same Opus 4.8 and Fable 5 pairing. Treating the final Claude Code scratch snapshot as the baseline output produces a score of 42.83% ; with Schema, the same pairing reaches 98.98% , an increase of 56.15%.

With the Sol xhigh and Sol max fallback pairing, Schema reaches 95.35% . The nearest official reference is not a matched harness comparison: ARC Prize reports the best individual variant, Sol max, at 13.33% on Public and 7.78% on Semi‑private：https://arcprize.org/results/openai-gpt-5-6. The 82.02% Public-set difference shown in the chart is therefore contextual, not a controlled estimate of the gain produced by Schema.

The controlled Claude comparison isolates a difference in process rather than underlying model capability. Claude Code provides a strong general-purpose harness for file operations and long-context management. In principle, it can mimic Schema’s workflow, but it does not require the model to do so. Under the generic harness, the model acts on the game directly and may keep its beliefs implicit in context. Schema instead enforces three constraints:

Under this controlled configuration, Schema’s harness yields a 56.15% improvement over the Claude Code baseline.

Verification status. The 98.98% and 95.35% scores are self-reported results on the Public set, calculated from the run artifacts released with this post. Neither score has been independently verified by ARC Prize.

How much does the public set indicate? Every Schema number here is measured on the 25 public games. Sol max supplies one official calibration point across evaluation sets — 13.33% public versus 7.78% Semi‑Private — but that does not justify numerically extrapolating a near-ceiling public score. What 98.98% public maps to on Semi‑private is unknown until it is measured. The available artifacts document public-set runs only, so this draft makes no frozen-harness or held-out-performance claim.

The pairing ledger. Among the retained Claude results, 14 games use the Opus run and 11 use the Fable run. 13 of the 14 Opus runs and 6 of the 11 Fable runs score exactly 100, yielding 19 games with a score of 100 overall. Among the retained Sol results, 15 games use the xhigh run and 10 use the max run. All 15 xhigh runs score 100; of the 10 max runs, 5 score 100 and 5 fall below 100.

The residual is concentrated. The Claude pairing falls 1.02% short of 100 overall. Nineteen games score exactly 100, while the remaining six range from 89.87 to 99.10; the median game score is 100. The Sol pairing also has a median game score of 100: 20 games score exactly 100, while the remaining five range from 60.93 to 87.80.

In the 14 of 25 games where the agent induced a program world model that exactly reproduced its recorded history, it used 1.6–5.0× fewer actions than the human reference. The reason is a shift in where actions are spent: the agent pays real actions only once, to discover a mechanism, and then plans inside the model for free instead of rediscovering the mechanic through trial and error. This depends on two capabilities:

A. Verify against complete history. Every real transition is logged, and run_backtest checks each candidate rule against the entire record rather than relying on recollection. Because the record survives both bounded working memory and the auto-compacted context window, the certified model can be trusted in place of further real-environment testing.

B. Plan inside a reusable simulator. Once step() and is_goal() are certified, breadth-first search explores 10 3 -10 4 modeled states without spending a single environment action. And because the model persists as code, this free planning repeats on every later level.

The payoff is sharpest where humans struggle most: on M0R0 Level 4, the agent needs 42 actions to the human's 500, consistent with paying the discovery cost once and recomputing plans inside the model thereafter. Each expandable item below is one game-level case supporting this pattern.

The world-model advantage appears only once the model is right. The playback below shows the agent shift from trial-and-error probing to a verified 94-action plan.

Before the pivot, the agent is losing. Across Levels 2–4 it spends more actions than the first-time human, because it treats the block as an object it steers directly. New observations keep contradicting this model, and each contradiction forces more real-world experiments.

The turnaround is a representation change. The agent admits, "I had the block model completely wrong," and replaces it with a carry-state rule: the block moves when the avatar's carry state changes. Mispredictions collapse from dozens per level to 4, the operational signal that the model now explains the interaction history.

After the pivot, the same model transfers. On Levels 5, 8, and 9 the agent uses roughly a quarter to a sixth of the human's actions, and on the level the human found hardest, it searches the corrected model, commits a verified 94-action plan, and executes it. The playback shows reuse, not rediscovery.

RE86 shows the full sequence in one game: run_backtest replays the model over every recorded transition, then the verified model supplies a plan that clears a whole level without additional trial and error.

KA59 isolates the memory advantage: exact records from two complete runs reveal that an apparently successful rule only fit by coincidence.

M0R0 isolates the planning advantage: once the model is exact, the solution is searched inside the simulator rather than discovered through further real-environment trial.

To understand how model choice affects world-model discovery under the same executable harness, we compare Schema w/ Opus 4.8 Max vs Fable 5 on games attempted by both models. Fable achieves higher RHAE across these games in two ways: on some games, it discovers a model that allows it to complete levels Opus cannot; on others, both models finish, but Fable reaches the same endpoint with fewer environment actions.

The paired traces suggest a common explanation. After a failed prediction, Fable more often questions the current representation itself, identifies the uncertainty that matters, and chooses an interaction whose possible outcomes distinguish between competing hypotheses. It then converts the observation into a reusable transition rule. Opus often eventually discovers the same mechanism, but only after spending more actions testing alternative targets, conditions, or configurations within its existing representation.

The matched-completion cases are particularly informative: because Opus eventually encodes the same mechanism, the action gap cannot be explained simply by one model being able to express the rule and the other being unable to. The difference lies in the discovery process—what to question, which experiment to run, and when to turn the result into executable code.

Fable questions the representation first. It enters the level treating the checker as a non-clickable decoration. When the board satisfies the current target logic but does not advance, Fable tests the more basic affordance question: can the supposed clue itself be acted on? The probe reveals a lights-out-style cross button that flips itself and its orthogonal neighbors. Fable turns that observation into code, clears 11 actions later, and solves the next level in 13.

Opus repairs the target for much longer. It notices the same contradiction but continues testing alternative target-state explanations for roughly 240 additional actions. At step 287 it finally probes the checker, records the same hidden mechanism, and revises its model to a 270/270 exact backtest. Both models can express and use the rule; the difference is how quickly each chooses the experiment that makes the missing affordance observable.

Read the two playbacks together. The left trace shows Fable moving from failed goal test to affordance probe and model revision. The right trace shows Opus converging on the same rule after a much longer within-model search. The 247-action milestone gap is discovery cost, not a difference in the final mechanism.

Opus built a detailed model of movement and three toggles. From a fresh reset, BFS later exhausted every state reachable in that model and correctly concluded that the target was unreachable. Fable exposed a transition that was absent from the modeled graph.

Both models recognized peg solitaire and learned that a cart moved along tracks. The decisive issue was how the two mechanisms composed. Fable first excluded the useful interaction too, then drove the cart to an exact docking coordinate and treated that moment as an observation point.

Both models discovered a DFS-like rule after Level 1 and both eventually solved all eight levels. This pair separates “stating a general idea” from maintaining a reusable coded abstraction that absorbs later variation.

Summary. The harness and the underlying model affect efficiency at distinct stages:

The executable harness reduces the cost of using a theory. It makes the theory persistent, exactly verifiable, and searchable. This is the source of the efficiency pattern observed relative to the human reference.

The underlying model determines the cost of discovering a useful theory. Paired runs sometimes converge on the same representation through markedly different trajectories. Fable more often makes the decisive representational revision earlier and therefore reaches an executable solution with fewer environment actions.

Search is only complete relative to the world model it operates over. Once the missing object, state variable, or transition is represented, the existing verifier and planner are often enough. If observations do not distinguish the right representation, the same machinery can verify and exhaustively search the wrong one.

ARC‑AGI‑3 is an important benchmark in a rapidly advancing field. When it launched in March, the leading frontier agent scored just 0.51%. By July, the best official Sol Max result had reached 13.33% on Public and 7.78% on Semi‑private, while self-reported results climbed as high as 58.12% mean per-game RHAE.

Our self-reported 98.98% continues this trajectory rather than breaking from it. The key ingredients were already emerging: frontier models capable of adapting to novel environments, coding-agent harnesses, and programmatic world models. Schema is the system that brings them together.

We read a saturated ARC‑3 as the new beginning: mechanism discovery as a general capability — grounding the causal structure of a world through the agentic loop of action and perception, in environments far richer than a 64×64 grid. This is where we are heading to.