Recursive Self-Improvement in AI: A Survey

1. Introduction

Improving an AI system usually requires a division of labor: a model solves problems, while researchers design its data, training procedure and operating environment. Foundation models increasingly participate in both roles. They produce training examples, diagnose failures, construct tools and run experiments. Recursive self-improvement (RSI) asks whether the benefits of these activities can return to the process that produces the next improvement. A stronger solver is one possible outcome; a more effective way of building stronger solvers is the further object of interest.

The practical work falls into two overlapping goals. Automated design constructs AI infrastructure: data pipelines, learning algorithms, model architectures, agent workflows and their evaluation machinery. Repair and optimization methods modify existing systems by correcting bugs, recovering from failed interactions, maintaining memory and skills, or updating parameters and configurations. These goals have different success criteria. A design should generalize beyond the experiments that select it; a repair should resolve its target failure while preserving other useful behavior. Both can support RSI when retained changes improve later update production. Neither is recursive simply because it runs repeatedly.

Figure 1. A mechanism-level view of recursive self-improvement. Experience informs candidate changes. Validation determines what is retained: the upper loop carries task-system state into later tasks; the dashed lower loop carries changes to the process that produces later improvements. External anchors specify the conditions outside the update scope. The diagram describes possible dependencies, rather than a guarantee of gains.

Figure 1. A mechanism-level view of recursive self-improvement. Experience informs candidate changes. Validation determines what is retained: the upper loop carries task-system state into later tasks; the dashed lower loop carries changes to the process that produces later improvements. External anchors specify the conditions outside the update scope. The diagram describes possible dependencies, rather than a guarantee of gains.

The literature connects these goals through several mechanisms. Generated examples and rewards support parameter updates; memories and skills retain experience; prompt, workflow and program search alter how agents act; and editable improvers make the update procedure itself a search object [1,2,3,4,5,6]. Recursive context provides another route: Metaⁿ keeps a meta-operation fixed while adding earlier programs and traces to the material it processes [7]. The resulting systems differ in what changes, what survives a reset, and what remains externally fixed. Figure 3 and Figure 4 give an early view of these mechanisms and their historical research routes.

Three questions organize this survey. What is being improved? The target may be an answer, a persistent solver, or the process that generates updates. What evidence supports the improvement? Independent task gains, retention across rounds and transfer of improvement ability require different tests. What keeps the loop productive? Repeated updates can reinforce errors, lose earlier capabilities or exploit a proxy reward; execution checks, new data and human judgment can supply information the loop does not generate reliably on its own. The amount, timing and cost of that outside feedback belong in the experimental description.

These questions connect RSI to an established history of AutoML, meta-learning, program search and adaptive agents. Automated search already uses feedback, and learned optimizers already make learning rules trainable. The relevant distinction is the role of inherited changes in later improvement, rather than a categorical divide between older optimization and modern agents. Recent surveys offer complementary accounts of evolving agents, model-development lifecycles and coupled improvement components [8,9,10,11]. We build on them through three contributions:

• A formulation that separates infrastructure design from repair and optimization, and connects both to persistent state and improver quality.
• A synthesis by method clusters, with historical comparisons, diagrams and configuration-level tables that expose shared mechanisms and exceptions.
• An evidence framework covering independent tests, full budgets, retention, improver ablations and external feedback, together with the limits of currently demonstrated results.

Figure 2 maps the article. Scope and foundations lead to a mechanism taxonomy; Section 5 and Section 6 then develop the two engineering goals. Evaluation and open questions cut across both.

Figure 2. Organization of the survey. The nine sections connect two engineering goals to common mechanisms and tests. Infrastructure design and repair can share the same update operators. Branches describe this article’s organization, rather than technical ancestry or a ranking of approaches.

Figure 2. Organization of the survey. The nine sections connect two engineering goals to common mechanisms and tests. Infrastructure design and repair can share the same update operators. Branches describe this article’s organization, rather than technical ancestry or a ranking of approaches.

Figure 3. Landscape of mechanisms relevant to recursive self-improvement. The map connects update targets in the inner band, improvement mechanisms in the middle band, and representative studies in the outer band. The six sectors cover weights, tasks, memory, programs, feedback, and the improvement process. A work may involve several targets; its placement highlights one connection. The map includes historical foundations, enabling methods, and RSI-oriented systems. Logos denote selected author or work-done affiliations, rather than base models; other collaborating institutions may be omitted. The accompanying source register records each selection.

Figure 3. Landscape of mechanisms relevant to recursive self-improvement. The map connects update targets in the inner band, improvement mechanisms in the middle band, and representative studies in the outer band. The six sectors cover weights, tasks, memory, programs, feedback, and the improvement process. A work may involve several targets; its placement highlights one connection. The map includes historical foundations, enabling methods, and RSI-oriented systems. Logos denote selected author or work-done affiliations, rather than base models; other collaborating institutions may be omitted. The accompanying source register records each selection.

Figure 4. Research routes toward recursive self-improvement. Forty-five representative method papers are grouped into six research routes, with three historical anchors shown separately. Year bands use the first public dates in the checked source records; spacing within each band is adjusted for legibility. Branch lines denote research families. Technical ancestry, cross-route transfer, and sustained recursive gains require separate evidence. The selection reflects the literature search through September 12, 2026. Logos identify one selected author or work-done affiliation per study; “Ind.” denotes independent researchers. Affiliation and logo sources are documented separately.

Figure 4. Research routes toward recursive self-improvement. Forty-five representative method papers are grouped into six research routes, with three historical anchors shown separately. Year bands use the first public dates in the checked source records; spacing within each band is adjusted for legibility. Branch lines denote research families. Technical ancestry, cross-route transfer, and sustained recursive gains require separate evidence. The selection reflects the literature search through September 12, 2026. Logos identify one selected author or work-done affiliation per study; “Ind.” denotes independent researchers. Affiliation and logo sources are documented separately.

2. Scope and Review Methodology

2.1. Research Scope and Inclusion Criteria

We review foundation models and agents that use generated data, interaction experience or evaluation feedback to change later behavior. We focus on methods that modify the process used to generate subsequent improvements. Self-training, memory, tool construction and automated design supply enabling mechanisms; local refinement and failure studies clarify boundaries. Historical work enters where it explains a mechanism or supplies a necessary comparison. Inclusion in the survey does not imply that a method demonstrates RSI.

Our unit of analysis is a concrete configuration, with a specified update target, feedback source, retained artifact and externally fixed conditions. A paper can describe several configurations, and one configuration can serve both design and repair. We distinguish an implemented recursive dependency from evidence that this dependency produces useful gains.

2.2. Literature Discovery and Evidence Organization

We identify relevant studies through an initial set of papers, citation tracing and targeted searches for related mechanisms. We check publication details against paper pages on arXiv, ACL Anthology, Preprints.org and conference proceedings. The main search covers work available by 12 September 2026. To expand the initial bibliography of 125 works, we screen the bibliographic records and abstracts of 442 distinct arXiv papers and include 275 additional works. A historical supplement dated 20 September adds four references on AutoML and architecture search. The bibliography therefore contains 404 distinct works, including those cited in figures. The supplement does not extend the cutoff for recent work.

For each entry, we retain the source link and version information. When a preprint and a published paper are confirmed to describe the same work, we count them once. We distinguish screening bibliographic records and abstracts from examining methods and experiments in the full text. Not all included papers receive the same depth of full-text review. We use the broader collection to identify related approaches and restrict detailed numerical comparisons to experiments we inspect. This is a narrative survey, not an exhaustive systematic review or a meta-analysis. We mark protocol details as unconfirmed when the inspected material does not specify them. The selected samples do not support estimates of how common a practice is across the field.

The synthesis links three levels: mechanisms (what changes and persists), protocols (splits, resources, controls and horizons), and claims (task gains, retention, transfer or stronger improvers). This separation prevents a descriptive method label from substituting for an experimental result.

2.3. Relationship to Existing Surveys

The neighboring survey literature can be viewed through three intersecting perspectives, summarized in Figure 5. Lifecycle and agent surveys organize the objects, stages, and application settings of self-improvement [8,9]. Component surveys examine how particular mechanisms operate and what state they preserve [12,13,14]. RSI-oriented syntheses focus more directly on how the improvement loop is closed and what evidence supports recursive improvement [10,11]. These perspectives are thematic rather than mutually exclusive, so a survey may contribute to more than one branch.

Table 1 compares existing surveys along three groups of dimensions derived from our research questions. System boundary asks which components can be updated and what information is retained or reset between improvement rounds. Recursive agency asks whether the improver that generates updates and the judge or criterion that evaluates them remain fixed or can change across rounds. Evaluation evidence asks what evidence supports a claimed improvement, including evaluation data kept outside the update process, controls for attributing gains to the update, full accounting of the resources used, longitudinal tests of retention and transfer, and matched comparisons between improvers.

We assign full coverage when a dimension forms a central or systematic part of a survey’s framework, partial coverage when it is discussed explicitly but only to a limited extent, and no systematic coverage when it falls outside the survey’s main scope. The assessment reflects the role of each dimension in the survey’s overall framework rather than isolated mentions. It characterizes differences in scope, not the overall quality of the surveyed work.

