Scoring 21–0 in Pong, AI Doesn’t Even Need to Call an LLM Anymore
Leveling up while playing games?
Huawei’s latest research enables AI to literally get stronger as it plays.
Developed jointly by Huawei Noah’s Ark Lab and UCL, an AI agent system called Memento 3 has cleared all 25 games and 183 levels across the public ARC-AGI-3 benchmark.

And this wasn’t achieved through brute-force trial and error.
Human players require an average of 17,135 actions to complete the same levels; Memento 3 took just 7,518—about 56% fewer actions than humans, earning a perfect score of 100 on the Relative to Human Action Efficiency (RHAE) metric.

Even more striking: built on Claude Opus 5 as its base model, the system never updated model weights, nor was it fine-tuned for any of these game tasks.
It relied entirely on hands-on exploration, deducing operational rules, writing code to simulate environments, and self-reflecting and correcting when making mistakes—ultimately achieving a flawless run.
In comparison, Claude Opus 5 scored an average RHAE of roughly 40.7 points in the standard official ARC Prize evaluation framework. With the exact same foundation model, this agent architecture alone boosted the score by a massive 59.3 points.
What’s more, this method isn’t just limited to puzzle games. The team also tested it on the classic Atari arcade game Pong. Once the AI figured out the control policy on its own, it no longer needed to send any inference calls to the LLM, shutting out its opponent 21–0 across three consecutive matches.
How does the game continue running smoothly without real-time LLM inference?
The core mechanism is right in the research title: Model-Based Recursive Self-Improvement.

Huawei AI Beats 25 Games with 56% Fewer Actions Than Humans
The 25 benchmark games come from the ARC-AGI-3 benchmark released by the ARC Prize. Compared to earlier ARC iterations, this version marks a fundamental shift:
Instead of static “input-output” question-answering, AI is thrown directly into unfamiliar, interactive game environments.
The AI must figure out the rules on its own, discover the objective, and learn the effects of different actions purely through trial and error.

The 25 public games comprise 183 levels. Visually, most feature simple pixels, grids, colors, and geometric shapes, reminiscent of retro minigames.
Yet beneath the minimalist visuals lies extreme reasoning complexity. For AI, motor control isn’t the challenge; the real bottleneck is deciphering an entirely unknown environment: What chain reaction does stepping on a special tile trigger? Is the door locked because of a color mismatch or an incompatible geometric shape? Worse still, subsequent levels can introduce novel mechanics that entirely overturn previously established rules.
Even for human players, these games are notoriously challenging.
According to ARC Prize test data, in the puzzle game r11l—where players control an amoeba’s movement and color changes—all 10 human testers cleared it; but in tr87, a puzzle game testing symbol deciphering mechanics, only 6 out of 12 challengers succeeded.

Competition on this benchmark was already fierce among top research groups:
- Princeton University’s Continual Harness cleared only 3 games, scoring 20.5 points;
- DreamTeam, co-developed with NVIDIA researchers, cleared 6 games with a score of 38.1;
- OPINE-World (by independent researcher David Courtis) and NOOA (by an NVIDIA team) achieved 78.4 and 85.1 points, respectively;
- baseline1, built by independent developer Sergey Rodionov, stood out by clearing all 25 games and earning 99 points—just one point shy of perfection.
Memento 3, from Huawei’s joint research team, closed that final 1-point gap.
Not only did Memento 3 achieve a perfect score of 100 across all 25 games and 183 levels, but it also reduced total action steps to 7,518—829 fewer than baseline1’s 8,347—surpassing competitors in both completion rate and operational efficiency.
How did it pull this off?
Zero Fine-Tuning: Building Self-Iterative Mechanisms via Code
According to the paper, Memento 3’s core paradigm is dubbed Code as Model.
The core intuition is to let the agent autonomously construct two vital assets during exploration: a continuously updated notebook of rules, and a suite of executable code that simulates the game’s physical dynamics.
- Rulebook: A Markdown document documenting the environmental dynamics inferred by the AI, including action outcomes, win conditions, and tentative edge-case rules.
- Executable World Model: The AI translates its synthesized rules into standalone, executable Python code, essentially building a lightweight in-memory game simulator.

Armed with these two tools, the AI can perform multi-path rollouts and pruning inside the code simulator before committing to any real actions, thereby selecting the optimal sequence.
But what happens if the initially inferred rules are flawed?
Memento 3 features self-reflection and falsification mechanisms: whenever real observations contradict simulated predictions, it actively restructures its rules.
The paper highlights a representative case: when encountering a special tile in a puzzle game, the AI initially hypothesized that stepping on it would mirror the pattern based on the entry angle. However, upon real execution, it found that the pattern actually rotated 90 degrees clockwise, completely independent of the entry direction. The AI immediately updated its rulebook and refactored the underlying Python simulation code in lockstep.

