9 Paths Toward True Recursive Self-Improvement
We can all see how gradually the Recursive Self-Improvement (RSI) field is getting more crowded. But at the same time, there is no AI system that would be fully RSI and would build the next generation of more capable AI on its own. It is too early for that. Before we can achieve AI that improves AI, we need to overcome a lot of limitations and imperfections. In our recent article we’ve wrote about this problem.
The 2026 RSI survey literature makes the point that current systems improve different aspects – deployment behavior, policy, evaluator, scaffold/code, or the research/improvement process – and full open-ended RSI remains unsolved. That gives us almost a map of different parts of the RSI loop.
TL;DR: Nine systems explore different paths toward RSI. Metaⁿ and MetaSkill-Evolve target strategy, Recuris and SkillGLoW improve memory and skills, Q-Evolve and RISE evolve policies, while MGM, RQGM, and DGM explore self-modifying agents and evaluators. None achieves full RSI yet.
What Exactly Is Improving?
Not all self-improvement means the same thing. An AI system can improve its answers without improving the process that produced them. It can also change its policy while leaving its memory fixed, evolve its code keeping the underlying model frozen, or improve the evaluator that decides what “better” even means.
That is why these nine approaches are interesting together. They target different parts of the RSI loop:
Strategy → Memory → Skills → Policy → Model weights → Scaffold/code → Evaluation
None covers the entire loop. But together, they give us a clearer picture of what still needs to become self-improving before we can talk about true RSI.
Method | What improves | How it improves | Best for | Status |
|---|---|---|---|---|
Metaⁿ | Improvement strategy | Adds recursive layers that review lower layers and provide better guidance and tools | Rethinking the broader RSI strategy | Bounded RSI component |
Recuris | Memory and retrieval | Evolves skills, working memory, retrieval policy, and verification based on failures | Using past experience at the right moment | Self-evolving memory; RSI component |
MetaSkill-Evolve | Skills + improvement strategy | Co-evolves task skills and the meta-skills responsible for improving them | Improving the improvement process itself | Explicit bounded RSI |
Q-Evolve | Policy | Generates fresh trajectories with the current policy and learns which actions contributed to final outcomes | Turning sparse rewards into step-level learning | Self-evolving policy; RSI component |
RISE | Model policy/weights | Extrapolates the model’s training trajectory into a stronger “future” policy and distills it back | Learning from an estimated future version of itself | Weight/policy-level self-improvement; RSI component |
SkillGLoW | Procedural skills | Consolidates task-specific experience into reusable global skills | Building reusable procedural knowledge | Self-improving skill memory; RSI component |
Mendel Gödel Machine | Agent scaffold | Compares failures and successful behaviors across tasks and agent versions before self-editing | More targeted self-modification | RSI / self-modifying agent |
Red Queen Gödel Machine | Agent + evaluator | Co-evolves agents and the criteria used to evaluate their improvement | Improving the standard that guides self-improvement | Explicit RSI / co-evolving agent–evaluator system |
Darwin Gödel Machine | Agent code and scaffold | Creates, evaluates, and preserves multiple branches of self-modified agents | Open-ended exploration of agent designs | Explicit RSI / self-modifying agent |
1. Metaⁿ
It is a framework for recursive self-improvement that targets the improvement process itself. It adds new layers around a base solver: each layer reviews the results, strategies, and failures of the layers below, then adds better guidance or reusable tools. The stack keeps growing while performance improves, giving higher layers a chance to rethink the broader strategy. The base model stays unchanged.
Paper: Metaⁿ research paper
GitHub: Metaⁿ GitHub
Also, read about Metaⁿ in our recent article about the missing pieces of RSI.
Best for: Rethinking the improvement strategy by recursively adding higher-level layers that review and improve how lower layers solve tasks.
Status: Bounded RSI component
2. Recuris
One more notable framework for RSI that focuses concretely on memory and improves how an agent uses its past experience. It keeps the base model frozen and evolves an external memory system: one part stores reusable skills, another tracks what is done or still pending, a policy decides which skill to retrieve and when, and checkers verify progress. After failures, a Meta-Agent finds which memory component failed and updates that specific part for future tasks.
Paper: Recuris research paper
Also, read about Recuris in our recent article about missing pieces of RSI.
Best for: Learning how to use past experience better by evolving skills, task-state memory, retrieval timing.
Status: Self-evolving memory; RSI component
3. MetaSkill-Evolve
This option improves both an agent’s skills and the process used to improve them. It runs two loops. A fast loop learns from failures and rewrites the task skill. A slower loop improves five meta-skills controlling how the system diagnoses failures, retrieves useful experience, allocates search effort, proposes fixes, and applies them. The key detail is that the same pipeline that improves task skills is recursively used to improve this improvement strategy itself.
Paper: MetaSkill-Evolve research paper
Best for: Improving the improvement process itself by co-evolving task skills and the meta-skills that diagnose failures and decide how those skills should change.
Status: Explicit bounded RSI
4. Q-Evolve
Q-Evolve uses in-distribution optimization to let an agent improve without training directly on behavior produced by a different policy. It works as a loop: the current agent generates trajectories, Q-Evolve learns which individual actions helped or hurt the final result, and the policy is updated on those trajectories from its current behavior distribution. The improved policy then generates a fresh set of trajectories for the next round.
In other words, the training data evolves together with the agent. This keeps each optimization round close to what the agent can currently do, rather than pushing it toward actions from an increasingly outdated data distribution.
Paper: Q-Evolve research paper
Website: Q-Evolve project page
Best for: Turning sparse final rewards into useful step-by-step learning signals.
Status: Self-evolving policy; RSI component.
5. RISE
In this Saleforce’s RSI method, the model uses its own training trajectory to create a stronger teacher for itself.
It first improves through RL with verifiable rewards. Then it “looks” at the direction the model is already moving during training and extrapolates that trajectory forward, estimating what a slightly more improved version of the model would predict. This “future” policy becomes a teacher, and its token-level predictions are distilled back into the current model.
As a result, the model learns from an estimated future version of itself without an external teacher or new knowledge. RISE does this during training; the same idea moved to inference is test-time training, where the model keeps updating while you use it.
Paper: RISE research paper
Best for: Letting a model learn from an estimated future version of itself by extrapolating its own improvement trajectory.
Status: Weight/policy-level self-improvement; RSI component.
6. SkillGLoW
This method can become one more potential components of a fuller RSI system. It is made for self-improving agents, improving how an agent learns and organizes reusable skills from its experience, evolving agent’s external procedural knowledge.
For each task, the agent creates a local skill from what happened during execution. SkillGLoW then groups related local skills into procedural families and consolidates them: it generalizes across similar tasks and removes task-specific details. These become global skills that guide the agent on future tasks.
The new skills are kept only if they actually improve downstream execution, and the process repeats as the agent gets more experience.
Paper: SkillGLoW Research paper
Best for: Consolidating experience into reusable procedures by turning task-specific skills into procedural families.
Status: Self-improving skill memory; RSI component.
7. Mendel Gödel Machine (MGM)
An RSI method for coding agents that improves how the agent uses past failures to rewrite its own scaffold. MGM keeps an archive of agent versions and their results, then uses three kinds of self-modification:
a normal single-failure edit,
a reaction-norm mutation that compares the same agent across multiple tasks to find recurring weaknesses, and
cross-lineage hybridization that compares different agent versions on the same task to transfer useful behavior.
The key idea: better comparisons give better self-edits. The agent’s underlying LLM is not retrained, only the coding-agent scaffold and workflow evolve. Each improved child goes back into the archive, is tested on more tasks, and can become the parent for later self-modifications.
Paper: MGM Research paper
GitHub: MGM GitHub
Website: MGMProject page
Best for: Making self-modification more targeted by comparing failures across tasks and successful behaviors before rewriting the scaffold.
Status: RSI / self-modifying agent
8. Red Queen Gödel Machine
Most self-improving agent systems still optimize against a fixed benchmark or verifier, so something needs to do this RQGM makes the evaluation criterion itself evolvable: agents and learned evaluators improve together, while each evaluator stays frozen within an epoch to keep the search stable. At epoch boundaries, a challenger evaluator replaces the current one only if it performs better on a fixed ground-truth anchor.
Paper: RQGM Research paper
GitHub: RQGM GitHub
Website: RQGMProject page
Best for: Evolving the evaluator together with the agent, so the standard used to guide improvement can also improve over time.
Status: Explicit RSI / co-evolving agent–evaluator system.
9. Darwin Gödel Machine
The idea of DGM is to keep an archive of many self-modified versions of an agent and treats them as possible stepping stones. A selected agent edits its own codebase, the new version is tested on coding benchmarks, and successful variants are added back to the archive. This lets the system explore multiple evolutionary branches, including temporary performance dips that may later lead to stronger agents.
As in many other methods, the model stays frozen, and the archive-management and parent-selection process itself is still fixed. What evolves is the agent scaffold – its tools, prompts, workflows, and code.
Paper: DGM Research paper
GitHub: DGM GitHub
Website: DGMProject page
Best for: Open-ended evolution of the agent’s own code and scaffold by exploring and preserving multiple self-modified versions.
Status: Explicit RSI / self-modifying agent.
Sources and further reading
If you're just getting started with ML and AI, check out our curated list of Top 10 GitHub repos for AI & ML practitioners— collections of courses, guides, and projects to build your foundations.
From Turing Post
FAQ
What is recursive self-improvement in AI?
Recursive self-improvement (RSI) is the idea of an AI system improving the process used to create better AI systems, with those improvements feeding into future improvement cycles. True RSI would go beyond simply getting better at individual tasks and increasingly improve the mechanisms behind its own progress.
Does true recursive self-improvement exist today?
No. Current systems can improve specific components such as policies, memory, skills, evaluators, or agent code, but no existing system independently improves the entire process required to build increasingly capable generations of AI. Today’s approaches are better understood as components or bounded forms of RSI.
What are the main approaches to recursive self-improvement?
Current research explores several paths, including recursively improving strategy, evolving memory and skills, updating policies or model weights, modifying agent code and scaffolds, and even co-evolving the evaluator used to judge progress. The nine methods in this guide represent different parts of this larger RSI loop.
What is the difference between self-improving agents and true RSI?
A self-improving agent may get better at a task by updating its memory, skills, policy, or code. True RSI requires a deeper recursive loop in which the system can also improve the mechanisms and strategies responsible for producing those improvements, potentially across successive generations.
Which parts of an AI system can recursively improve?
Research is already experimenting with improvement at several levels: strategy, memory, procedural skills, policies, model weights, agent scaffolds and code, and evaluators. The major unsolved problem is connecting these pieces into a system where increasingly more of the improvement loop can itself evolve.
How did you like it?
Thank you for reading! [Sign-off — e.g. “Share this list with a friend who is still deploying models by hand.”]