Early general surveys primarily organize self-improvement around the model and its immediate update process. The initial self-evolution perspective follows the acquisition, refinement, updating, and evaluation of experience [15]. Agent-level surveys broaden the unit of analysis to models, memory, tools, architectures, environments, and optimizers [8,16]. Lifecycle and system-oriented views further connect data, training, inference, and evaluation with the operational scaffold surrounding the foundation model [9,17].

Recent RSI-oriented syntheses shift attention from individual updates to the structure of the improvement loop, including persistent system changes and the evolution of the improver itself [10,11,18]. They further examine the autonomy and reliability conditions required to sustain and verify improvement across successive rounds [19,20,21].

A second group studies self-evolution within broader agent architectures or particular application settings. Surveys of persistent autonomous agents, foundation agents, and lifelong learning emphasize workspaces, reusable skills, agent components, and the retention and transfer of experience across tasks [22,23,24]. More specialized surveys examine how the available update targets, feedback channels, and evaluation procedures are shaped by multimodal interaction or software-engineering environments [25,26].

A third group of surveys focuses on boundary conditions or offers detailed analyses of individual components. Full-stack safety and inference-time self-improvement respectively clarify the risks associated with mutable systems and the distinction between temporary inference gains and persistent updates [27,28]. Memory surveys examine how experience is represented, retrieved, consolidated, and revised over time [12,29], while surveys of automatic prompt optimization and agentic judging provide more focused accounts of prompt-level updates and evaluator agents [13,14]. These specialized surveys offer depth on individual mechanisms and boundaries, whereas the present survey examines how these mechanisms interact within a recursive improvement process.

Across these perspectives, our unit of analysis is an inherited change and its effect on subsequent improvement. We ask what is updated, what persists into later rounds, whether the improver or evaluation process changes, and what evidence attributes later gains to those changes. This framing distinguishes persistent and recursive improvement from better execution produced by an unchanged procedure. Table 2 provides a finer-grained comparison of ten representative surveys and roadmaps, examining their scopes, organizing perspectives, and evaluation emphases. Together, Figure 5, Table 1, and Table 2 position this survey at the intersection of persistent system change, evolving improvement processes, and cross-road evidence of improvement.

3. Foundations and Problem Formulation

3.1. Definitions and Historical Continuity

The term self-improvement covers several claims. In its broad usage, a system uses its outputs or experience to improve later performance. A structural RSI claim adds a return path through which an improvement procedure acts on itself or on inherited artifacts that govern subsequent improvement. An empirical RSI claim additionally requires evidence that this return path makes later improvement more effective. We use these distinctions rather than assign every included method one binary RSI label. Shared weights or code can implement several roles, and a fixed operator can process an evolving recursive context.

The Gödel Machine supplies a formal reference: self-rewrites depend on proofs of utility under specified axioms, with the proof searcher itself eligible for rewriting [30]. This conditional guarantee is not a guarantee for an empirical LLM agent that accepts edits by testing. Bounded RSI and seed-AI analyses also expose assumptions about resources, representation and the ability to recognize useful changes [31,32]. Modern systems replace some formal requirements with executable feedback and statistical evaluation, making the resulting evidence conditional on the tasks and tests available.

From AutoML to editable improvement processes.

Bayesian optimization adapts its proposals to earlier evaluations; Auto-WEKA applies automated search to joint algorithm and hyperparameter selection, while auto-sklearn adds meta-learning and ensemble construction [33,34,35]. Neural architecture search learns a controller that proposes architectures from validation rewards [36]. These are already adaptive, feedback-driven procedures. A fixed outer algorithm does not imply that its search state is static, and a learned controller is already an improvement component. The additional RSI question is whether inherited changes improve that component’s ability to produce successors, and whether this advantage survives new tasks and a full accounting of cost.

Meta-learning makes the overlap explicit. Learned optimizers change update rules; RL² learns adaptation through recurrent dynamics; MAML learns an initialization [37,38,39]. AutoML-Zero searches programs representing learning algorithms, while POET couples solver evolution, environment generation and transfer [40,41,42]. Evolution through Large Models connects program mutation, archives and model training [43]. These traditions supply the representations, search operators and transfer tests that modern RSI inherits. Language models broaden the editable objects to natural-language instructions and general programs; that broader interface does not remove the need to validate the resulting updates.

Table 3. Historical connections. A fixed outer algorithm can still maintain adaptive search state. The final column specifies an additional question, not a property absent from every method in a family.

Tradition	Search / learning target	Retained object	Additional RSI question
AutoML / NAS[34,35,36]	Pipelines; architectures; configurations	Models; search history; learned controller	Better future design at matched cost?
Meta-learning[37,38,39]	Update rule; dynamics; initialization	Meta-learned state	Can its production or revision improve?
Program / open-ended search[40,41]	Algorithms; environments; solvers	Programs; populations; archives	Does discovery improve later discovery?
Tool-using agents[44,45]	Actions; tool use	Traces or learned policies	What survives, and affects later updates?
Self-modification[30,46]	Solver and/or improver code	Revised executable state	Do tested or proved gains survive reuse?

Table 3. Historical connections. A fixed outer algorithm can still maintain adaptive search state. The final column specifies an additional question, not a property absent from every method in a family.

Tradition	Search / learning target	Retained object	Additional RSI question
AutoML / NAS[34,35,36]	Pipelines; architectures; configurations	Models; search history; learned controller	Better future design at matched cost?
Meta-learning[37,38,39]	Update rule; dynamics; initialization	Meta-learned state	Can its production or revision improve?
Program / open-ended search[40,41]	Algorithms; environments; solvers	Programs; populations; archives	Does discovery improve later discovery?
Tool-using agents[44,45]	Actions; tool use	Traces or learned policies	What survives, and affects later updates?
Self-modification[30,46]	Solver and/or improver code	Revised executable state	Do tested or proved gains survive reuse?

3.2. Two Engineering Goals and Their Objectives

We organize applications by their immediate engineering goal. The equations below are analytical templates for comparison, not objectives claimed to be implemented by every paper. Let S denote a task system and let

$$Q(S;D)={\mathbb{E}}_{z\sim D}\left[u(S,z)\right]$$

(1)

measure utility on a task distribution D, with higher values preferred. The utility u can encode correctness or a declared combination of quality and deployment cost. Training, development, validation and sealed test distributions serve different roles; $D_{\mathrm{test}}$ never selects an update.

Goal A: automated design of AI infrastructure.

Infrastructure includes learning pipelines and agent architectures, as well as the tools and evaluators that support them. Let a specify a design, $\lambda$ its configuration, and $\theta$ trainable parameters when present. A common formulation is

$$\begin{array}{cc}\hfill (a^{*},{\lambda }^{*})& \in arg\underset{a,\lambda }{max}Q(S(a,\lambda ,{\theta }^{*}(a,\lambda ));D_{\mathrm{val}}),\hfill \\ \hfill {\theta }^{*}(a,\lambda )& \in arg\underset{\theta }{min}{L}_{\mathrm{train}}(\theta ;a,\lambda ,D_{\mathrm{train}}),C_{\mathrm{search}}\le B.\hfill \end{array}$$

(2)

Here $L_{\mathrm{train}}$ is the specified training loss, $C_{\mathrm{search}}$ counts all candidate construction and evaluation, and B is the search budget. For training-free agent design, the inner training problem is absent and a can specify a workflow, tool library or prompt program. A new design is an output of the search. A recursive return path exists only when the retained result also affects how later designs are generated or selected.

3.2.0.3. Goal B: repair and optimization of an existing system.

Let $S_t\oplus \delta$ apply an allowed edit $\delta$ to the incumbent. Repair emphasizes a target failure distribution $D_{\mathrm{target}}$ and protected capabilities $D_j$. One useful constrained formulation is

$$\begin{array}{cc}\hfill {\delta }_t^{*}\in arg\underset{\delta \in {\mathcal{A}}_t}{max}& Q(S_t\oplus \delta ;D_{\mathrm{target}})-{\lambda }_{e}d\left(\delta \right),\hfill \\ \hfill \mathrm{subject}\mathrm{to}& Q(S_t\oplus \delta ;D_j)\ge Q(S_t;D_j)-{ϵ}_j\forall j,\hfill \\ \hfill & C_{\mathrm{update}}\left(\delta \right)\le B_t.\hfill \end{array}$$

(3)

The allowed edit set ${\mathcal{A}}_t$ can contain patches, memory operations, prompt changes or parameter updates. The optional penalty d discourages unnecessary change, ${\lambda }_e\ge 0$ weights it, and ${ϵ}_j\ge 0$ sets an allowed regression tolerance. All selection data here are development or validation data. An independent audit tests whether the selected edit also works outside them. The mathematical optimum is a specification; an actual search can fail to find a feasible or useful edit.

Design and repair overlap. Replacing a workflow after a failure is both a repair of its current behavior and a design decision. The distinction lies in the experimental goal and constraints, not the format of the code or whether model weights change. We retain both labels when needed.

3.3. A Unified Description of the Improvement Loop

Following Figure 1, let $X_t=(S_t,I_t)$ denote the retained state at the start of round t. Here, $S_t$ represents the state that supports task solving, including model parameters, prompts, memory, skills and executable programs. $I_t$ represents the process that produces or selects subsequent updates, including its programs, parameters, strategies and persistent context. This is a distinction between functional roles: one model or program can support both task solving and improvement. The roles can therefore share an implementation and need not have independently separable parameters.

