💻 computer science

Tycho: Active Abstraction with Programmatic World Models for ARC-AGI-3

The paper introduces Tycho, a coding-agent system that addresses the ARC-AGI-3 challenge by formalizing environments as parameterized Moore machines and employing "active abstraction" to dynamically construct, test, and repair executable world models, achieving perfect human-replay efficiency on all 183 levels while significantly reducing action counts compared to human baselines.

Original authors: Jens Lehmann, Andrei Aioanei, Sahar Vahdati

Published 2026-07-31

📖 3 min read☕ Coffee break read

CC BY 4.0

Original authors: Jens Lehmann, Andrei Aioanei, Sahar Vahdati

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are dropped into a brand-new video game with no manual, no tutorial, and no way to ask for help. You can only see the screen, press a button, and watch what happens next. To win, you have to figure out the hidden rules, guess the goal, and do it all without wasting a single move, because every button press counts against your score. This is the challenge of active abstraction: learning how a world works by doing things in it, rather than just memorizing answers. Scientists call this "skill acquisition," which is basically the ability to learn a new trick quickly from just a few tries, rather than needing to practice a million times. The big question is: Can a computer learn to play these mysterious games the way a human does—by watching, guessing the rules, and then using those rules to plan ahead?

This paper introduces a system called Tycho (named after the astronomer Tycho Brahe, who mapped the stars so precisely that others could later find the laws of the universe) to answer that question. Tycho is a "coding agent" designed to play a specific set of tricky puzzles called ARC-AGI-3. Instead of just guessing the next move, Tycho tries to write a little computer program that acts like a simulator of the game itself. It watches the game, writes code to predict what will happen if it presses a button, checks if that code is right, and then uses that code to plan its moves. The researchers tested four different ways Tycho could use this simulator: ignoring it completely, having the main brain write the code itself, asking a helper bot to write the code, or automatically fixing the code whenever it makes a mistake.

The results were surprising and nuanced. The team found that simply having a simulator isn't enough; the strategy for when to use it matters most. The best approach was actor-requested delegation, where the main agent asks a specialist helper to build the game simulator only when it thinks it's necessary. This method scored the highest efficiency among the initial tests. When they took this winning strategy and gave it to two of the most powerful AI models available (GPT-5.6 Sol and Opus 5), the results were incredible: they solved 100% of the 25 public games and all 183 levels within them. The Opus 5 model was particularly efficient, using 61% fewer actions than the average human player to complete the same levels.

However, the paper also warns against a common trap. They found that building a simulator that perfectly predicts every single pixel of the game (high accuracy) doesn't guarantee you will win. One strategy, called "automatic repair," built simulators that were incredibly accurate at predicting what happens next, but the agent still played poorly because it didn't know what to aim for or when to stop using the simulator. It's like having a perfect map of a maze but not knowing where the exit is. The paper concludes that true intelligence isn't just about building a perfect model of the world; it's about the "active abstraction" of deciding when to build a model, when to trust it, and when to ignore it and just act. Tycho showed that by treating the game as a set of rules to be discovered and tested, rather than just a picture to be solved, AI can learn to play new games with human-like efficiency.

Technical Summary: Tycho – Active Abstraction with Programmatic World Models for ARC-AGI-3

Problem Definition

The paper addresses ARC-AGI-3, an interactive benchmark where an agent must infer the rules, hidden state, and goals of unfamiliar games solely through observation and action. Unlike static reasoning tasks, ARC-AGI-3 imposes a strict action budget: every move counts toward the score, and the agent must balance exploration (gathering evidence) with exploitation (completing levels).

The core challenge is active abstraction: the agent must decide not only what is true about the environment but when it is worth the cost to construct a model, use it for planning, repair it upon failure, or bypass it entirely. The paper formalizes these environments as parameterized rendered deterministic Moore machines, distinguishing between the underlying state (which includes hidden variables like counters or camera offsets), the transition dynamics, and the observation formation (rendering). A key difficulty is that identical rendered grids can correspond to different underlying states (non-Markovian observations), requiring the agent to maintain a history of interactions to resolve ambiguity.

Methodology: The Tycho System

Tycho is a coding-agent system designed to construct and utilize programmatic world models during interaction. It operates on a shared task-time architecture (Figure 1) involving an actor (which reasons and commits actions) and an optional workbench (which constructs or repairs executable models).

1. Formal Framework

Rendered Moore Machines: The environment is modeled as a deterministic system where actions update an underlying state $s$ , and the state produces an observation (grid), available actions, and an outcome. Transitions may emit intermediate animation frames (transient evidence) before settling on the next decision frame.
Typed Interaction History: The system records a structured history of decision frames, actions, transient frames, and terminal outcomes. This prevents the agent from confusing animation frames with decision points.
Partial Prediction: To handle uncertainty, the model's renderer can abstain on pixels it cannot determine (returning $\perp$ ) or return a bounded set of observation variants for quantization ambiguities (e.g., a HUD bar representing a hidden counter).

2. Executable Hypothesis Language

Tycho represents world models as Python programs implementing four core functions:

init_state: Maps the initial grid and level index to a modeled state.
transition: Advances the state given an action.
render: Maps the state back to a grid (supporting abstention).
outcome: Classifies the state as ongoing, level complete, or game over.
The model is free-form, allowing the agent to choose the state representation (e.g., object lists, cellular automata, counters) based on the specific game mechanics.

3. Metareasoning Policies

The paper evaluates four distinct policies for managing the interaction between the actor and the model:

No World Model (Direct Reasoning): The actor reasons directly over the evidence without constructing an executable model.
Single (Actor-Authored): The actor both reasons and edits the model as needed.
Orchestrator (Actor-Requested Delegation): The actor can request a specialized builder subagent to construct or repair the model.
Trigger (Automatic Repair): The harness automatically invokes the builder when verification fails (e.g., transition mismatch, insufficient coverage) or at level boundaries.

4. Verification and Planning

Verification: The model is tested by replaying the recorded interaction history. A transition is "accepted" if the model's predicted grid matches the observed grid on all claimed cells (or matches one of the allowed variants).
Planning: Once a model is verified, the system searches the state space for a sequence of actions leading to level_complete. The resulting plan is validated against the model's internal state and executed step-by-step, with the actor re-verifying the state after each action.

Key Contributions

Formalization: The paper formalizes ARC-AGI-3 as the active identification of rendered deterministic Moore machines with transition emissions, explicitly handling hidden state, non-injective observations, and the cost of interaction.
Programmatic World Models: It defines a free-form, executable hypothesis language that allows agents to externalize rules as inspectable, editable Python code, supporting partial prediction and state abstraction.
Policy Benchmarking: It provides a matched comparison of four model-maintenance policies (No Model, Single, Orchestrator, Trigger) under identical inference budgets, isolating the impact of model allocation (who builds the model and when) from model synthesis capabilities.
Distinction of Metrics: The work separates transition accuracy (does the simulator reproduce history?) from game-playing performance (does the model help win?). It demonstrates that high transition accuracy does not guarantee high scores if the model fails to identify the objective or if the policy misallocates resources.
Human-Adaptation Loop: It describes a process where meta-reflections from agent runs are used to iteratively refine the agent's harness (tools, memory, verification) before freezing it for future runs.

Experimental Results

The evaluation was conducted on the 25 public ARC-AGI-3 games (183 levels total) using frontier LLMs (Claude Opus 4.8, GPT-5.6 Sol, and Opus 5).

Matched Policy Selection (Opus 4.8)

Direct Reasoning (No Model): Achieved 79.07 RHAE (Relative Human Action Efficiency).
Single (Actor-Authored): Achieved 85.36 RHAE.
Orchestrator (Delegated): Achieved 88.49 RHAE, the highest among matched policies.
Trigger (Automatic Repair): Achieved 83.07 RHAE. Despite producing models with the highest accepted transition match (88.1%), it underperformed the Orchestrator. This gap illustrates that accurate simulation of dynamics is insufficient without correct objective inference and efficient resource allocation.

Frontier Model Evaluation (Selected Orchestrator Policy)

Using the Orchestrator policy with stronger models:

GPT-5.6 Sol: Reached 100.00 RHAE, completing all 25 games and 183 levels in 7,766 scored actions.
Opus 5: Reached 100.00 RHAE, completing all 183 levels in 6,641 actions (using 14.5% fewer actions than GPT-5.6 Sol).
Efficiency: Opus 5 used 61% fewer scored actions than the aggregate official human baselines.
Cost: The Opus 5 run cost an estimated $2.99k (API-equivalent), significantly lower than comparable runs of other systems (e.g., Rodionov's verification runs estimated at $13.6k–$ 15.5k under similar conditions).

Qualitative Analysis

Case studies (e.g., cd82, tu93, sk48) revealed:

Success: Models can replace trial-and-error with verified sequences (e.g., cd82) and support search over reduced state spaces (e.g., tu93).
Failure: An accurate transition model can fail if the objective is misidentified (e.g., sk48, where the model perfectly simulated mechanics but failed to identify the goal).
Repair: The system successfully localized mismatches (e.g., unexpected patrol explosions in tu93) and repaired the model to enable replanning.

Significance and Claims

The paper claims that active abstraction is a critical component of general intelligence: the ability to generate testable models from costly interaction and decide when to use them.

Selective Modeling: The results suggest that world modeling is most effective when delegated to a specialist (Orchestrator) rather than forced automatically (Trigger) or handled solely by the actor.
Accuracy vs. Utility: High-fidelity simulation of environment transitions is necessary but not sufficient for success; the system must also correctly infer objectives and allocate computational resources efficiently.
System Architecture: The performance gains (from 79.07 to 100.00 RHAE) are attributed to the compound agent system (harness + model + policy) rather than the foundation model alone. The paper emphasizes that general intelligence depends on machinery that can organize limited experience into task models and adapt the system supporting that process.
Modesty: The authors acknowledge that these results characterize performance on a fixed public testbed. They note that the current adaptation loop is human-mediated (authors refine the harness based on agent notes) and that future work must automate this outer loop to achieve true self-improvement. They also caution that the high inference cost (API calls) trades unscored compute for scored action efficiency, a trade-off that differs from biological efficiency.