What if an LLM could keep its language model completely frozen, yet still learn how an unfamiliar world works? MEMENTO 3 gives it a rulebook, turns that rulebook into code, and lets prediction errors rewrite both. Recursive self-improvement aims to enable autonomous agents to acquire knowledge from experience and progressively improve their capabilities.

An agent entering an unfamiliar environment must learn not only which actions are useful, but also what its actions do. It may initially know neither the environment’s objects and dynamics nor the criterion for success. A model-based agent learns a world model to predict the consequences of actions before executing them.

Programs encode state transitions and goal conditions as executable functions that a planner can query repeatedly, supporting fast, inspectable simulation. Agreement with observed transitions does not guarantee correct generalisation.

A finite interaction history typically leaves a version space of programs that reproduce every observed transition but disagree on unobserved states. If every observed wall lies at column 7, “a box stops at a wall” and “a box stops at column 7” may explain the same trajectory while predicting different outcomes when a wall appears elsewhere.

Replay can reject an inconsistent program, but cannot identify the correct rule among consistent alternatives, so the agent needs to maintain and revise its generalisation hypotheses as new evidence arrives. MEMENTO 3 is the model-based continuation of the Memento series, extending reflective learning from policy and procedural memory to explicit world models.

Its central design, called Code as Model, represents the agent’s evolving understanding through a natural-language rulebook and an executable realisation. The interaction history provides episodic evidence, while the natural-language rulebook serves as semantic memory for current hypotheses about objects, actions, dynamics, and goals.

Code is generated from the rulebook for prediction and planning, so the rulebook states believed environment rules while execution fixes how those rules are applied. Together, the two representations form a persistent world-model hypothesis that can be inspected, tested, and revised throughout interaction.

The center rulebook column shows five numbered rules, each connected by an arrow to the matching numbered branch in the executable model on the right. Along the bottom, the run advances through recolour, refill, two rotations, and entry, with the displayed budget changing from fifteen of twenty-one moves to four of twenty-one at the open door.

Learning a world model from interaction involves forming and revising hypotheses about an unfamiliar environment’s rules as new evidence arrives. In Code as Model, the agent records current hypotheses in a natural-language rulebook and implements them in executable code for prediction and planning.

New observations drive revisions to the rulebook and executable, and the revised model guides subsequent interaction. Look first at the left observation panel: after moving onto the white pad, the badge visibly changes orientation. In the reflection panel below, the predicted mirrored badge does not match the observed badge, while the clockwise-rotation prediction does match it; the revised rule is then shown carried into the rulebook and executable model.

The approach learns an environment model from interaction and uses its predictions to select actions. A frozen LLM proposes transition rules and goal conditions in a natural-language rulebook and compiles them into executable code. A planner queries the verified executable to search for action sequences predicted to reach a goal within the remaining budget.

The agent follows the resulting plan, using discrepancies between predicted and observed outcomes to guide revisions to the rulebook and code. The rulebook serves as persistent semantic memory, recording current hypotheses about entities, action semantics, dynamics, goals, and termination conditions.

The executable realisation supplies a transition predictor and an inferred goal condition over its own internal state space. The persistent world-model hypothesis is the pair of the rulebook and its executable realisation. Together with the interaction record, that pair forms the agent’s external learning state.

Code as Model constructs and selects rulebook–executable hypotheses from the interaction record. The frozen LLM expresses candidate rules in a rulebook and compiles them into a simulator with its own internal state representation. Replay tests the simulator’s observation predictions against the history and reconstructs its current internal state.

An accepted rulebook–executable pair and its reconstructed state supply the belief approximation used for planning. The revision choices include retaining the current rulebook–executable pair, revising the rulebook and its executable realisation, or repairing the executable while retaining the rulebook.

Given the updated interaction history and the current pair, the frozen LLM proposes a revision choice. Exact replay checks the observation-consistency requirement. For a single trajectory, verification indicates whether the executable predicts every recorded next observation correctly, and the passing programs form the checked set.

Verification can leave multiple rulebook–executable pairs in the admissible set. Selecting a working hypothesis completes the update operator, and the control operator then uses that hypothesis to choose actions. In the single-model case, Code as Model uses the LLM to prefer a simpler explanation and implementation among the admissible pairs.

When no goal-reaching plan is available, the LLM uses the interaction history and unresolved rulebook hypotheses to choose an intermediate target. The target can involve testing a mechanic, revealing an unseen region, or interacting with an unexplained object, and an auxiliary planner searches the executable for a sequence reaching it.

