Recursive Self-Improvement in AI: Survey Distinguishes Evolution Stages and Proposes Unified Framework

Introduction

Traditional AI improvement processes are human-designed and executed, covering training data construction, preference optimization, model architecture design, training strategy selection, and final evaluation. The model is primarily the object of optimization, not an active participant. With the development of LLM agents, this boundary is blurring: modern agents can modify code, call tools, analyze failures, optimize prompts and workflows, and even participate in training data generation, model training, and automated experimentation. AI begins to not only complete tasks but also participate in "how to make the system itself better."

Background: From Intelligence Explosion to Agentic Improvement

The idea of RSI traces back to Butler, Turing, and Good's discussions on machine self-improvement and intelligence explosion: if a system can design a stronger successor, the new system may further enhance this design capability, creating a positive feedback loop. Subsequently, AutoML, NAS, Self-Play, Meta-Learning, and Curriculum Learning gradually turned this idea into executable machine learning optimization processes.

The real change arrives in the Agentic Era. Modern agents can not only generate answers but also execute code, call tools, observe results, modify behavior based on feedback, and further adjust Memory, Workflow, Harness, and even the research process. Consequently, RSI research shifts from "can machines make themselves smarter" to "can a system continuously produce, verify, retain, and inherit trustworthy improvements."

Definition: What Constitutes True RSI?

The paper first distinguishes four easily confused stages:

Evolution : Only improves current output or trajectory; changes are not persistently retained.

Self-Evolution : Retains accepted improvements and reuses them in subsequent tasks, runs, or new interactions.

Meta-Evolution : Further modifies the mechanisms responsible for generating, evaluating, or selecting improvements, such as the proposer, verifier, search rules, or updater.

Recursive Self-Improvement (RSI) : Requires that an accepted improvement in one cycle genuinely becomes the starting state for the next improvement cycle, enabling subsequent optimization to build upon the already improved state.

The paper emphasizes: Iteration alone is not RSI. Repeated reflection, revision, search, or optimization does not mean the system possesses RSI. The key to true recursion is state inheritance : subsequent cycles must explicitly inherit the previously verified and retained improved state, continuing optimization from that state rather than restarting from the same base state each round.

Further, the paper distinguishes minimal RSI (improvements inherited across cycles) from stronger recursive progress (inheritance further enhances the subsequent improvement procedure, e.g., making the system more effective at generating, screening, or verifying the next round of improvements). The system must not only "get better" but gradually "get better at getting better."

Framework: Proposal → Feedback → Optimization

To unify different types of RSI systems, the paper proposes a three-stage closed loop:

Proposal : Decides "what to improve" and "how to generate candidate improvements."

Feedback : Executes candidate modifications in an environment and converts execution results into evidence via tests, benchmarks, judges, simulators, or human review.

Optimization : Decides whether to retain, modify, reject, generalize, or roll back the candidate based on evidence.

An important distinction: execution results do not equal improvement evidence; verification passing does not equal direct system update. The Environment exposes consequences of candidate modifications; the Verifier judges whether consequences meet objectives; the Update Policy ultimately decides whether a change earns permission to enter persistent state.

When a verified improvement is truly written into Memory, Skill, Workflow, Code, or Model, and is reloaded in the next Proposal–Feedback–Optimization cycle, an ordinary iterative improvement loop begins to possess recursive significance.

System Structure: Six Key Components

Under this framework, the paper decomposes modern RSI systems into six key components:

Target Selection and Candidate Generation constitute Proposal, deciding "what to improve" and "how to generate candidate improvements."

Execution Environment and Verification Signal constitute Feedback, responsible for running candidate modifications and converting execution results into comparable evidence.

Update Policy and Memory Update belong to Optimization, deciding which changes are retained, revised, rejected, generalized, or rolled back, and carrying the verified state into the next cycle.

