9 Paths Toward True Recursive Self-Improvement

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.

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.

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.

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

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.

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

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.

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

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.

Best for: Turning sparse final rewards into useful step-by-step learning signals.

Status: Self-evolving policy; RSI component.

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.

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.

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.

Best for: Consolidating experience into reusable procedures by turning task-specific skills into procedural families.

Status: Self-improving skill memory; RSI component.

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:

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.

Best for: Making self-modification more targeted by comparing failures across tasks and successful behaviors before rewriting the scaffold.

Status: RSI / self-modifying agent

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Thank you for reading! [Sign-off — e.g. “Share this list with a friend who is still deploying models by hand.”]