Let $E_t$ denote the experience and feedback available for improvement in the current round, $V_t$ the information used to validate candidates and select updates, and $\mathcal{C}$ the conditions declared to remain externally fixed. These conditions can include task objectives, data-access rules, resource constraints, and models, tools and evaluation interfaces outside the update scope. An update takes the following general form:

$$\begin{array}{cc}\hfill {\tilde{X}}_{t+1}& \sim P_{I_t}(·\mid X_t,E_t;\mathcal{C}),\hfill \\ \hfill X_{t+1}& ={\mathcal{R}}_t(X_t,{\tilde{X}}_{t+1},V_t;\mathcal{C}).\hfill \end{array}$$

(4)

Here, $P_{I_t}$ describes candidate generation under the current improvement process, ${\tilde{X}}_{t+1}$ is a candidate state, and ${\mathcal{R}}_t$ denotes the actual validation and retention mechanism. Updatable parts of the retention mechanism fall within the analysis of $I_t$, while its externally fixed constraints belong to $\mathcal{C}$. Validation can accept a candidate, retain the existing task system and improver, or place a candidate in an archive for later selection; failed attempts and their costs also require recording. For evolution with multiple branches, $X_t$ can include the candidate archive and selection state, allowing this representation to accommodate non-greedy retention and multiple exploration paths.

This representation emphasizes what persists across rounds and how it serves subsequent activity. Figure 6 illustrates four typical patterns. Local refinement changes the current answer. Memory accumulation writes experience into external state available for later access. Parameter learning changes model weights through training. An improver update retains a change in the improvement process as $I_{t+1}$, which participates in generating changes in the next round. In the local-refinement pattern shown in the figure, answer revisions do not become persistent updates to the solver or improver. The other patterns can combine, as when a system updates its skill library, model parameters and improvement prompts together.

Retention requires an explicit task, session or training boundary. Context that grows within one run has a different persistence scope from memory that remains available after a task reset. Parameter updates likewise require specifying whether the next task restores the previous parameters [47,48]. Similarly, fixed external conditions delimit the update scope under study without implying independence from human design, pretraining knowledge or environmental feedback. Our subsequent method comparisons record both the components that change and the conditions that continue to support those changes.

3.4. Three Distinct Empirical Claims

The loop supports three questions with different observables. At a scheduled checkpoint t, task gain is

$${\Delta }_t=Q(S_t;D_{\mathrm{test}})-Q(S_0;D_{\mathrm{test}}).$$

(5)

For a task group j first acquired at round $t_j$, later retention and out-of-distribution transfer can be recorded as

$${\rho }_{t,j}=Q(S_t;D_j^{\mathrm{test}})-Q(S_{t_j};D_j^{\mathrm{test}}),{\tau }_t=Q(S_t;D_{\mathrm{new}}^{\mathrm{test}})-Q(S_0;D_{\mathrm{new}}^{\mathrm{test}}).$$

(6)

The reference checkpoint $t_j$ is predeclared; ${\rho }_{t,j}<0$ indicates a loss relative to it. The new distribution specifies the intended shift. Neither positive ${\Delta }_t$ nor positive ${\tau }_t$ isolates the improver.

For that question, let $S^{+}(I;S,B)$ be the successor selected by improver I from the same starting solver S within budget B. Define

$$g(I;S,B)=\mathbb{E}\left[Q(S^{+}(I;S,B);D_{\mathrm{test}})-Q(S;D_{\mathrm{test}})\right],$$

(7)

where the expectation covers update randomness and sampled tasks. A paired probe on held-out starting states drawn from ${\mathcal{P}}_{\mathrm{start}}$ tests

$${\Gamma }_t\left(B\right)={\mathbb{E}}_{S\sim {\mathcal{P}}_{\mathrm{start}}}[g(I_t;S,B)-g(I_0;S,B)].$$

(8)

Positive ${\Gamma }_t$ with appropriate uncertainty supports a stronger improver under that probe. Controls must match starting states, feedback access and resource accounting. The expense of obtaining $I_t$ is additional and belongs in an end-to-end comparison. If solver and improver share inseparable state, a swap can change both roles; component ablations then support a narrower claim, and the coupling must remain explicit.

STOP’s self-modifying program and Hyperagents’ editable meta-agent expose update-producing components; Metaⁿ instead retains recursive context for a fixed operation [6,7,46]. Their structure motivates a test, rather than supplies its outcome. Even increasing task scores over a finite horizon do not demonstrate accelerating improvement: that stronger claim requires gains per unit cost over longer horizons, without changing the criterion that defines success.

3.4.1. What Theoretical Results Establish

Recent theory addresses more specific mechanisms. A framework for self-play theorem proving models relations among theorems as a graph and derives expansion results under assumptions about connectivity, the prover and the conjecturer [49]. Work on iterative self-rewarding derives guarantees within an explicit statistical model, including dependence on initialization and sample size [50]. Such results explain possible sources of improvement under stated conditions. They do not imply that arbitrary language-model judges or generated curricula satisfy those conditions.

The information carried by a synthetic training distribution is another useful analytical object. The reverse-bottleneck account relates post-training generalization to information gain from the generative model [51]. The power-distribution analysis connects sampling, self-reward optimization and distillation, while distinguishing an increase in self-reward from an increase in the downstream reward of interest [52]. Together, these perspectives motivate measuring what new training material makes learnable, rather than using sample count or internal confidence as a sufficient account of progress.

Learning an update procedure also predates current agent scaffolds. Automated Continual Learning trains self-referential networks to acquire in-context learning algorithms that balance old and new tasks [53]. Its controlled setting offers a concrete example of optimizing how learning proceeds. Conversely, reward-overoptimization studies show that stronger optimization of a proxy can reduce performance against a separate reference criterion [54]. For RSI, these observations belong together: making an update process more effective requires specifying the objective against which its effectiveness is judged.

3.4.2. Local Revision and Learned Correction

Self-correction is an informative boundary case because repeated calls can change an answer without changing the system that answers the next question. Confidence Matters and the uncertainty-based account of intrinsic self-correction investigate when revisiting a response can help; a more recent task-sensitive analysis relates its usefulness to the structure of the task [55,56,57]. These findings caution against treating self-correction as a uniform capability across problems. They also motivate controls that preserve already-correct responses, rather than assuming every revision deserves acceptance.

Error recognition and correction activation are separable. Self-Correction Bench compares otherwise matched errors attributed to the model or to an external speaker, while DISC uses a judgment gate to limit harmful rewrites [58,59]. Symbolic feedback for planning and LLM-Augmenter’s externally grounded feedback show how additional evidence changes the correction problem [60,61]. The information introduced by a verifier, retrieval system or task constraint belongs in the account of the gain; it should not disappear under the label of introspection.

Correction can become a persistent skill when it is trained. STaSC uses self-generated data to learn correction; EVOLVE coordinates training and inference to develop refinement behavior; and Generative Self-Refinement jointly trains generation and aggregation using transferred refinement supervision [62,63,64]. LADDER instead recursively constructs simpler problem variants for learning and test-time adaptation [65]. Here, recursion over subproblems and recursion over an improvement procedure are different structures even when both support better later predictions.

The intervention level also matters in research. SAGE’s multi-hypothesis failure attribution distinguishes changes to a hypothesis, experimental design and implementation [66]. This illustrates why a fluent reflection is an incomplete description of an update. The operational question is which observed failure warrants which change, and whether that change survives verification at the level where the failure occurs.

Table 4. Conceptual boundaries of RSI. Patterns overlap. The final column poses evaluation questions, not claims established by every cited example.

Concept / examples	Updated state	RSI boundary	Key question
Local self-refinement[67,68]	Task-local responses, critiques and traces	Repeated correction need not change the solver	Retention after reset? Reliable correction?
Inference-time search[69,70,71]	Reasoning paths; search statistics; local reflections	Recursive search can use fixed models/rules	Equal-budget gains? Retention beyond the episode?
Self-training[1,72,73]	Synthetic examples; filtered rationales; weights	Generator can change; training/filtering may stay fixed	Transfer beyond generated data? External supervision?
Self-play / curriculum[74,75,76]	Policies; opponents; tasks; experience distribution	Adaptive curricula need not change learning rules	Which components change? Who fixes the objective?
Memory / skill retention[3,4,77,78]	Reflections; summaries; executable skills/tools	Persistent state; weights/update rule may stay fixed	When reused? Cross-task retention ablation?
Self-reward / meta-reward[2,79]	Preferences; judging behavior; actor/judge weights	Judge improvement differs from criterion/update-rule changes	Independent gains? Actor/judge role ablations?
Automated agent design[80,81,82]	Prompts; workflows; agent programs	Improved agents can have a fixed search driver	Artifact transfer? Is the driver updated/inherited?
Meta-learning / learned updates[37,38,39,83]	Initialization; learning dynamics; learned update rules	Adaptation can rely on fixed external meta-training	Which level learns? Is meta-training itself modified?
Improver self-modification[6,46,84]	Mutation prompts; improver code	Editable improvers do not establish sustained gains	Better successors at matched initial states and cost?
Recursive context / nested research[7,85]	Meta-context; evidence; unresolved constraints	Metan: fixed $\Omega$; AREX: answer/context refinement	What persists? Which process changes?

Table 4. Conceptual boundaries of RSI. Patterns overlap. The final column poses evaluation questions, not claims established by every cited example.

