Huawei Noah Lab Releases Memento 3: World Model RSI Enables Zero-Fine-Tuning ARC-AGI-3 Mastery with 56% Higher Efficiency Than Humans

Yishui, reporting from Ao Fei Si QbitAI | WeChat Official Account: QbitAI

Leveling up while gaming?

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

A recent study from Huawei's Noah's Ark Lab, in collaboration with UCL and other teams, introduces an AI agent system called Memento 3.

It successfully cleared all 25 games and 183 levels in the public ARC-AGI-3 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—and achieved 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 any model weights or fine-tuning for specific games.

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

Then... it cleared everything with a perfect score.

For comparison, under the official ARC Prize 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.

But 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 and then defeated opponents 21-0 in three consecutive matches without needing further inference requests from the large language model.

Wait, the LLM wasn't even involved in subsequent operations, yet the AI played so flawlessly?!

The key lies in the title of this research:

Model-Based Recursive Self-Improvement.

Huawei AI Clears 25 Games with 56% Fewer Actions Than Humans

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

They come from ARC-AGI-3, released by ARC Prize. If you follow AI benchmarks, you're likely familiar with the ARC series.

However, this generation features a significant change:

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

Rules must be inferred by the AI; goals must be discovered 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 resemble retro mini-game collections from decades ago.

But don't let the simplistic graphics fool you.

For AI, figuring out how to operate isn't the hardest part; the real challenge is understanding how the world works.

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

It gets even trickier because later levels may introduce new rules that completely overturn previously learned experiences.

Not just AI—even human players get stuck.

ARC Prize test data shows that in r11l, a puzzle game requiring players to move and change the color of an amoeba, all 10 participants succeeded. However, in tr87, a puzzle testing symbol decryption skills, only 6 out of 12 challengers succeeded.

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

Princeton University's Continual Harness cleared only 3 games, scoring 20.5.

NVIDIA researchers' DreamTeam performed slightly better, clearing 6 games with a score of 38.1.

Moving higher up, independent researcher David Courtis's OPINE-World and NVIDIA's NOOA scored 78.4 and 85.1, respectively.

The strongest performer was independent developer Sergey Rodionov's baseline1, which cleared all 25 games and scored 99 points—just one point shy of perfection.

But Huawei's team has now closed that final gap.

Memento 3 not only cleared all 25 games and 183 levels with a perfect score of 100, but it also reduced the total action count to 7,518—829 fewer actions than baseline1's 8,347.

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

How was this achieved??

No LLM Training Required: AI "Levels Up" by Writing Its Own Strategy Guides

Looking at the paper, Memento 3's core method is called Code as Model.

While abstract, it essentially involves the AI preparing two things during gameplay:

An ever-updating strategy guide and a piece of code capable of simulating the game environment.

• Rulebook: A Markdown document recording patterns the AI discovers in-game, such as which actions trigger which effects, how to clear levels, and which rules remain unclear.
• Executable World Model: The AI translates its summarized rules directly into runnable Python code, effectively building 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 what if the initially understood rules are wrong?

Don't worry—Memento 3 doesn't just write guides; if it finds errors, it rewrites them from scratch.

The paper provides an example.

In a puzzle game, the AI encountered special floor tiles. Initially, it assumed that stepping on them would cause the character's carried pattern to mirror-flip based on the entry direction.

It wasn't until we actually tried it that we discovered the pattern isn’t a flip, but a 90-degree clockwise rotation, regardless of the entry direction.

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

However, changes still need verification.

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

If there’s a mismatch, it keeps iterating.

In this way, the AI explores while correcting errors, refining the rules with each iteration.

Moreover, lessons learned in earlier stages 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 emerged, it overturned its previous understanding of cursor positions.

Throughout the entire game session, the single rulebook went through 11 iterations.

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

Every modification to rules and code is logged. If an error is detected, they can review historical versions and revert if necessary.

Wow, playing a game also involved maintaining a code repository.

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

Without altering the large model’s parameters, the AI becomes more proficient simply by accumulating experience and iteratively modifying rules and code.

Furthermore, this approach is backed by data.

The research team conducted controlled experiments across three games:

With the rulebook retained, the AI required a total of 617 actions; without the rulebook, relying solely on the code-based world model, it needed 677 actions.

Essentially, having this "strategy guide" reduced action counts by approximately 9% and agent execution rounds by about 18%.

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

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

So, they had the AI maintain two world models concurrently, sharing gameplay logs but independently inferring different rule hypotheses.

The result: In game wa30, a single world model required 899 actions to clear the level. Switching to dual world models dropped this directly to 597 actions.

Action counts were further reduced by approximately 34%.

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

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

Without retraining the large model, the AI can become stronger 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, challenging Memento 3 with the classic arcade game Atari Pong.

Unlike the previous puzzle games, here the ball moves and bounces continuously. The AI not only needs to grasp the game rules but also must judge the ball’s trajectory in real-time to control the paddle.

This test yielded some surprising new insights.

Initially, the AI didn’t know the ball’s 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 play, a horizontal bounce suddenly occurred.

Huh? That doesn’t match the previously summarized rules.

So, the AI re-analyzed collision positions, modified the bounce formula, and continued adjusting when encountering new trajectory deviations, gradually deriving motion laws that better reflected reality.

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

No longer calling Claude Opus 5, and no longer updating rules.

The result: Across three different starting conditions, it achieved a perfect 21 victory every time.

Amazing—it started out figuring out how to catch the ball, then ended up shutting out the opponent completely???

Note that at this stage, the large model no longer needs to actively participate.

It is responsible only for initial rule exploration and strategy summarization. Once the tactics are learned, execution is handed over to the code.

By comparison, if the world model isn’t used and the large model is forced to decide each move based solely on the current screen, the final score is -19, barely better than random button mashing (-20.7).

The contrast highlights the difference clearly.

Rather than having the large model rethink every step, it’s better to let it learn how to play first, then delegate execution to the program.

Efficiency is also impressive.

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

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

Of course, this doesn’t mean Memento 3 is cost-free.

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