Memento 3: Recursive Model-Based Self-Improvement via Reflective Rulebooks

Meta description: Memento 3 uses a frozen LLM and a self-improvement loop that turns experience into natural-language rules and executable code for unknown environments.

Tags: Memento 3, Recursive Self-Improvement, Frozen LLM, AI Agents, Model-Based Learning

Featured image: Abstract glowing nodes forming a looping pathway over a dark grid, no people, no logos, no text.

In unfamiliar environments, an agent cannot rely on a fixed policy. It must discover rules, test them, and revise its behavior. Memento 3 is introduced as a model-based approach to recursive self-improvement (RSI) with a frozen LLM, meaning the language model is not retrained during the process. Instead, the system improves the external representations it uses: a natural-language rulebook, executable code, and a world model. That shift matters because it offers a path toward agents that can keep learning without constantly updating large model weights.

Background: Agents Need a Way to Learn Rules They Were Not Given

When an agent enters an unfamiliar environment, the central difficulty is not simply choosing an action. The agent first has to understand what actions are possible, which constraints matter, and what consequences follow from each choice. In many traditional setups, a fixed policy or a fixed set of instructions must be designed before deployment. That works when the environment is known, but it becomes fragile when the rules are hidden, changing, or only discoverable through interaction.

This is the problem space where model-based learning becomes useful. Rather than only mapping observations directly to actions, a model-based agent tries to maintain an internal representation of how the world behaves. It can then plan using that representation and update it when experience contradicts its assumptions. Memento 3 addresses this issue with a structured loop centered on natural language, code, and observed outcomes.

Development: From Experience to a Rulebook, Then to Executable Code

The process begins with experience. As the agent interacts with its environment, it collects evidence about what works, what fails, and which patterns recur. Memento 3 converts that evidence into a natural-language rulebook. The rulebook is a provisional description of the environment built from the agent's own observations.

The next step is to make that description operational. The natural-language rulebook is compiled into executable code for planning. This matters because language can express rules, but planning usually requires something more precise: state transitions, constraints, search procedures, or action sequences. By translating rules into code, Memento 3 creates a bridge between what the agent believes it has learned and what it can actually use to choose future actions.

The loop does not stop after generation. The system tests and revises both the rulebook and the code against observed outcomes. If the agent predicts that an action will lead to a certain result, and the environment does not produce that result, the mismatch becomes feedback. The rulebook can be amended, the code can be adjusted, and the world model can be updated. This testing phase turns learning from a one-time summary into an ongoing correction process.

Latest Stage: A Frozen LLM Guides Recursive Improvement Without Retraining

A key part of Memento 3 is that the LLM is frozen. In this context, “frozen” means the underlying language model weights are not changed during the agent's self-improvement cycle. Instead of updating the model itself through training, the system updates the artifacts the model produces and uses: the rulebook, the executable code, and the world model.

This creates a recursive self-improvement (RSI) loop at the level of the agent's knowledge and planning machinery. What the agent learns helps it decide what to investigate next. In turn, those investigations produce new observations, which refine the rulebook and code, which shape future plans. The improvement is recursive because the output of one cycle changes the input conditions of the next cycle.

The design has a practical implication. Because the LLM remains frozen, the approach avoids the need to continually retrain or fine-tune a large language model for each new environment. Instead, adaptation happens through external structures such as the rulebook, the executable code, and the world model. That separation can make the learning process more transparent, since revisions can be inspected in the rulebook and code rather than hidden inside updated model weights.

Current Stage and What to Watch Next

At present, Memento 3 is described as a model-based RSI approach for agents operating in unfamiliar environments. The contribution emphasized is the sequencing of mechanisms: experience becomes natural-language rules, rules become executable planning code, code and rules are tested against outcomes, and the updated world model directs the next round of exploration.

The name Memento 3 identifies the introduced approach. The current phase emphasizes a closed loop rather than a static instruction set. What to watch next is how such loops behave when environments are noisy, when rules conflict, when code generation fails, or when the agent must decide which unknown to test first. Those questions will determine whether a frozen-LLM self-improvement cycle can support reliable learning beyond controlled settings.