Concept / examples	Updated state	RSI boundary	Key question
Local self-refinement[67,68]	Task-local responses, critiques and traces	Repeated correction need not change the solver	Retention after reset? Reliable correction?
Inference-time search[69,70,71]	Reasoning paths; search statistics; local reflections	Recursive search can use fixed models/rules	Equal-budget gains? Retention beyond the episode?
Self-training[1,72,73]	Synthetic examples; filtered rationales; weights	Generator can change; training/filtering may stay fixed	Transfer beyond generated data? External supervision?
Self-play / curriculum[74,75,76]	Policies; opponents; tasks; experience distribution	Adaptive curricula need not change learning rules	Which components change? Who fixes the objective?
Memory / skill retention[3,4,77,78]	Reflections; summaries; executable skills/tools	Persistent state; weights/update rule may stay fixed	When reused? Cross-task retention ablation?
Self-reward / meta-reward[2,79]	Preferences; judging behavior; actor/judge weights	Judge improvement differs from criterion/update-rule changes	Independent gains? Actor/judge role ablations?
Automated agent design[80,81,82]	Prompts; workflows; agent programs	Improved agents can have a fixed search driver	Artifact transfer? Is the driver updated/inherited?
Meta-learning / learned updates[37,38,39,83]	Initialization; learning dynamics; learned update rules	Adaptation can rely on fixed external meta-training	Which level learns? Is meta-training itself modified?
Improver self-modification[6,46,84]	Mutation prompts; improver code	Editable improvers do not establish sustained gains	Better successors at matched initial states and cost?
Recursive context / nested research[7,85]	Meta-context; evidence; unresolved constraints	Metan: fixed $\Omega$; AREX: answer/context refinement	What persists? Which process changes?

4. A Taxonomy of Recursive Self-Improvement

4.1. Two Axes: Engineering Goal and Update Target

The engineering goal explains why a change is made; the update target explains what changes. Infrastructure design seeks a useful pipeline, architecture or improvement procedure. Repair and optimization start from an incumbent and a failure, performance gap or resource constraint. Either can change weights, data, memory or code. We therefore use the two goals to organize the methods discussion and retain the six overlapping target labels in Figure 3 for mechanism comparison.

Each configuration also receives three descriptors. Feedback identifies answers, execution, environmental outcomes, model judgments or human input, and whether each signal trains, proposes or selects an update. Persistence specifies the task, session or training boundary across which state survives. Control identifies editable proposal, training and selection components alongside fixed objectives, tools and budget rules. A label such as self-training or self-modification leaves these descriptors undetermined; they must come from the implementation.

4.2. Six Overlapping Mechanism Families

Parameters and data.

Parameter updates internalize generated or selected experience. Data and task updates alter the examples, curricula or task-generation policy that make learning possible. These mechanisms often coexist: STaR returns selected reasoning traces to training, while Absolute Zero learns task proposal and solving with executable feedback [1,75]. Their classification must keep the generator, acceptance criterion and trainer separate. Learning a task proposal policy does not imply learning the rule that trains that policy.

Memory and skills.

Persistent text, graphs, latent states and executable libraries retain experience without necessarily changing the backbone. Reflection, experience abstraction and skill reuse differ in what later computation accesses [3,4,77]. A stored record belongs to the solver when it guides task execution and to the improver when it guides diagnosis or update selection; the same record can serve both. Changing a memory’s contents and changing its management algorithm are separate interventions.

Prompts, programs and agent harnesses.

Textual instructions, tools and orchestration code govern how a model uses its capabilities. A searched prompt, generated workflow and revised agent program therefore share an operational target, despite different search operators [80,82,86,87]. The scope ranges from the current problem to a deployed agent family. A recursive call graph describes execution; it does not by itself show that an improved artifact survives to the next task.

Feedback and evaluation.

Judges, critics, tests and reward models affect what the loop accepts. Self-rewarding and meta-rewarding make this role explicit, but actor and judge can share the same parameters [2,79]. Feedback quality should be measured against an independent reference, and its effect on downstream updates tested separately. A changed evaluator can alter the scale on which apparent progress is reported.

The improvement process.

A prompt that generates mutations, a program that edits programs, a memory-management policy or a learned workflow designer can all act as an improver. Promptbreeder, STOP and Hyperagents expose different forms of editable update production [6,46,84]. Metaⁿ illustrates recursive conditioning under a fixed operation [7]. These functional labels overlap with the state carriers above: an improver may be stored in weights, code or context. The relevant evidence traces the changed object into the next update.

4.3. Reading Combinations Without Imposing a Capability Ladder

The four patterns in Figure 6 distinguish local answer revision, memory retention, parameter learning and improver updates. They can coexist in one system and do not establish an ordering of intelligence. A small memory update can be more useful than a large training run; an editable improver can repeatedly regress. The task, budget and retention boundary determine which comparison is meaningful.

The research routes in Figure 4 likewise denote families, not verified lines of technical descent. Their chronology helps locate shared ideas, while the two engineering goals organize what the systems attempt to accomplish. Section 5 and Section 6 synthesize these goals; Section 7 tests the claims that follow from them.

5. Automated Design of AI Infrastructure

Infrastructure design determines the machinery with which an AI system learns, acts and evaluates alternatives. Its outputs include data pipelines, learning algorithms, agent workflows, tools and research procedures. Equation 2 places these outputs under a shared design-and-evaluation view. We group the literature by the design decision it automates, then ask what the result contributes to the next design round.

5.1. Learning Pipelines and Task Curricula

A learning pipeline chooses what experience to collect, which examples to admit and how to turn them into updates. Generated instructions expand task coverage; rationales and executable solutions provide more structured training material [1,72,88]. The design problem is consequently broader than producing more samples. A pipeline must preserve informative variation while controlling error, redundancy and the cost of verification. Its output should be judged by the successor it trains, rather than the fluency of its synthetic data.

Curriculum methods adapt the difficulty, composition or source of tasks. Self-play couples this choice to the learner’s current behavior. Absolute Zero makes task proposal and solving learnable but retains an external executor and training rule [75]; POET couples evolving tasks, solvers and transfer [41,42]. These systems expose a common tension: tasks should be solvable enough to yield feedback and diverse enough to extend capability. Raising difficulty alone can eliminate the learning signal. A fixed independent test distribution is needed to separate better learning from a task generator’s changing preferences.

Curriculum mechanisms.

Three clusters refine this choice. Scheduling methods select or order preference pairs, reasoning difficulty and learning stages [89,90,91,92,93]. Co-evolution methods couple task proposal with a changing solver or critic [94,95,96,97,98,99]. Population and multi-agent approaches instead vary opponents, collaborators or model populations [100,101,102,103,104,105]. These mechanisms change the supply of experience in different ways; a harder task pool and a more diverse population are not interchangeable measures of learning opportunity.

A second axis concerns grounding. Verified problem construction, learned critics and solver–verifier interaction differ in who can certify an answer [106,107,108]. Executable software tasks and formal mathematics offer narrower checks than unrestricted language interaction [109,110]. Task construction from tools, self-challenges and interactive experience broadens coverage but also changes the sources of uncertainty [111,112,113]. Test-time curriculum and self-play methods additionally make the persistence boundary task-dependent [114,115]. Across these clusters, the common test is whether generated experience improves a learner on an independent task distribution after accounting for generation and checking.

Evaluator design is another part of the pipeline. Constitutional principles, model preferences and process supervision supply different forms of feedback [116,117,118,119]. Their external information differs: a human-written principle, a reference answer and a tool outcome cannot all be counted as an absence of supervision. Changing an internal judge is compatible with RSI, but independent task checks must remain outside the criterion it can rewrite. Section 6.4 examines the maintenance of these learned feedback components.

5.2. Agent Architectures, Workflows and Tool Interfaces

Agent design searches the arrangement of reasoning, tool use, memory and verification. ReAct and Toolformer establish complementary interfaces between language models and external actions [44,45]. Tool construction extends this interface from choosing existing actions to writing new executable capabilities [120,121]. Self-Discover, AgentSquare and ADAS make reasoning structures, modular compositions or agent programs explicit design objects [80,81,122]. The shared search space is an executable organization of capabilities, rather than only the parameters of one model.

Workflow methods cluster around three choices: how to represent a design, how to allocate roles and communication, and whether to train the designer. A natural-language program admits broad edits but can hide interface changes; a graph exposes dependencies but constrains the operators available. Learned designers can reuse experience across searches, while a fixed optimizer can still adapt its candidate distribution within a run. Useful comparisons therefore report both the artifact and the state of its designer.

Workflow design mechanisms.

Representation-oriented methods manipulate language programs, coding workflows or collaboration graphs, using execution feedback to assign responsibility for failure [123,124,125,126]. Designer-oriented methods train proposal or role policies, retain useful experience, or combine optimizers in a common platform [127,128,129,130]. The distinction is the learned output: one workflow, a distribution over workflows, or reusable optimization infrastructure.

Population search and communication-aware design preserve alternatives or adapt team topology [131,132,133,134]. Model heterogeneity, population size and communication density must remain separate budget variables. Instance-specific adaptation can instead revise roles, scaffolds or tools during a problem; such changes have different retention horizons from reusable domain tool collections [135,136,137,138]. Bounded condition–action rules with temporally ordered validation offer a more restricted, inspectable alternative in domain settings [139]. Expressive search spaces permit broader changes, while restricted ones make interfaces and regression tests easier to specify.

