🤖 AI

Twin: Playing an Unknown Game with a Test-Time Digital Twin

The paper introduces "Twin," a test-time world-model inference system that enables a coding agent to dynamically construct and iteratively repair executable simulations of unknown grid games through interaction, achieving a 97.8% success rate on ARC-AGI-3 levels by verifying actions against a digital twin before execution.

Original authors: Alexy Skoutnev, Kirill Acharya, Gaston Longhitano, Madeleine Udell, Kevin Ellis, Iddo Drori

Published 2026-08-17

📖 3 min read☕ Coffee break read

CC BY 4.0

Original authors: Alexy Skoutnev, Kirill Acharya, Gaston Longhitano, Madeleine Udell, Kevin Ellis, Iddo Drori

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 video game you've never seen before. There are no instructions, no tutorial, and no one to tell you what the buttons do or what you're supposed to win. You just have to press buttons, watch what happens, and figure out the rules by trial and error. This is the daily reality for artificial intelligence when it faces "unknown worlds." For a long time, AI researchers tried to teach computers to be super-smart guessers, hoping they could just memorize patterns or learn from millions of examples. But when the rules change completely, or the game is brand new, those guessers often get stuck, pressing buttons randomly until they get lucky. The big question in this corner of computer science is: How can an AI learn a new game as quickly and efficiently as a human does, without needing a million practice rounds first?

This paper introduces a clever new system called Twin that solves this by changing the game entirely. Instead of just guessing, Twin acts like a curious detective who builds a "digital twin"—a perfect, working copy of the game's rules inside a computer program. Think of it like this: when you play a new game, you might make a mental note, "If I click here, the block turns red." Twin doesn't just make a mental note; it actually writes a tiny piece of code that says, "If you click here, the block turns red." Then, before it makes any real move in the actual game, it runs a simulation in its own head using that code. If the simulation says the block turns blue, but the real game shows it turning red, Twin knows its code is wrong. It immediately rewrites the code to fix the mistake. It keeps doing this—writing, testing, and fixing its own rulebook—until its digital twin predicts the real world perfectly. Only then does it take a real action.

The results are impressive. The researchers tested Twin on 25 brand-new, mysterious grid games (part of a benchmark called ARC-AGI-3) where the rules and goals are hidden. In these games, a standard AI model playing directly without any special help managed to clear only one game and scored a low 7.8 out of 100. Even a smart AI with a standard "helper" tool improved to 61.1. But Twin, with its self-writing rulebook, cleared 23 out of the 25 games and scored a massive 93.3. Perhaps even more surprisingly, Twin figured out what "winning" looked like in 87.2% of the levels before it ever got a reward or a "game over" signal. It did this by guessing what the goal might be, testing that guess in its digital twin, and only committing to a plan if the simulation said it would work.

The paper shows that building a usable world model is actually simpler than people thought, but figuring out the goal is the hard part. Twin doesn't just react to the game; it constructs the game's logic in real-time, checks its work against every single move it has ever made, and then plans its next steps with confidence. It turns out that if you give an AI a way to write its own simulator and force it to prove that simulator works before it acts, it can learn unknown games almost as efficiently as a human playing for the first time. This suggests that the secret to smart AI isn't just having a bigger brain, but having a better way to test its own theories before making a move.

Technical Summary: Twin – Playing an Unknown Game with a Test-Time Digital Twin

Problem Statement

The paper addresses the challenge of an agent learning to play an unknown, interactive grid-world game without prior instructions, demonstrations, or explicit rules. The specific benchmark is ARC-AGI-3, a successor to the ARC reasoning benchmark, where each task is a $64 \times 64$ colored grid game. The agent must discover:

Dynamics: How the world transitions in response to actions (e.g., clicks).
Goal: The hidden win condition (a predicate $R: S \to \{0, 1\}$ ).

The evaluation metric is action efficiency, scored 0–100, rewarding agents that clear games in as few actions as a human playing for the first time. Traditional frontier models fail at most games (scoring ~7.8%) because they lack the ability to build and reason within an explicit model of the environment.

Methodology: The Twin System

The Twin system employs a "Test-time World-model Inference" approach. Instead of reacting to the environment as a black box, a coding agent writes a Python program (the "twin") that serves as an executable hypothesis of the game's world model. This model is continuously refined through a loop of validation, exploration, and planning.

Core Components

