Google researchers develop memory mechanism for recursive AI self-improvement
A new framework allows AI models to inherit optimization logs from previous versions, preventing performance loss when switching underlying models.

The short version
- SIM records the rationale, predicted outcomes, observed results, and evaluation context for every code modification.
- The framework enables models to inherit experience across different families, such as moving from Claude Opus to Gemini.
- Tests show that models using SIM achieved a 16-point surge in workspace task performance compared to those with only code transfers.
- The mechanism allows for "compound growth" where each new iteration builds on the cumulative logs of all previous versions.
Why it matters
This research addresses a major hurdle in AI development: the loss of progress when upgrading the underlying model. By creating a standardized "handover document," developers can ensure that complex agent behaviors and fixes are preserved across different AI architectures.
The problem of lost progress
When developers optimize AI agents, they often modify a "Harness"—an outer layer of prompts, tools, and rules—rather than the model's underlying weights. Over time, this harness becomes highly refined through countless trials and errors to handle specific tasks or bugs.
However, a significant problem occurs when the underlying model is replaced. A harness optimized for one model, like Claude Opus, may perform worse than a new model's native setup when moved to a different model, like Gemini. This happens because the new model sees the complex rules but lacks the "reason" behind why those specific modifications were made.
Without knowing the original intent, a new model's optimizer might treat critical bug fixes as redundant code and delete them. This can lead to a cycle of random modifications where the AI repeatedly fails or creates new errors, effectively losing all previous progress. As 36Kr reported, this creates a "nightmare" for developers who must constantly rebuild optimizations for every new model release.
How Self-Improvement Memory works
To solve this, Google researchers developed a framework called Continual Recursive Self-Improvement (CRSI), powered by a mechanism called Self-Improvement Memory (SIM). Instead of just saving a chat history, SIM acts like a structured "geek development log" that records every single tinkering action the AI takes during optimization.
Every time the AI modifies the harness code, the SIM mechanism groups these changes by their root cause. It records four specific elements: the rationale for the change, the predicted outcomes, the actual observed results, and the specific evaluation context used during the test. This creates a detailed "handover document" for the next generation of the model.
When a new model takes over a complex harness, it reads this log before beginning any new optimization. By learning from the "wisdom" of past mistakes and successes, the new model understands the architecture's history. This allows the AI to maintain the integrity of previous fixes while seeking out new areas for improvement.
Testing the inheritance bridge
The researchers verified this mechanism by conducting a cross-model relay race. They took a harness evolved by Claude Opus 5.5, packaged it with its SIM memory, and handed it over to Gemini 3.8 Flash to continue the optimization process. This test specifically looked at a "premature completion" bug where the AI would falsely claim a task was done before executing a command.
In scenarios without SIM, Gemini struggled to understand the existing interceptor code and repeatedly crashed or rewrote the section into a mess. It behaved like a novice programmer who did not understand the previous architecture and was simply piling messy code on top of a bad base. The AI failed to recognize that the code was there to prevent a specific type of failure.
With the SIM log, the results were different. Gemini read the log and immediately understood that the interceptor was designed to prevent premature submissions without evidence. Instead of breaking the code, Gemini retained the existing logic and upgraded it to a higher standard. It added new checks to ensure tasks were compared against theoretical optimal solutions before submission.
Benchmark results and growth
The data from the paper shows that the Full SIM mechanism consistently outperformed all other methods across four core fields: code writing, text classification, workspace tasks, and engineering design. In workspace tasks, the performance gap between the SIM-enabled model and the code-only transfer was a significant 11.33 points.
In the coding field, specifically for challenging command line tasks in Terminal-Bench, the SIM-enabled side won 9 out of 10 independent continuous optimization runs. The results also showed strong cross-dataset generalization, where the SIM mechanism helped the model perform better on entirely unseen datasets compared to models without complete memory.
These findings suggest that AI evolution can achieve "compound growth." Because every iteration is additive, the first generation can optimize 10% of the code, and the second generation can read that memory to optimize an additional 20%. This creates a path where AI can stack experience buffs across generations rather than starting from zero every time a new model is released.
The path toward RSI
This research marks a transition from "pseudo-RSI" to a functional implementation of Recursive Self-Improvement (RSI). Previously, AI would often go out of control or suffer from performance degradation after several self-improvement iterations because there was no mechanism to retain knowledge.
By providing a way for AI to reflect on itself, record its own progress, and teach that experience to future versions, Google has unblocked a critical path for sustained evolution. This allows the AI to pass down knowledge through text logs in a way that mimics how humans pass down experience through documentation.
The study suggests that the era of relying solely on brute-force computing power to create miracles is ending. Instead, the focus is shifting toward models that can learn to inherit memories. This transition could lead to an irreversible species evolution where AI becomes capable of continuous, cumulative self-improvement without losing its previous gains.
What to watch
- How other companies will adopt similar memory frameworks for their own agent architectures.
- Whether SIM can be scaled to handle millions of small, granular code changes without becoming too large for the model to read efficiently.
Sources and links
- Reporting36Kr: the article we sourced
First reported by 36Kr. Written by the SI Agent News Desk from the reporting above.Written with AI from the source above. Every number is checked against the source. Spot a mistake? Corrections.
Liked it? Say why
Add a line for other readers.
No account needed. We never show your email. Comments with links, ads or abuse are held and not shown. Your comment shows after a quick check.