Huawei Noah and UCL Release Memento 3: Recursive Self-Improvement via World Models Clears ARC-AGI-3 with 56% Higher Efficiency Than Humans

AI beats the game 21, no longer needing to call the large model

Yi Shui from Ao Fei Si

QbitAI | WeChat Official Account QbitAI

Leveling up while playing games?

Wow, Huawei has directly taught AI how to "get stronger by playing."

In a recent study, Huawei Noah’s Ark Lab, in collaboration with UCL and other teams, introduced an AI agent system called Memento 3—

It successfully cleared all 25 games and 183 levels in the ARC-AGI-3 public dataset.

And it didn’t just brute-force its way through via mindless trial and error.

Humans require 17,135 actions to complete the same set of levels.

Memento 3 used only 7,518 actions, approximately 56% fewer than humans, achieving a perfect RHAE score of 100 (Relative Human Action Efficiency).

Even more astonishing is that this system uses Claude Opus 5 as its base model, without updating model weights or fine-tuning for the games.

It simply started playing on its own, figured out the rules, wrote code, reflected on mistakes, and made corrections.

Then... it achieved a perfect clear.

For comparison, under the ARC Prize official standard testing framework, Claude Opus 5 averages an RHAE score of only about 40.7.

With the same base model but a different agent system, the performance skyrocketed by 59.3 points.

That’s not all.

This method isn’t limited to puzzle games; the research team also had it play the classic Atari game Pong.

The result: The AI independently developed a control strategy, then stopped requesting inference from the large model entirely, defeating the opponent 21 in three consecutive rounds.

Wait, the large model wasn’t even involved in subsequent operations, yet the AI still played so smoothly?!

The key lies in the title of this research:

Model-Based Recursive Self-Improvement.

Huawei’s AI clears 25 games directly, using 56% fewer actions than humans

First, let’s look at what these 25 games are.

They come from ARC-AGI-3, launched by ARC Prize. Those following AI benchmarks should be familiar with the ARC series.

However, this generation features a significant change:

It’s no longer just about solving problems; instead, AI is thrown directly into unfamiliar game worlds.

Rules must be guessed by the AI; goals must be found by the AI; and the effects of actions must be tested by the AI.

AI: So I have to do everything myself~

These 25 public games contain a total of 183 levels, with visuals mostly composed of simple pixels, blocks, colors, and shapes.

At first glance, they might even resemble retro mini-game collections from decades ago.

But don’t be fooled by their modest aesthetics.

For AI, figuring out how to operate isn’t the hardest part; the real challenge is having absolutely no idea how the world works.

What happens when you step on a special floor? If a door won’t open, is it because the color doesn’t match, or the shape is wrong?

To make matters worse, later levels may introduce new rules that completely overturn previously discovered experiences.

Not just AI—human players get stuck too.

According to ARC Prize test data, in a puzzle game named r11l requiring players to move and change the color of amoebas, all 10 participants completed the level. In contrast, in another puzzle game tr87 testing symbol decryption skills, only 6 out of 12 challengers succeeded.

Before Huawei’s AI, various research teams were already competing fiercely:

Continual Harness, developed by Princeton University, cleared only 3 games, scoring 20.5.

DreamTeam, co-developed by NVIDIA researchers, performed slightly better, clearing 6 games with a score of 38.1.

Higher up, OPINE-World by independent researcher David Courtis and NOOA by the NVIDIA team scored 78.4 and 85.1, respectively.

The most impressive was baseline1 by independent developer Sergey Rodionov, which not only cleared all 25 games but also scored 99, just one point shy of perfection.

But Huawei’s team this time filled in that final missing point.

Memento 3 not only cleared all 25 games and 183 levels with a perfect score of 100 but also reduced the total number of actions to 7,518, saving 829 actions compared to baseline1’s 8,347.

It didn’t just clear the games; it did so with fewer steps.

How was this achieved??

No need to train the large model; AI achieves "leveling up" by writing its own walkthroughs

Looking through the paper, Memento 3’s core method is called Code as Model.

Sounds abstract, but essentially, it involves the AI preparing two things for itself during gameplay:

A constantly updated game walkthrough, and a piece of code capable of simulating the game’s execution.

• Rulebook: A Markdown document recording the patterns the AI discovers in the game, such as which actions trigger which effects, how to clear levels, and which rules remain unclear.
• Executable World Model: The AI writes the summarized rules directly into executable Python code, effectively creating a simplified game simulator.

With these two components, the AI can simulate different paths within its self-built emulator before deciding on the next move.

But here’s the problem: What if the initially understood game rules are wrong?

Don’t worry, Memento 3 not only writes its own walkthroughs but can also discard them and start over if errors are detected.

The paper provides an example.

While encountering a special floor in a puzzle game, the AI initially assumed that stepping on it would cause the character’s carried pattern to mirror-flip based on the entry direction.