Runtime adaptation needs a separate persistence account. ToolSelf permits configuration changes during execution and also studies a separate training stage [140]. Orchestra-o1 combines multimodal subtask assignment with training of the orchestrator through DA-GRPO [141]. A topology selected for one query and a trained policy for selecting future topologies have different return paths. A clear experiment tests the former on task outcomes and the latter on new design problems, with communication, model calls and tool execution included in cost.

5.3. Algorithms, Search Operators and Reusable Design Knowledge

Algorithm design ranges from architecture search to executable learning and optimization procedures. AutoML-Zero searches learning algorithms, and AlphaEvolve uses model-guided program proposals, execution and an archive to search for useful programs [40,142]. A fixed search engine can produce a substantially better algorithm. That result becomes evidence about recursive improvement only when the discovery also changes later search or the model that conducts it.

Textual optimization offers a related space for studying proposal quality. APE, automatic prompt optimization, EvoPrompt and OPRO use different forms of generation, feedback and selection; TextGrad and GEPA use textual or execution-grounded diagnoses to guide revisions [82,86,87,143,144,145]. These methods connect design to repair: the same optimizer can construct a new instruction or correct an incumbent’s failure. Their common limitation is that a high validation score can reflect specialization to the search population. Held-out artifacts, tasks and starting programs test different kinds of reuse.

Search control and reusable operators.

Prompt search varies the source of feedback: error traces, synthetic comparisons and environment rollouts offer different independence and cost [146,147,148,149]. History-sensitive textual optimization adds credit assignment and control of revision magnitude [150,151,152]. These are improvements to a search design even when its outer implementation remains fixed.

Executable search introduces archives, diversity, uncertainty and crossover as mechanisms for retaining useful alternatives [153,154,155,156]. Returning search traces to proposal training differs from evolving models through weight-space operators [157,158]. Reusable transformations, typed skills and tool libraries narrow future search by preserving executable design knowledge [159,160,161,162]. Their transfer should be tested on new combinations, not inferred from library size.

Budget allocation, model routing and proxy evaluation alter which candidates receive expensive checks [163,164,165,166]. A proxy can reduce search cost while misranking the eventual deployment candidates. Independent execution and separate reporting of proposal, verification and deployment expenditure therefore remain necessary for claims about both efficiency and discovery quality.

5.4. Automated Research as Infrastructure Design

Research agents extend design to proposing hypotheses, implementing changes, conducting experiments and interpreting results. The AI Scientist reports span related stages of this workflow and do not constitute independent replications [167,168,169]. ASI-Evolve connects experimental analysis and accumulated priors to changes in data pipelines, architectures and learning algorithms [170]. The important inherited object is an executable finding together with its evidence and conditions of use, rather than the research report alone.

Research mechanisms.

Hypothesis-generation systems use knowledge representations, critique, tournaments or physical experiments to refine proposals [171,172,173]. Persistent research agents additionally retain ideation records, tools, strategies or scientific skills [174,175,176,177]. The central distinction is whether feedback selects a current hypothesis or improves how the next study is conducted.

For machine-learning research, experiment loops search algorithms and data pipelines while preserving evaluations and retrospective lessons [178,179,180,181]. Execution permissions, budgets, artifact management and explicit evidence records support these loops by making an experiment reproducible and its intended mechanism inspectable [182,183]. A run that completes successfully can still fail to implement the proposed idea, so operational success and scientific support need separate checks.

Training proposal generators and comparing research-search strategies also expose a tradeoff among quality, novelty and diversity [184,185]. A productive loop should retain negative results and uncertainty alongside successful recipes. Otherwise, later experiments inherit a selectively favorable record rather than reliable knowledge about where a design works.

Research assistance also includes task-local loops. AREX refines evidence and constraints through a learned context-update tool; OMNIFLOW uses a frozen multimodal model with physical consistency checks and rollback [85,186]. These mechanisms can improve an answer or experiment without training a successor researcher. SGI-Bench’s novelty-based test-time learning provides a different return path from retrieved literature to future proposals, but novelty alone does not establish scientific validity [187].

An infrastructure-design claim is strongest when a proposed algorithm survives independent reimplementation or rerunning. A recursive claim adds a further step: the resulting system participates in subsequent discovery, and does so more effectively. Human review, physical measurements and negative results remain legitimate inputs to that process. Their roles and costs should be reported, particularly when an inexpensive exploratory run precedes a costly test of a trained successor.

6. Repair and Optimization of Existing Systems

Repair begins with an incumbent and a diagnosed shortfall. Optimization can also target accuracy, efficiency or robustness without an explicit software bug. In both cases, Equation 3 asks for useful change subject to resource and regression constraints. We organize this literature by the state that receives the repair: parameters, experience stores, programs, feedback components and the improver itself.

6.1. Parameter Updates from Generated Experience

Self-training converts outputs selected under a feedback rule into new parameters. The central decisions concern generation, admission and the starting checkpoint for retraining. STaR iteratively improves a rationale pool while restarting each round’s fine-tuning from the original pretrained model; its continuity resides partly in the evolving training data [1]. Other methods use generated reasoning, offline experience reuse or preference training with human anchors [73,188,189]. Thus, an iteration label does not specify either the inherited state or the source of supervision.

Executable and formal feedback makes errors more observable in code and mathematics. DeepSeek-Prover, ReST-MCTS* and DeepSeek-R1 illustrate different ways of combining generation, verification, search and training [190,191,192]. These results support learning within the reported regimes; they do not show that the outer training algorithm improves itself. Evidence of stronger reasoning must also distinguish better sampling or selection from gains in the trained policy under a fixed evaluation budget.

Self-training mechanisms.

The literature groups naturally by the bottleneck it addresses. Instruction and reasoning synthesis broadens available supervision [193,194,195]. Verification, reflection and retry mechanisms refine which generated traces are admitted [196,197,198]. Mathematical and verifier-supported pipelines use more structured correctness signals [199,200,201,202]. These clusters concern different parts of one loop; better filtering need not supply missing task diversity.

Diversity-aware selection and adaptive training address that latter problem [203,204,205], while noise-aware preference and self-play optimization modify the learning signal [206,207]. Synthetic pretraining broadens the scale at which generated data enters the pipeline [208,209]. Across these regimes, self-training can also degrade [210]. Comparisons should therefore expose real-data retention, admission criteria and teacher dependence rather than treat all generated-data loops as one mechanism with one expected outcome.

The same return path appears beyond language reasoning. BeamVQ combines a vector-quantized code bank, beam search and physics-based selection, then uses selected forecasts in self-training [211]. Search improves a candidate prediction; returning selected candidates to training changes future generation. The physical criterion remains an external anchor. RoboAlign-R1 instead uses a frozen multimodal teacher to refresh a student’s reward proxy [212]. In both settings, the loop must retain its verification source in the description and test generalization beyond the conditions used for filtering or reward construction.

6.2. Memory and Skill Maintenance

Memory repair changes what the agent retains and how it retrieves or uses it. Generative Agents and MemGPT support persistent context, while Reflexion, ExpeL and Voyager emphasize reflective experience, extracted lessons and executable skills [3,4,77,213,214]. These forms differ in granularity and reuse: a successful trace preserves circumstances, a lesson abstracts them, and a skill specifies behavior. A useful memory can outlive one task without any change to the language-model weights.

Representation and management.

Memory systems vary along three dimensions. Conversational and experiential stores consolidate facts, temporal relations, beliefs or multiple memory types [215,216,217,218]. Graph, hierarchical and distributed structures change what relationships retrieval can recover [219,220,221,222,223]. Experience abstraction instead extracts workflows, reasoning strategies and subtask-specific lessons [224,225,226,227,228]. The right representation depends on whether the task needs exact recall, temporal consistency or procedural transfer.

Management methods train or revise admission, retrieval, augmentation and consolidation [229,230,231,232,233]. Latent pools, soft prompts and rehearsal-based consolidation blur the boundary between external storage and parameter learning [234,235,236,237,238]. The report must identify both the information that persists and the operations or parameters that change.

Cross-system memory records tool behavior, shares experience or preserves artifact lineage for later executors [239,240,241,242,243]. Provenance and applicability become central: a retrieved strategy is useful only if its assumptions still hold. Retrieval accuracy alone does not test whether memory helps the agent diagnose failures or produce better updates.

Skill creation and maintenance.

Skill construction converts interaction into APIs, tools and composable behaviors [244,245,246,247]. Lifecycle methods add validation, bounded edits and trace-based revision [248,249,250,251]. Learning the manager or generator further makes later skill quality part of the training objective [252,253,254,255]. These are distinct capabilities: creating a plausible skill, maintaining a useful library and improving its maintenance procedure.

Skills can guide new software tasks, supervise policy updates or generate robot-training curricula [256,257,258]. They also interact: complementary and conflicting tools, retirement under noisy judgments, acquisition constraints and transfer granularity all affect library utility [259,260,261,262]. Failure-driven code improvement with light human verification gives a further reminder to report outside intervention explicitly [263]. The pertinent endpoint is successful reuse under stated conditions, together with regressions and maintenance cost.

Training and deployment boundaries.

