A German academic research group today posted an open-source AI agent to arXiv that approaches ARC-AGI-3 — the interactive benchmark where frontier models including Claude Opus 5 still cannot reliably solve most environments — by doing something those frontier models do not: writing and running its own Python code as a testable hypothesis about how each unknown world works. The system, named Tycho, does not represent its understanding of an environment as a learned weight matrix. Instead, it writes a small Python codebase, runs it against every observation it has collected, checks whether the predictions match, refactors the code toward simpler abstractions when they do not, and only then uses that code to plan action sequences through simulation — spending none of the real interaction budget on guesses.

The result is an agent whose reasoning is auditable in a way that no frontier model’s reasoning is: the hypothesis is right there in the code, and a verifier either confirms it or flags the mismatch.

ARC-AGI-3: Interactive Environments With No Instructions

ARC-AGI-3, developed by the ARC Prize Foundation and designed by François Chollet, is the third and most demanding version of the Abstraction and Reasoning Corpus benchmark series. Unlike ARC-AGI-1 and ARC-AGI-2, which presented static grid puzzles — a handful of input-output examples from which a solver must infer a transformation rule — ARC-AGI-3 drops an agent into a novel, abstract, turn-based game with no instructions, no language, and no applicable prior knowledge. The agent must explore, figure out what the game’s rules are, infer what winning looks like, and then execute efficiently — all from scratch, every time.

When ARC-AGI-3 launched in March 2026 at Y Combinator in San Francisco, every frontier AI system scored below 1%. Human testers cleared 100% of environments. As of this month, Claude Opus 5 holds the current record at 30.2%, independently verified by ARC Prize — still leaving 19 of 25 public environments unsolved by any AI system.

Performance is measured through a metric called Relative Human Action Efficiency, or RHAE. For each completed environment, the score equals the square of the ratio of the human baseline action count to the AI’s action count. The squared term is what makes ARC-AGI-3 resistant to brute-force approaches: taking twice as many actions as a human does not halve the score — it quarters it. An agent that exhausts its budget on blind exploration earns near zero regardless of whether it eventually succeeds. Only an agent that forms an accurate model of the environment quickly and acts on that model efficiently scores meaningfully.

How Tycho Writes Its Own Physics

The core idea behind Tycho is to replace a neural-weight world model with an executable one — a Python codebase the agent writes, maintains, and tests as it goes.

When Tycho enters a new environment, it starts by taking exploratory actions and recording what it observes. It then generates Python functions encoding its best current hypothesis about how the environment works: how states are represented, how actions cause transitions, what a completed level looks like, and how to plan a path from any state to the goal. These functions do not start as pre-built templates with game-specific logic — they start empty, and the agent is responsible for writing them based on what it has seen.

After each modification to this codebase, a verifier program runs automatically. It checks whether the agent’s Python model correctly predicts every transition the agent has previously observed. If the model predicts a state the environment did not produce, the verifier flags the mismatch and the agent must revise its code before proceeding. This makes the agent’s hypotheses falsifiable in a technical sense: they generate predictions that can be tested.

A second loop runs in parallel: the agent is repeatedly prompted to simplify the code. When new observations arrive, it is asked to replace special cases with shared rules, eliminate ad hoc overrides, and keep the planner expressed through the same engine as the model. This refactoring serves as a practical proxy for the Minimum Description Length principle — the theoretical idea that the best explanation of data is the one that compresses it most efficiently. An agent that represents a game’s rules as fifty special cases instead of one general rule has built a brittle model that will fail on the next level. The refactoring loop enforces simpler, more general code.

Once the agent is confident in its world model, it uses a plan executor to simulate candidate action sequences through the code — spending no real environment actions — and then commits the sequence it expects to work. If the real environment diverges from the simulation at any point, the executor stops, records the mismatch, and forces a model revision before further action.

The paper’s authors call this entire loop “active abstraction”: the agent does not passively accumulate observations but actively chooses which hypotheses to test, which actions will most reduce its uncertainty, and when it knows enough to shift from exploration to efficient execution.

What Made This Approach Legible Before Today

The code-as-world-model paradigm for ARC-AGI-3 did not begin with Tycho. Sergey Rodionov of SingularityNET published the foundational version of this architecture in May 2026, reporting that the same basic loop — write Python world model, verify against observations, refactor toward simplicity, plan through the code — fully solved 15 of 25 public ARC-AGI-3 games using GPT-5.5, with a mean per-game RHAE of 58.12%. That paper has since been accepted at AGI 2026. Rodionov’s earlier version, using GPT-5.4, solved 7 games with a mean RHAE of 32.58%.

The earlier version also came with a frank accounting of failure modes. When an agent forms an initial wrong hypothesis about an environment’s objects or goal, the verification loop can lock it into refining that wrong hypothesis rather than reconsidering it — what Rodionov called “tunnel vision.” And even a correct world model is not enough if the planner cannot efficiently search the state space it induces.

Tycho’s paper from the NIMI group — whose earlier living survey analyzed 82 approaches across all three ARC-AGI generations, finding a consistent 2-3x performance drop from ARC-AGI-1 to ARC-AGI-2 across every paradigm tested — extends and formalizes this framework. The specific additions Tycho introduces are: a systematic treatment of hypothesis management, more structured active exploration strategy, and a reusable planner skills library. The paper spans Computer Vision and Pattern Recognition alongside Artificial Intelligence and Symbolic Computation in its arXiv subject classifications — a marker that the approach integrates visual perception of grid states with symbolic rule reasoning.