After updating the rules, the system initiates a verification pipeline: it replays past action trajectories, comparing the 64×64 visual state pixel-by-pixel to confirm whether the code faithfully reproduces real outcomes. If discrepancies persist, it continues tuning the code logic until the simulator aligns perfectly with the ground-truth environment.
Furthermore, prior knowledge accumulated in earlier levels seamlessly transfers to later ones.
In the symbol-deciphering puzzle game tr87, for example, the AI initially couldn’t tell whether symbol orientations carried semantic meaning, but gradually learned that symbols with different orientations could map to the same letter. As new levels unlocked, it promptly refined its logic for determining cursor positions. Over the entire run, the rulebook underwent 11 version iterations.

To ensure state traceability, the researchers integrated Git version control. Every modification to the rules and code produces a commit. If subsequent deductions encounter logical drift or bugs, the system can revert to an earlier snapshot and branch out in a new direction.

This establishes the Recursive Self-Improvement (RSI) closed loop described in the paper: with the base model parameters frozen, the agent achieves autonomous performance leaps by continuously consolidating experience, iterating on rules, and evolving its code.
Ablation studies further confirmed the value of the rulebook: in control experiments across three games, keeping the rulebook required 617 total actions to clear them; stripping away the rulebook and keeping only the code world model increased the action count to 677. The rulebook reduced action steps by approximately 9% and agent interaction turns by roughly 18%.
The researchers also explored a dual-model architecture: running two world models in parallel, sharing trajectory data while maintaining divergent rule hypotheses and counterfactual reasoning. In the game wa30, the single-model approach took 899 actions, whereas the dual-model setup slashed this to 597 actions—a further efficiency gain of roughly 34% (currently, this dual-model advantage has primarily been validated on wa30; generalizability across other environments remains to be explored).
These results demonstrate that even without retraining or fine-tuning foundation models, AI can evolve its capabilities autonomously simply by refining an external world model.
21–0 Shutout: Ditching Real-Time LLM Inference Once Policies Crystalize
To test the approach’s generalization potential in dynamic, continuous environments, the team deployed Memento 3 in the classic arcade game Atari Pong.
Unlike discrete grid-based puzzles, Pong involves continuous ball motion, bounces, and collision trajectories, requiring the agent to infer physical laws while executing real-time trajectory planning for paddle movements.
The test highlighted the system’s adaptability:
Initially, the AI had no prior knowledge of ball-bounce physics and had to hypothesize rules on the fly. It started with the assumption that the paddle was divided into four deflection zones, each determining a specific return angle; during play, however, it encountered an unexpected horizontal deflection.
Detecting this discrepancy, the AI recalculated the collision point parameters, restructured its bounce dynamics equations, and continued fine-tuning across subsequent deviations—ultimately fitting a physics model remarkably close to ground truth.

Once the control policy converged and solidified, the researchers ran the synthesized program completely decoupled from the LLM—no longer making calls to Claude Opus 5, nor updating the rules.
In this offline state, the AI swept its opponent 21–0 across three different opening configurations.
At this stage, the LLM was completely removed from frame-by-frame action decisions. Its role shifted: handling rule exploration and policy synthesis early on, then compiling that logic into deterministic execution code once finalized.
Comparative experiments showed that without a world model—relying solely on the LLM to generate actions frame-by-frame from visual inputs—the score plummeted to -19, barely better than random actions (-20.7).
Rather than paying for expensive LLM forward passes at every single step, extracting rules upfront and delegating execution to a lightweight program proves dramatically more efficient.
Data shows that Memento 3 converged on an effective control policy in just ~9,500 game frames; in contrast, conventional reinforcement learning benchmarks typically require hundreds of thousands, if not hundreds of millions, of frames.
Naturally, there are still cost trade-offs: during the exploration phase, Memento 3 relied on Claude Opus 5 in high-reasoning mode, consuming substantial tokens and compute for code generation, static analysis, and verification. Furthermore, current experiments focus primarily on well-defined game sandboxes with closed rule systems; its viability in open-ended, stochastic real-world tasks remains to be validated.
Nevertheless, this research offers a compelling takeaway for embodied AI and general-purpose agents:
Recursive Self-Improvement (RSI) does not necessarily require frequent updates to underlying model weights. By constructing an inspectable, executable, and rollback-capable external world model, frozen-parameter foundation models can still achieve self-iteration and dramatic capability leaps in unfamiliar domains.
Paper:
https://arxiv.org/abs/2610.11794
Reference link:
https://x.com/ScarletKc/status/2109169173540884935