The Executable Twin:
- A Python file implementing step(grid, action) -> grid and goal_reached(grid) -> bool.
- It begins as an identity stub and is iteratively repaired.
- It allows for exact replay, deterministic long-horizon rollouts, and legible artifacts.
The Validation-Explore-Plan Loop:
The system operates under a strict harness that enforces an asymmetric objective:
- Fit (Hard Constraint): The twin must reproduce every previously observed transition before any scored action is taken.
- Reachability (Optimistic Search): Once the dynamics are validated, the agent searches for a path to a goal.
The loop consists of four stages (illustrated in Figure 1 of the paper):
- Observe & Log: The agent observes the current grid and appends the transition $(s, a, s')$ to an append-only log $D$ .
- Validate: The harness replays the entire log $D$ against the current twin code. If a mismatch occurs (a "counterexample"), the twin is blocked from acting.
- Explore:
  - Dynamics Wall: If validation fails, the system ranks repair targets based on error frequency and diversity, prompting the agent to fix the step function.
  - Goal Wall: If validation passes but no route to a goal exists, the system proposes candidate goal states based on "progress signals" (e.g., color changes, region compactness). It generates a tentative goal_reached predicate.
- Plan: A Breadth-First Search (BFS) runs inside the validated twin to find the shortest route to the proposed goal.
- ExecuteChecked: The agent submits actions one by one. If the real outcome matches the twin's prediction, the plan continues. If a mismatch occurs, the action is halted, the transition is added to the log, and the loop restarts for repair.

Goal Discovery Strategy

Inferring the goal is the harder half of the problem, as no reward is given until the level is cleared. Twin treats the win condition as a hypothesis:

Before any reward exists, the system proposes candidate goal predicates based on reachable states that look like progress.
A candidate is only tested if it evaluates to false on all logged frames (ensuring consistency with observed non-goals).
A level boundary confirms the hypothesis; reaching a candidate state without a boundary permanently rejects it.

Key Contributions

Test-Time World-Model Inference: The agent writes the simulator it plans in. The environment becomes an inspectable, falsifiable, and repairable executable hypothesis rather than a black box.
Harness-Enforced Validation: Unlike other agents that rely on prompt instructions to validate, Twin's harness mechanically blocks any scored action until the twin reproduces the entire interaction history. This prevents error compounding.
Asymmetric Objective Handling: The system separates the hard constraint of fitting observed dynamics from the exploratory search for the goal. It hypothesizes the goal before any reward arrives, allowing for goal-directed planning from the first action.
Efficiency: The system clears 179 of 183 levels (97.8%) and uses fewer actions than humans in 88.3% of cleared levels.

Experimental Results

Evaluated on the 25 public ARC-AGI-3 games (183 levels):

Performance: Twin achieves a mean score of 93.3/100, clearing 23 of 25 games.
Comparison:
- Base Model (GPT-5.6 Sol): Scores 7.8% (clears 1 game).
- Off-the-shelf Harness (Codex): Scores 61.1% (clears 13 games).
- Twin (Ours): Scores 93.3% (clears 23 games).
- Other Systems: OPINE-World (78.4), Prime Agent (78.3), EWM (63.8).
Action Efficiency: Twin uses 0.61× the number of actions humans use on average for cleared games. It uses fewer actions than competitors on 11 of 13 games where all systems cleared the same levels.
Ablation: Removing the Twin harness (leaving only the base model) drops the score to 61.1, confirming the gains come from the method, not just the base model.
Goal Inference: The first goal hypothesis is correct on 87.2% (156/179) of cleared levels. The remaining levels are solved via search.
Dynamics Accuracy: The twin predicts 79.0% of "first-seen" state-action pairs exactly, demonstrating generalization beyond simple replay.

Significance and Claims

The paper claims that building a usable world model is simpler than anticipated, whereas inferring the right goal remains the harder problem.

Paradigm Shift: Twin demonstrates that an agent can treat interaction with an unknown game as the construction of an executable hypothesis. This shifts the focus from "answering sampling" (generating many outputs and filtering) to "world-model inference" (spending compute to build a verified model).
Robustness: The harness-enforced replay validation ensures that model errors do not compound, which is critical for long-horizon games where other systems fail.
Limitations: The system assumes deterministic dynamics and small discrete states. It struggles with truly latent state (variables never shown in a frame) and probabilistic dynamics. It also relies on fixed search budgets, meaning goals beyond the horizon may remain undiscovered.

The authors conclude that while the current system achieves human-level action efficiency, the frontier lies in improving goal inference speed and handling more complex, partially observable, or probabilistic environments.