After actually trying it, the AI discovered that the pattern rotates 90 degrees clockwise, regardless of the entry direction.

Consequently, the AI modified the rulebook, and the corresponding Python code was updated accordingly.

However, changes must be verified.

The system re-simulates previous actions, comparing the 64×64 game screen cell by cell to ensure the code accurately reproduces real results.

If there’s a mismatch, it continues to revise.

Thus, the AI explores and corrects errors simultaneously, refining the rules progressively.

Moreover, experiences learned earlier can be applied to subsequent levels.

For instance, in the symbol decryption game tr87, the AI initially couldn’t determine whether symbol orientation affected meaning. It later discovered that symbols facing different directions could represent the same letter.

As new levels appeared, it overturned its previous understanding of cursor positions.

Throughout the entire game, the single rulebook underwent 11 versions.

To facilitate backtracking, the research team even introduced Git version control.

Every modification to rules and code is logged, allowing the team to review historical versions if errors are discovered and restore previous states when necessary.

Talk about multitasking—while playing a game, they were also maintaining a code repository.

This is precisely what the research team refers to as Recursive Self-Improvement (RSI).

Without altering the large language model's parameters, the AI becomes increasingly proficient by continuously accumulating experience and modifying its rules and code.

Moreover, this approach is backed by data.

The research team conducted controlled experiments across three games:

When retaining the rulebook, the AI required 617 actions in total; removing the rulebook and keeping only the code-based world model increased this to 677 actions.

In other words, having this "strategy guide" reduced action counts by approximately 9% and agent execution rounds by roughly 18%.

But the research team wasn't satisfied with just that.

If one world model helps the AI avoid detours, what happens if you use two simultaneously?

So, they had the AI maintain two world models concurrently, sharing gameplay logs while each independently inferring different rule assumptions.

As a result, in the game wa30, a single world model required 899 actions to complete the level, whereas switching to dual world models dropped this directly to 597 actions.

Action counts decreased by another ~34%.

Of course, this improvement has currently only been validated on wa30 and cannot yet be generalized to other games.

However, at least within these experiments, Memento 3 proved one thing:

Without retraining the large model, the AI can grow stronger through play by continuously refining its understanding of the world.

Winning 21 in Pong: The AI No Longer Needs to Call the LLM

Is this method limited to puzzle games?

The research team decided to raise the stakes, pitting Memento 3 against the classic arcade game Atari Pong.

Unlike the previous puzzle games, where the ball constantly moves and bounces, the AI here needed not only to grasp the game rules but also to predict the ball's trajectory in real time and control the paddle to intercept it.

This test revealed something new.

Initially, the AI was unaware of the bounce patterns and had to learn by doing.

It first hypothesized that the paddle could be divided into four zones, with the ball bouncing in corresponding directions depending on where it hit.

Then, during gameplay, an unexpected horizontal bounce occurred.

Wait? That doesn't match the previously summarized rules.

Consequently, the AI re-analyzed the collision points, modified the bounce formula, and continued adjusting as it encountered further trajectory deviations, gradually deriving motion laws that better reflected reality.

Once the control strategy matured, the research team let the program run independently.

No more calls to Claude Opus 5, and no further rule updates.

The result? Across three different starting conditions, it achieved a clean sweep of 21 every time.

Amazing! It went from figuring out how to catch the ball to shutting out the opponent completely???

Note that at this stage, the large model no longer needs to intervene directly.

It is responsible only for the initial phase of exploring rules and summarizing strategies. Once the tactics are learned, they are handed off to the code for execution.

For comparison, without using a world model—if the large model were forced to decide each move based solely on the current screen—the final score would have been -19, barely distinguishable from random button mashing (-20.7).

The contrast highlights the difference clearly.

Rather than having the large model rethink every step, it is more effective to let it learn how to play first, then delegate execution to the program.

The efficiency gains are also impressive.

According to the paper, Memento 3 learned this control strategy using approximately 9,500 frames of gameplay.

By comparison, many traditional reinforcement learning methods often require hundreds of thousands or even hundreds of millions of training frames.

Of course, this does not mean Memento 3 comes without cost.

After all, it relies on Claude Opus 5 with Extra-High reasoning intensity enabled. The processes of exploration, code generation, and validation consume significant tokens and computational resources.

Furthermore, current experiments primarily target game environments with relatively clear rules. Whether this method remains effective in more complex, dynamic real-world scenarios still requires verification.

Nevertheless, this research points to a noteworthy direction:

Recursive Self-Improvement (RSI) does not necessarily require modifying the underlying model weights. By constructing external world models that are inspectable, executable, and rollback-capable, frozen-parameter general-purpose LLMs can self-iterate and rapidly evolve in unfamiliar domains.

Paper link:

https://arxiv.org/abs/2610.11794