This decomposition separates "the object being modified" from "the mechanisms responsible for generating, verifying, and retaining modifications." A system may choose to modify Prompt, Memory, Workflow, Harness, Model, or even the entire Research Process; candidate improvements can be produced via textual revision, search, evolution, program synthesis, or autonomous experimentation. The critical factor is not the specific algorithm but whether each modification has clear boundaries, can be executed in the environment, its effects can be reliably verified and attributed, and it can enter the next round's persistent state in a traceable, rollback-capable form.

Taxonomy: What Exactly Is RSI Improving?

From the perspective of Evolution Target, the paper categorizes current RSI-related research into four classes, corresponding to increasing persistence and causal reach:

Behavior Evolution

Operates at the most local, immediate behavioral level, modifying model outputs, reasoning processes, search trajectories, and intermediate states maintained in natural language. Typical methods include self-refinement, reflection, search-time reasoning, and state optimization: the system corrects the current answer or trajectory based on feedback, then compresses valuable critiques, search traces, or experiences into reusable states. Advantages: low modification cost, fast feedback. However, many improvements remain confined to the current task or context; only when these trajectories, reflections, or rules are further retained and reused in subsequent tasks do they begin to possess lasting evolutionary significance.

Agent-System Evolution

Extends the modification object from "current behavior" to the agent's own operational structure, including Prompt, Memory, Tool-use Policy, Workflow, Harness, multi-agent collaboration mechanisms, and Runtime Components. Unlike one-off output corrections, these changes can continuously affect multiple subsequent tasks and execution cycles, e.g., updating long-term memory, distilling reusable skills, adjusting tool-calling logic, restructuring workflows, or modifying mechanisms coordinating multiple agents. The paper particularly emphasizes that Harness is not merely a Prompt wrapper but a critical control plane governing tools, state representation, execution order, feedback channels, and release conditions; thus evolution at this layer begins to influence "how the agent works," not just "what it outputs this time."

Model & Data Evolution

Pushes self-improvement into the training process itself; modified objects include training data, Reward, model parameters, and Curriculum. Typical directions: synthetic data bootstrapping, self-rewarding and meta-rewarding, agentic post-training, self-play, and curriculum evolution. Unlike external Prompt or Workflow adjustments, changes at this layer directly alter the model's subsequent learning and generation behavior, yielding stronger persistence and transfer potential. However, credit assignment, regression detection, and verification difficulty increase significantly because final performance changes may be simultaneously influenced by data, Reward, training process, and parameter updates.

Research-Process Evolution

Expands the scope of evolution to the complete AI R&D or scientific research process, no longer optimizing only a single model or agent component but incorporating hypothesis, experiment, evidence, research state, and subsequent research decisions into the set of modifiable objects. Typical systems: AI Scientist, Executable AI4AI / MLE, Experience Factories, End-to-End AutoResearch Loops, and domain-specific scientific agents. These systems can autonomously propose hypotheses, design and execute experiments, analyze results, and decide next research directions based on evidence, thus approaching the full closed loop of "AI improving AI." However, they impose the strongest verification requirements because a seemingly successful experiment does not necessarily imply genuine scientific progress; reproducibility, evidence quality, cross-task transfer, and whether subsequent research decisions truly improve must be scrutinized.

This trajectory reflects a key RSI trend: improvement objects are gradually expanding from local, transient outputs to persistent, inheritable system states that can influence subsequent improvement processes. Consequently, potential gains increase, but verification, credit assignment, rollback, and safety control become more difficult.

Future Directions: Where Does RSI Go Next?

The paper summarizes seven key challenges for future RSI: Reliability, Efficiency, Diversity, Persistence, Adaptability, Controllability, and Generalization. These are not seven independent capabilities but together form an evidence-oriented RSI evaluation profile.

Reliability

Focuses on whether a change is truly worth accepting. RSI's special risk: a single misjudgment may not only affect the current result but be written into Memory, Skill, Training Data, or Harness, propagating through subsequent cycles. Future systems need more independent, verifiable evaluation mechanisms, including execution-based verification, held-out evaluation, rule/formal checks, and necessary human review, to avoid reward hacking, verifier exploitation, or evaluator bias being mistaken for genuine progress.