What Programmatic Reasoning Implies About ARC-AGI-3

There is a deeper significance to this line of research that the paper’s technical contents do not state explicitly.

ARC-AGI-3 was designed to measure fluid intelligence — the ability to reason about genuinely novel situations, as distinguished from crystallized intelligence, which applies knowledge accumulated from prior exposure. If a programmatic world model approach outperforms pure neural scaling on this benchmark, that outcome is itself a structural argument about what the benchmark is measuring: something that requires explicit hypothesis formation, testing, and simplicity-seeking — not the retrieval of learned patterns from a large weight matrix.

The ARC Prize 2025 technical report noted that frontier AI reasoning “remains fundamentally constrained to knowledge coverage, giving rise to new forms of benchmark contamination.” Claude Opus 5’s Witness benchmark counter-evidence — where it performed at or above human efficiency on a familiar puzzle genre before taking a single exploratory action, then fell below its predecessor on a genuinely novel mechanic combination — illustrated this contamination risk from the frontier direction.

Tycho’s architecture addresses the same problem from the opposite direction: rather than training a larger model and hoping it develops the right internal representations, the system builds those representations explicitly, in code that can be read, tested, and falsified. Whether this produces better performance on the private validation set — the decisive test of generalization that the public games cannot provide — remains to be seen.

What Tycho Cannot Yet Do

The paper is candid about what the system does not yet solve. Performance varies substantially across environments and across independent runs of the same environment, a reflection of the fact that the agent’s early hypotheses shape everything that follows — and early hypotheses can be wrong in ways that are hard to recover from. The agent still depends significantly on the quality of the language model it uses as a code-generation backbone.

The main next steps identified in the paper are enforcing model-mediated execution (ensuring the agent always acts through its world model rather than bypassing it), explicit competing-hypothesis tracking (instead of committing to the first plausible hypothesis, maintaining multiple candidates until evidence rules them out), and stronger reusable planner skills.

ARC-AGI-3 remains deeply unsolved in any general sense. Even Rodionov’s 58.12% mean RHAE on the 25 public games leaves a wide gap from the human baseline of 100%, and the public games are a subset of the private validation set that has historically revealed substantial generalization gaps across the benchmark series. But Tycho’s release adds a fully reproducible, openly documented system to a research area where reproducible baselines have been scarce — and where the difference between “frontier model trained on benchmark-adjacent data” and “system that genuinely builds world models” is precisely the question the benchmark was built to answer.

The source code is publicly available at github.com/NIMI-research/Tycho.

Frequently Asked QuestionsWhat is a programmatic world model, and why does it matter for ARC-AGI-3?

A programmatic world model is an internal representation of an environment’s rules expressed as runnable code — in Tycho’s case, Python functions — rather than as learned neural weights. In a standard large language model, the model’s understanding of the world is distributed across billions of parameters in ways that cannot be directly inspected or tested. In a programmatic world model, the agent’s hypothesis about how an environment works is written out as explicit code that can be run against observations, verified, and refactored when it makes wrong predictions. This matters for ARC-AGI-3 specifically because the benchmark’s RHAE scoring heavily penalizes wasted actions: an agent that plans through a verified internal simulation before acting can commit only actions it expects to work, rather than learning from random exploration. The ARC-AGI-3 scoring design directly rewards this kind of pre-committed, model-verified execution.

How does this approach differ from how frontier AI models like Claude Opus 5 tackle ARC-AGI-3?

Claude Opus 5 and other frontier models approach the benchmark as large-scale reasoning engines — applying the representations and heuristics they developed during training to figure out what each environment requires. Tycho (and the Rodionov system it builds on) do not come to each game with pre-trained representations of game mechanics. Instead, they write their model of the game from scratch during the game, verify it against what they actually observe, and plan through it. The tradeoff is that frontier models can succeed immediately if their training has exposed them to similar mechanics, while programmatic models must construct their understanding from observations — but the programmatic approach generalizes more robustly to genuinely novel mechanics that were not in any training distribution.

What does ARC-AGI-3 actually tell us about AI intelligence?

ARC-AGI-3 was designed to measure fluid intelligence — the ability to reason about genuinely novel situations, rather than applying crystallized knowledge accumulated from prior training. The ARC Prize Foundation designed the benchmark so that a score of 100% would mean an AI can solve every environment as efficiently as the second-best human tester; ARC Prize is explicit that this would not mean AGI was achieved, but it would mean one specific, measurable human-AI gap in adaptive learning had been closed. Claude Opus 5’s Witness benchmark results — performing near-perfectly on a familiar puzzle genre but below its predecessor on novel mechanics — illustrate why the distinction between genuine fluid reasoning and sophisticated pattern retrieval remains the fundamental open question the benchmark exists to probe. Tycho’s code-as-hypothesis architecture is itself a structural argument that closing this gap requires explicit hypothesis formation, not just larger models.

Why is the open-source release significant for this field?

Most progress on ARC-AGI-3 has been reported by frontier labs (Anthropic, OpenAI) without detailed architectural explanation. The programmatic world-model line of research — Rodionov’s system (accepted at AGI 2026) and now Tycho — provides fully reproducible, inspectable systems with published code, failure analyses, and explicit failure mode documentation. This lets independent researchers build on, stress-test, and extend the architecture rather than starting over. The NIMI group’s prior living survey of 82 approaches across all three ARC-AGI generations was similarly structured as a reproducible research contribution, establishing it as a group whose work other researchers can build on.