Web-agent training uses generated trajectories, search and critique, or failure-driven curricula [264,265,266]. World-model experience and environment assessment add further sources of feedback for adaptation [267,268]. Their value depends on the observation interface, action space and validity of simulated transitions. Agent learning frameworks place self-generated experience and feedback into training or evolving execution procedures [269,270,271]. Coaching, reflection and experience reuse provide complementary paths to later adaptation [272,273,274,275,276]. Operating-system agents, tool-building systems and symbolic agent learning extend the editable objects beyond model weights [277,278,279]. Test-time self-improvement further varies when an update occurs [280]. A common comparison records which state crosses the next task boundary and whether that state changes future update production.

The critical intervention separates stored content from the mechanism that manages it. Removing both at once cannot establish which produces the gain. Mem2Evolve and dynamic memory-graph approaches make the interaction between experience and its organization especially relevant [78,281]. A practical comparison freezes one of admission, retrieval, consolidation or content while varying the others. Tests should include shifted tasks and obsolete memories, because a library can grow while becoming less useful. An improved memory policy becomes an improver component when it determines how future experience produces future updates.

6.3. Prompt, Tool and Code Repair

Execution traces often localize a failure more clearly than a final reward. Prompt and program optimizers translate that evidence into revisions of instructions, tools or agent code. The design methods in Section 5.3 supply many of these operators; their use for repair adds a requirement to preserve previously correct behavior. Tests that trigger an edit are development evidence, while regression tests and sealed tasks probe the scope of the repair.

A local correction is valuable without being persistent self-improvement. Self-Refine and tool-grounded correction operate on current outputs [67,68]; SICA instead targets agent code used by later executions [282]. The distinction is what the next task inherits. Program repair also needs a distinction between a patch to a target repository and a patch to the agent that writes repository patches. Only the latter directly changes the update-producing machinery; even then, a later controlled test is needed to establish improved repair ability.

6.4. Maintaining Feedback and Evaluators

A feedback provider can improve, drift or be exploited as the actor changes. Self-Rewarding returns model preferences to training, while Meta-Rewarding also targets judging behavior; SaFeR-VLM studies self-feedback in a multimodal setting [2,79,283]. Shared actor–judge weights complicate attribution: a single training step can change both the answers and their assessment. Track actor outcomes, judge calibration and the downstream usefulness of feedback as separate measurements.

Feedback mechanisms.

Self-judgment, latent reasoning, trajectory consistency and endogenous reward estimation extract different proxies from model behavior [284,285,286,287]. Semantic agreement, reconstruction and peer prediction introduce other assumptions and auxiliary components [288,289,290]. Agreement can indicate consistency without establishing correctness; the reference used to calibrate each proxy must remain visible.

Verifier training and selective revision connect reference-supported error detection, step critiques and tool feedback [291,292,293,294,295]. Trajectory credit assignment instead estimates which actions contribute to successful outcomes [296,297,298]. These tasks require different calibration: detecting one wrong step, ranking candidate solutions and producing a stable training reward are related but separate objectives.

Explicit rules, meta-verification, research rubrics and structured attribution make feedback more inspectable [299,300,301,302]. Co-evolving tests, transition-based value estimates and critiques rewarded through their consequences evaluate feedback by what it helps improve [303,304,305]. This downstream test is particularly relevant to RSI: an explanation’s readability or a judge’s agreement with itself cannot substitute for evidence that its feedback produces a better successor.

Feedback sources are not interchangeable. Reference answers, environment outcomes, peer agreement and verbal critique reveal different information. A judge that ranks a fixed candidate pool well may still give unstable signals during repeated training. Likewise, refining an internal reward is an allowed update, but improvement under the revised reward must be kept separate from improvement under the original independent task criterion.

6.5. Repairing and Revising the Improver

Three clusters expose increasingly direct return paths without forming a universal capability ladder. Operator adaptation changes how edits are proposed: Promptbreeder evolves mutation prompts together with task prompts, and MetaRSI-v1 studies scheduling across data, harness and model operators [84,306]. Executable self-modification retains revised agent or improver code. Recursive conditioning retains material that a fixed meta-operation uses in later rounds. The comparisons below concern their different causal structures.

Executable self-modification.

STOP evaluates a program improver through the downstream utility of the programs it improves, and lets the procedure revise its own implementation [46]. DGM lets a coding agent revise its agent code while keeping the foundation model frozen; an archive and parent selection preserve alternatives to one lineage [5]. Hyperagents places task-agent and meta-agent code in one editable program; its principal DGM-H experiments retain handcrafted parent selection, with editable selection studied as an extension [6]. All three expose an implemented return path, but its scope differs: the program improver, shared agent logic or dedicated meta-agent can change, while other parts of the search remain external.

The value of a return path is a separate question. DGM’s fixed-modifier and archive ablations test specific contributions, but an archive-best score need not describe every descendant. Hyperagents measures successor gains and transfers an evolved system to new domains; transferring both task-agent and meta-agent code leaves starting-state attribution partly coupled. STOP’s transfer probes similarly concern selected evolved improvers. Section 7.6 preserves these distinctions when reading the results.

Recursive context under a fixed operator.

Metaⁿ applies a fixed operation $\Omega$ to earlier code, traces and context, producing new strategy layers and callable helpers [7]. Recursion lies in what the operator processes, rather than edits to its implementation. More depth, more candidate chains and more evaluation are separate resource changes. Context and library ablations can test the inherited material; matched-budget comparisons test whether its contribution survives control of extra search. Reported layer interference also shows why deeper recursion need not improve every chain.

Selection, shared state and changing objectives.

Improver methods differ in what makes a candidate worth retaining. Self-editing agents and descendant-aware selection expose the difference between current task quality and the quality of future offspring [307,308]. Memory-architecture search and guided mutation with evolution memory instead alter how experience informs future proposals [309,310]. Evaluating descendants can improve selection but also consumes the very budget against which improvement efficiency is measured.

Joint scaffold–weight updates, architecture-design agents and coupled populations of task agents and optimizers create additional attribution paths [311,312,313]. An architecture’s inner training gain is not automatically a gain in its designer; a changing task-agent population also changes the distribution on which optimizer quality is assessed. Held-out starting agents help test whether the advantage survives that change.

Finally, evolving utilities and aggregated objective proposals let the criterion change [314,315]. Record progress under both the revised objective and a stable external reference. Otherwise, a change in what the loop values becomes indistinguishable from improved ability to achieve a fixed goal.

6.6. Comparing Complete Configurations

Table 5 compares sixteen configurations by their inherited state, feedback and reported horizon. Its rows span both design and repair. The unit is the configuration, rather than a paper title or backbone alone: the same model can support local correction, persistent memory and code revision under different access rules. These descriptors make the later protocol comparison possible without assigning a single maturity score.

7. Benchmarks and Evaluation

An RSI experiment tests a sequence of proposals, acceptance decisions and retained changes. A final score summarizes only one outcome. The protocol in Figure 7 separates the development loop from independent audit, then compares task gain, retained behavior and successor production. The rules below are our synthesis of an experimental design, not a claim that every reviewed method implements them.

7.1. Match the Benchmark to the Engineering Goal

Interactive benchmarks expose task outcomes: AgentBench, GAIA and SWE-bench cover agent interaction, assistance and repository-level issue resolution [316,317,318]. Infrastructure-design benchmarks instead need executable artifacts and their downstream utility. MLAgentBench, MLE-bench and ScienceAgentBench probe machine-learning engineering and scientific experimentation [319,320,321]. RewardBench and ProcessBench test evaluators and reasoning-error detection [322,323]. A good score on one of these endpoints does not specify the improvement history that produces it.

Scientific and multimodal tasks broaden what an update must preserve. SGI-Bench separates research, idea generation and experimental reasoning; VideoGAIA tests multi-turn video understanding with tools [187,324]. Longitudinal environments make the history visible: SEA-Eval records success and cost along task streams, while SEAGym separates training, frozen update-validation, held-out tests, replay and cost records [325,326]. The benchmark supplies tasks and measurement; the researcher still specifies update rounds, retained state and acceptance.

7.1.1. Matching Benchmarks to the Claimed Update

A benchmark’s task realism and its suitability for measuring improvement are different properties. WebArena and Windows Agent Arena provide interactive environments, while $\tau$-bench tests tool use, policy compliance and consistency across repeated interactions [327,328,329]. These settings can host an improvement experiment, but the experiment must add an explicit sequence of updates and a rule for retained state. Repeated attempts by an unchanged agent measure a different quantity from repeated attempts after a learned update.

Software engineering also needs strong fixed-design comparisons. SWE-agent shows the effect of the agent–computer interface, and Agentless establishes a simpler localization, repair and validation baseline [330,331]. SWE-Bench Pro broadens the scope toward longer-horizon repository work; benchmark mutation studies examine how formal issue descriptions differ from realistic user requests [332,333]. These comparisons help prevent an interface advantage or an easier prompt distribution from being attributed to recursive improvement.

Training environments and test environments play different roles. SWE-Gym and R2E-Gym supply executable software tasks and support work on agent training and verification. EnvScaler synthesizes tool-interaction sandboxes [334,335,336]. Their usefulness for producing experience does not make the same tasks independent tests of a trained successor. Repository overlap, task-generation seeds and shared verification code should therefore be recorded when such infrastructure appears on both sides of an evaluation.