Execution compares predicted and observed outcomes after each action and stops on a mismatch, returning the new evidence to reflection. The single-model planning approximation commits to one explanation of the rules and current state. Other admissible pairs can fit the same history while prescribing different plans, and repeated runs can select different initial hypotheses whose plans influence later evidence.

A plausible but incorrect model can remain self-confirming if its actions never expose its errors. Exact replay can leave several world-model hypotheses consistent with the same evidence, and the LLM favours concise rulebooks and implementations subject to rulebook fidelity and exact replay.

This preference does not eliminate uncertainty, and committing to one hypothesis may steer exploration away from evidence that would falsify it. The population extension maintains world models in parallel, each represented by a rulebook–executable pair and sharing the same interaction history.

One member is sampled for each planning episode, and the resulting transitions are used to check all members. Different models can guide exploration while remaining consistent with shared evidence; one model recovers the single-model setting. For more than one model, the system maintains world models in parallel, each comprising a rulebook and its executable realisation.

These models may encode different hypotheses about the same environment. They share the interaction record rather than interacting with separate environment copies. The evaluation covers all 25 public ARC-AGI-3 games.

Every action sent to the environment is counted, including actions used in failed attempts and after the reset that follows. The reported Relative Human Action Efficiency is higher when better, with 100 as the ceiling. The agent observes only the action interface and cannot inspect the environment source.

Figure 6 lays out the benchmark as a grid of distinct game interfaces, with each tile labeled by a game code and its level count. The bottom-right panel also makes the interaction constraint concrete: the available controls are shown, but their meanings are explicitly withheld from the agent.

CODE-AS-MODEL reaches the 100 ceiling on all 25 games, yielding a mean Relative Human Action Efficiency of 100.0. A ceiling score requires every level to be cleared and the level-weighted mean to be at least 1. The total action count for every game is below its human baseline.

The agent clears all 25 games in 7,518 actions, which is 0.44 of the human baseline of 17,135. Per-game ratios range from 0.20 on m0r0 to 0.67 on lf52, with a median of 0.42. Baseline1 is the only other system to finish every game, using 8,347 actions, or 0.49 of the human budget.

The other four systems leave games unfinished: OPINE-World leaves 5, NOOA 6, DreamTeam 19, and Continual Harness 22. In the reported runs, the rulebook variant uses fewer actions and fewer agent turns in every difficulty band. Across the three games, it uses 617 rather than 677 actions, a reduction of 9 percent, and 678 rather than 830 agent turns, a reduction of 18 percent.

The reduction in actions is consistent across all three games, while the largest reductions in agent turns occur on ft09 and cn04. With task completion held constant, these results suggest that the persistent rulebook improves convergence to an effective executable model.

The evaluation uses ARC-AGI-3, where agents must infer unfamiliar game rules and goals under a human-derived action budget. The single-model agent clears every level of all 25 public games, reaches a mean Relative Human Action Efficiency of 100.0, and uses 44 percent of the corresponding human action count.

Compared with Claude Opus 5 with the ARC Prize Standard harness, the agent achieves a 59.3-point higher mean Relative Human Action Efficiency. The learned controller is evaluated in three episodes, each with a different opening, and wins 21 to 0 in all three, achieving the maximum episode score of 21.

Openings 1, 2, and 3 require 3,358, 4,014, and 5,039 actions, respectively. The LLM is used only during learning, while during evaluation the controller is held fixed. The episode scores and learning costs are reported alongside no-world-model and random-policy baselines.

In the plot, the three green trajectories climb in discrete scoring steps and stay at or above zero after their openings, while the orange and dashed gray trajectories descend below zero early. Their endpoints are separated by roughly forty-one score points, as indicated by the labeled endpoints near positive twenty-one and negative twenty.

The Atari Pong case study examines whether the learning mechanism can support feedback control in addition to discrete planning. In Atari Pong, the learned model supports a controller that wins 21 to 0 in three evaluated episodes with different openings, acting without further LLM calls.

Figure three models recursive self-improvement as a loop between the environment and the agent. Each hidden environment state produces an observation, which enters the agent’s history, rulebook, and executable; that state selects an action, while the next observation, together with the prior state and action, supports an update.

The visual matters because it makes explicit how executable learning couples model induction, exploration, and goal-directed planning over continued interaction. The central result is a verified loop in which a frozen LLM builds and revises executable world models.

On ARC-AGI-3, the agent clears all 25 public games, and its learned Pong controller wins every evaluated episode without further LLM calls.