Efficiency

Concerns whether RSI can sustain operation under limited resources. Real-world improvement loops cannot infinitely generate and verify candidates; trade-offs among compute, wall-clock time, human review, and deployment cost are necessary. The more important future question is not merely pursuing higher capability but measuring how much effective improvement each unit of resource yields, e.g., through budgeted search, selective evaluation, early stopping, and staged release to improve overall efficiency.

Diversity

Focuses on whether the system can maintain sufficiently diverse improvement paths. If different candidates originate from the same proposer, memory, or verifier, they likely share the same blind spots, leading to mode collapse, correlated errors, or evaluator overfitting. Future RSI needs richer hypotheses, populations, archives, and independent branches, enabling the system not just to "search more" but to genuinely explore different improvement directions.

Persistence

Focuses on whether an improvement can truly persist across cycles and continue to function. For RSI, short-term score gains are insufficient; the system must ensure accepted changes are recorded, loaded, tracked, and reused. This demands more robust Memory, Skill, Versioning, Lineage, Replay, and Rollback mechanisms, transforming improvement from a one-off local success into a persistent state that subsequent cycles can continue to leverage.

Adaptability

Focuses on whether the system can continue improving after environmental changes. Real-world tasks, tools, data distributions, and verifiers may constantly change; improvements effective on static benchmarks may not hold long-term. Future RSI needs stronger dynamic evaluation, verifier–environment co-evolution, and replayable, versioned contexts, enabling the system to continuously adjust under task shift, tool shift, and environment change rather than only adapting to a fixed distribution.

Controllability

Focuses on whether self-improvement remains within manageable, auditable bounds. When systems begin modifying Model, Code, Harness, or Research Process, the critical questions include not only "can it change" but "who has approval authority," "what is the scope of impact," and "can issues be rolled back." Future RSI requires clearer authority, scope control, approval, audit, and rollback mechanisms, preserving governance over the improvement process while granting improvement capability.

Generalization

The ultimate test of whether an improvement truly holds value, rather than only being effective on the current benchmark, judge, or harness. A system may achieve higher scores on a fixed evaluator without genuinely improving underlying capabilities. Future evaluation must emphasize held-out tasks, new environments, cross-domain transfer, product deployment, and scientific deployment, even examining whether the improvement procedure itself can transfer to new tasks and subsequent generations.

Implications: From "Can Modify Itself" to "Can Reliably Improve Itself"

From this survey's perspective, the true difficulty of RSI is not getting AI to continuously propose modifications. Today's agents can already generate code, modify prompts, adjust workflows, call tools, conduct search, and even execute relatively complete experimental workflows. The real difficulty lies in: how do we judge whether a change constitutes a genuine improvement, and how do we ensure this improvement is worth retaining, can be reliably reused in subsequent cycles, and will not be amplified recursively due to erroneous verification, misattribution, or local overfitting?

Therefore, trustworthy RSI requires not just a stronger proposer but a complete improvement infrastructure: reliable verification, explicit state inheritance, traceable lineage, reproducible evaluation, and control mechanisms capable of rollback when necessary. In other words, the system must not only "propose changes" but also know why it accepts a change, what that change affects, and whether it remains effective in subsequent tasks, environments, and improvement cycles. The paper ultimately identifies verification and reliable cross-cycle transfer as the core challenges for RSI to move from simple recursive state inheritance to genuine recursive progress.

In this sense, the ultimate question of Recursive Self-Improvement may not be "can AI change itself" but: can AI continuously judge what is worth changing, stably inherit truly effective changes, and make those changes the reliable starting point for the next improvement? Only when improvements can be verified, retained, transferred, and further support better subsequent improvements does RSI truly evolve from "repeatedly modifying itself" to "continuously improving its ability to improve."

Code example

来源：专知
本文
约4500字
，建议阅读
7
分钟
RSI 真正困难的地方并不是让 AI 不断提出修改。