Persistent state requires longitudinal tests. TRACE evaluates continual learning across tasks; LifelongAgentBench uses interdependent agent tasks; and AutoEnv studies learning across heterogeneous environments [337,338,339]. GateMem adds governance requirements to shared memory, including state updates, access boundaries and forgetting [340]. A protocol can improve recall while regressing on other retained requirements, so longitudinal utility should include both newly acquired behavior and obligations carried from earlier interactions.

Tool and algorithm creation can be probed directly. Tool-Genesis separates interface compliance, functional correctness and downstream utility. The Meta-Agent Challenge tests autonomous construction of agent artifacts, while AI4AI-Bench targets changes to training algorithms and independently reruns the resulting code [341,342,343]. These are useful instruments for measuring capabilities required by RSI. A successful artifact remains one link in the chain; testing an improved procedure on the next construction round supplies a further link.

Dynamic benchmarks address saturation but complicate comparability. Benchmark Self-Evolving transforms existing instances, TRACE’s validate-by-reproduce framework checks generated task trajectories, and BenchEvolver grounds harder coding tasks in evolved solutions [344,345,346]. An evolving task stream should be paired with a stable reference distribution. Otherwise, a lower score can reflect harder tasks and a higher score can reflect a generator’s changing preferences, rather than a change in the system being assessed.

Finally, resource controls must follow the operation being measured. Compute-optimal test-time scaling studies allocation across inference strategies, while SWE-Effi accounts for the costs of both successes and expensive failures [347,348]. For an RSI comparison, this means charging unsuccessful candidate updates, verifier calls, environment construction and retraining to the same declared budget. Reporting a final solver’s inference cost alone omits the investment that produces it.

Table 6. Match objectives to tests. Examples supply task endpoints; an RSI study must add update histories and independent audit.

Goal	Example setting	Endpoint	Additional probe
Infrastructure design	MLE-bench; AI4AI-Bench	Rerun artifact quality; cost	New tasks and training runs
System repair	SWE-bench; tool environments	Resolved failures; regressions	Sealed tasks; protected behaviors
Persistent adaptation	SEAGym; continual tasks	Gain; retention; transfer	Reset boundaries; replay; cost
Improver update	Held-out starting solvers	${\Gamma }_t\left(B\right)$; successor quality	Same states, feedback and budget
Research validity	Reproduction and scientific tasks	Reproducibility; supported claims	Independent checks; negative results

Table 6. Match objectives to tests. Examples supply task endpoints; an RSI study must add update histories and independent audit.

Goal	Example setting	Endpoint	Additional probe
Infrastructure design	MLE-bench; AI4AI-Bench	Rerun artifact quality; cost	New tasks and training runs
System repair	SWE-bench; tool environments	Resolved failures; regressions	Sealed tasks; protected behaviors
Persistent adaptation	SEAGym; continual tasks	Gain; retention; transfer	Reset boundaries; replay; cost
Improver update	Held-out starting solvers	${\Gamma }_t\left(B\right)$; successor quality	Same states, feedback and budget
Research validity	Reproduction and scientific tasks	Reproducibility; supported claims	Independent checks; negative results

7.2. Separate Development, Selection and Sealed Testing

Development feedback guides proposals or training; validation selects updates; sealed tests measure the resulting states. ADAS illustrates validation-guided search with held-out testing [80]. Repeatedly selecting against a fixed validation set still adapts the search to that set. Aggregate scores also convey information, so withholding individual labels is insufficient if test averages guide future edits.

Before a run, declare checkpoint times, budget milestones and selection rules. After all runs finish, an independent evaluator audits the scheduled checkpoints without returning scores to proposal, acceptance, stopping or checkpoint selection. Report the final checkpoint and any validation-selected checkpoint under their declared roles. Selecting the best checkpoint after inspecting its test performance compromises the audit. A procedural split also cannot rule out pretraining contamination; task release dates and model versions remain relevant, as release-aware testing such as LiveCodeBench emphasizes [349].

A deployment-oriented gate can formalize acceptance as

$$A_t=\mathbf{1}\left\{{\widehat{\Delta }}_{\mathrm{val}}\ge {\eta }_t,{\widehat{r}}_{t,j}\le {ϵ}_j\forall j,C_{\le t+1}\le B\right\},X_{t+1}=\left\{\begin{array}{cc}{\tilde{X}}_{t+1},\hfill & A_t=1,\hfill \\ X_t,\hfill & A_t=0.\hfill \end{array}\right.$$

(9)

Here ${\widehat{\Delta }}_{\mathrm{val}}$ estimates the candidate’s validation gain, ${\widehat{r}}_{t,j}$ estimates loss on protected group j, ${\eta }_t$ is a predeclared gain threshold and ${ϵ}_j$ a regression tolerance. These estimates can be noisy; the rule does not guarantee an independent test gain. Uncertainty-aware thresholds, repeated checks and recovery records make its behavior assessable. An exploratory archive can retain weaker candidates as future parents, so archive admission, parent selection and deployment acceptance must be reported separately.

Staged screening can save resources but changes score coverage. DGM first checks candidates on smaller subsets [5]; a candidate rejected early and one evaluated broadly have different observed evidence. Unevaluated tasks should not silently become measured failures. Preserve the screening history and audit selected artifacts on a common population.

7.3. Account for Full Development and Deployment Cost

An update round can mean a prompt edit, a population search or a training run. Use a non-overlapping cost ledger:

$$C_{\le T}={\displaystyle \sum _{t=0}^{T-1}}\left(c_t^{\mathrm{proposal}}+c_t^{\mathrm{train}}+c_t^{\mathrm{validation}}+c_t^{\mathrm{execution}}\right).$$

(10)

Include retries, rejected candidates and environmental checks; proposal inference belongs to the proposal term. Record independent audit cost separately under matched test-time limits. When GPU time, API expenditure and physical experiments lack a defensible common conversion, report a resource vector rather than add unlike units.

A shared budget cap does not ensure equal realized spending. Report quality at common cost milestones, together with per-task deployment cost. GEPA’s rollout budget controls one scarce resource, but does not equalize all tokens used to propose edits [82]. Similarly, matching tokens can leave model prices and tool latency unmatched. The relevant idea is skill-acquisition efficiency as well as task competence [350]; RLVR analyses using large-sample pass@k also show why inference limits affect the interpretation of learned gains [351].

For a deployment horizon of N future tasks, report $C_{\mathrm{total}}\left(N\right)=C_{\mathrm{development}}+N{\overline{c}}_{\mathrm{task}}$ alongside quality, where ${\overline{c}}_{\mathrm{task}}$ is the measured average serving cost. Reuse can amortize an expensive update, but only on tasks to which it applies. A cheaper search that produces an expensive agent need not be the more economical system over that horizon.

7.4. Isolate the Contribution of the Improver

Compare the full loop with a frozen-improver control that permits solver updates using $I_0$, and a no-persistent-update control that permits inference-time search within the same declared limits. DGM’s fixed-modifier baseline supplies a precedent for the first comparison [5]. The controls separate extra search, persistent adaptation and adaptation of the update procedure.

The paired probe in Equation 8 applies $I_t$ and $I_0$ to copies of the same held-out starting states. It tests the successors they produce at matched cost, with the probe isolated from the primary trajectory. STOP and Hyperagents motivate such downstream tests [6,46]. A swap is interpretable only if interfaces and dependencies remain compatible. Otherwise, failure may reflect a missing memory schema or broken tool interface rather than worse improvement ability.

When roles share code or weights, report the coupling and use the narrowest valid intervention. Removing both memory and its manager cannot identify the contribution of either alone. Factorial comparisons can separate their interaction when feasible. Baselines also need a functional opportunity to improve: repairing an invalid output format is useful, but differs from improving reasoning in an already functioning agent. Record these failure categories rather than collapse them into one score.

7.5. Measure Trajectories, Retention and Transfer

For each scheduled checkpoint, report quality versus cumulative cost, acceptance rates, new successes and regressions on earlier groups. An archive can preserve a strong candidate while its latest branch deteriorates; archive-best, deployed and final-state curves therefore answer different questions. Replay and transfer tests instantiate Equation 6; SEAGym’s replay view makes capability turnover visible [326].

Repeated runs should vary update generation and selection, not only final inference. State whether uncertainty summarizes tasks, search seeds, environments or task orders. A conservative gate that rejects almost every change can be stable but unproductive; an aggressive gate can gain quickly and incur costly recovery. Track accepted gains, rejected useful candidates, recovery cost and retained constraints together.

Transfer has several axes: tasks, backbones, tool interfaces and feedback sources. Varying them separately helps locate the inherited advantage. Transferring a solver tests a different object from transferring an improver. Figure 8 accordingly separates update targets from protocol evidence; its selected sample supports neither a prevalence estimate nor a common ranking of sustained RSI.

7.6. What the Current Evidence Supports

Table 7 compares eight protocols. The evidence clusters into artifact gains, transfer of update-producing procedures, and measurement limits. ADAS and GEPA test discovered designs or prompts with fixed outer optimizers; STOP tests an evolved improver; Metaⁿ tests recursive context and helpers [7,46,80,82]. They do not run one common RSI benchmark.

Artifact gains depend on the evaluated population.

DGM reports gains from 20.0% to 50.0% on its 200-task SWE-bench Verified subset after 80 iterations. Its Polyglot scores increase from 14.0% to 38.0% on a 50-task subset and from 14.2% to 30.7% on the full benchmark. These assessments include search tasks and are not wholly independent holdouts [5]. These figures describe different populations. Similarly, an archive’s per-task best score need not describe any deployable single agent. On CO-Bench with Gemma 4, Metaⁿ reports $0.851\pm 0.014$ for archive-best, $0.782\pm 0.016$ for its best single chain, and $0.814\pm 0.022$ for OpenEvolve (standard deviations over three seeds) [7]. The comparator ordering changes with the selected object; these values alone do not establish statistical significance.

Bounded evidence exists for improved successor production.

STOP tests 50 unseen learning-parity-with-noise instances over five runs and transfers a selected evolved improver to five additional utility settings. Its tested GPT-4 configuration improves early, whereas tested GPT-3.5 and Mixtral configurations can regress [46]. Hyperagents transfers evolved task-agent and meta-agent code to math grading; with the transferred meta-agent frozen for 50 new iterations, the validation-selected agents achieve a reported test score of 0.630 (confidence interval 0.540–0.630), from an initial zero score [6]. This supports useful transferred generation ability under that setup. It does not isolate meta-agent quality from the transferred starting agent, and the initial grader’s invalid format is a material qualification. In the source-domain comparison, DGM-H’s gains over DGM-custom are not statistically significant at the paper’s stated threshold, although comparisons with its frozen self-improvement control are significant.

Budget and feedback controls narrow the conclusions.

Metaⁿ adds token-parity tests on two prompt tasks, supporting a contribution beyond extra tokens in those settings; this does not equalize total cost across all experiments [7]. Meta-Rewarding reports an AlpacaEval 2 length-controlled win rate of 39.44% after four iterations, versus 35.49% for its length-controlled Self-Rewarding baseline [79]. Its separate judge tests show that early gains in correlation with human rankings do not persist in all later rounds. Automatic actor preference gains and stable evaluator improvement are thus different observations.

These examples show practical progress on bounded tasks and some direct probes of improvement ability. They also show regressions, selection effects, shared-state confounds and uneven budget controls. The evidence does not establish indefinite capability growth, reliable acceleration, or complete independence from externally supplied objectives and feedback.

8. Challenges and Future Directions

Useful feedback loops can also preserve mistakes. Figure 9 connects six constraints to testable questions. The common concern is whether a local gain remains useful as tasks, components and evaluation signals change.

8.1. External Feedback and the Risk of Drift

Self-Refine and studies of intrinsic self-correction reach different outcomes under different models, tasks and feedback access [67,352]. Repeated critique is therefore an operation to evaluate, rather than a generally reliable source of new information. Model-judge biases and shared actor–judge updates can make internal rewards increasingly favorable without a corresponding task gain [79,353]. Evidence graphs can make support and contradiction inspectable within a research task, but their improved belief state still differs from improved learning across tasks [354].

Outside feedback can take several forms: executable tests, fresh observations, trusted reference data, human preferences, expert review or physical experiments. Its purpose is to add information or constraints unavailable from the loop’s current proxy alone. No single source is infallible: tests have coverage limits, humans disagree and environments can shift. A useful study varies the source, frequency and cost of external feedback while holding other resources fixed. Track independent quality, acceptance errors and recovery across rounds, including a no-new-feedback condition. This tests when external intervention is helpful, rather than assuming that all RSI requires continuous human supervision or that none requires it.

8.2. Experience Selection and Coverage

Recursive synthetic-data training can degrade under particular replacement regimes, while retaining and accumulating real data changes the outcome in other tested settings [355,356,357]. These findings identify data composition and selection as experimental variables; they do not establish inevitable collapse for every feedback loop. For agents, old lessons and executable skills can preserve rare successes or stale assumptions [4,77]. Compare replay, selective retention and refresh on both earlier and shifted tasks, with storage, retrieval and maintenance costs. A larger store is useful only if its contents remain applicable.

8.3. Interacting Updates and Recovery

A new prompt can change a retrieval cue; a tool revision can invalidate a skill; training can alter a formerly successful workflow. Layer interference and replay regressions make these dependencies visible [7,326]. Archives preserve alternatives, rollback restores an earlier state and consolidation attempts to retain useful behavior in a new representation. Compare these policies under common budgets and preserve complete dependencies in checkpoints. Recovery time, lost skills and post-recovery quality matter alongside the latest task score. Stability is a measured property over a stated horizon, not a consequence of recursion.

8.4. Evaluation Integrity Under Self-Modification

An editable system can change how a development score is obtained. DGM’s objective-hacking example and contamination concerns illustrate distinct routes to misleading gains [5,349]. The broader lifecycle perspective includes risks introduced through data, training and deployed components [27]. An experimental boundary should protect test labels, audit code and accounting from the editable state. Internal judges can evolve while the independent reference remains fixed. Varying the allowed edit scope then tests both performance and preservation of the conditions under which that performance is meaningful.

8.5. Discovery and Verification Compete for Resources

More proposals can consume the budget on weak candidates; excessive early verification can eliminate exploration. Reflective search uses detailed feedback to target edits, but obtaining and interpreting that feedback also costs resources [82]. Compare proposal breadth, verification depth and staged screening at matched total cost. Record useful candidates lost to screening and regressions admitted by cheap proxies. Deployment horizons should be explicit when assessing whether the cost of training or tool construction pays for itself through reuse.

8.6. Transfer and the Limits of Current Demonstrations

Transferring a discovered design and transferring a procedure that discovers better designs are different experiments [6,80]. The paired probe controls starting states within each new domain; separate shifts in task, backbone, interface and reward help identify what transfers. New task generation can sustain learning opportunities, as POET and Absolute Zero motivate, but it also needs independent measures of coverage and value [41,75].

Formal self-modification results depend on their axioms and utility conditions [30]. Finite empirical trajectories cannot prove indefinite progress, and the absence of such evidence does not prove RSI impossible. The immediate research target is narrower: reproducible gains that persist under controlled shifts, at a known cost, while retaining the ability to recognize and recover from harmful updates.

8.7. Failure Mechanisms and Scientific Validity

Optimization, information and behavioral drift.

Campaign-level self-regression, loss of training knowledge and exploration collapse concern different states and timescales [358,359,360]. Reward bias, overconfidence and ungrounded reflection expose errors in the proxy itself [361,362,363]. Data admission, task design and verifier quality can be varied independently of the reward assigned to admitted examples [364,365,366]. A verified search artifact can also fail to teach the unaided model the computation it performs [367]. These mechanisms call for different interventions; grouping them all as collapse hides where the feedback loop fails.

Persistence can preserve vulnerabilities.

Model, memory, tool and workflow updates can carry undesirable behavior across rounds, including alignment drift under particular training regimes [368,369,370,371]. Memory manipulation, extraction and poisoning create distinct admission, retrieval and access-control problems; validation defenses address only specified parts of that threat model [372,373,374,375]. Executable skills and agent access-control proposals extend the boundary from information storage to permitted action [376,377]. Report tested attacks separately from proposed governance mechanisms, and check retained constraints alongside retained capability.

Scientific claims need evidence beyond a completed report.

Integrity, methodological soundness and replication benchmarks test different failure modes in automated research [378,379,380]. Case studies of failed autonomous experiments and active reverse engineering further distinguish plausible explanations from interventions that identify a mechanism [381,382]. Claim-level evidence records and judge characterization support auditability [383,384]. Broader critiques of missing practical knowledge and publication bias identify information that a research loop may never receive [385,386]. They motivate retaining negative results, uncertainty and reasons for rejection, rather than treating a favorable paper-review score as proof of scientific discovery.

9. Conclusion

RSI connects a system’s present capabilities to the process that produces its next improvement. This survey separates two practical goals—designing AI infrastructure and repairing or optimizing an existing system—and relates both to inherited state, feedback and update production. The connection to AutoML and meta-learning is substantial: automated search, learned update rules and reusable design experience are established foundations. The additional empirical question concerns the value of the return path into future improvement.

Several parts of this agenda already work in bounded settings. Generated experience supports parameter learning, memories and skills support reuse, and automated search produces useful prompts, workflows and programs. DeepSeek-R1 demonstrates verifiable-reward reasoning training; Llama-based self-rewarding studies examine actor and judge updates; GPT-based program improvers and other frozen-backbone agents test useful changes outside model weights [2,46,79,192]. These successes concern different objects and do not establish that the underlying foundation model autonomously improves its entire training stack. Selected improver-transfer experiments provide a further, qualified step toward reusable improvement ability.

The appropriate tests follow the claim. Task benchmarks measure artifact quality; replay and shifted tasks measure retention and transfer; paired successor-production probes measure improver quality. All need an explicit selection boundary, complete resource accounting and uncertainty over improvement runs. Current evidence leaves unrestricted, indefinitely sustained or reliably accelerating RSI unestablished. It also shows that regression is possible and that execution, trusted data and human expertise can remain important sources of correction.

A productive research agenda therefore asks which inherited changes remain useful, under what feedback and budget, and for how long. Closer links between objective design, independent audit and failure recovery make those questions answerable. Progress consists of reproducible improvements to both systems and their update procedures, with their limits visible.

ChatGPT (OpenAI) assists with literature searches, manuscript drafting, translation, language editing, and figure preparation. The authors retain responsibility for the content, citations, and conclusions.