Aman's AI Journal • Primers • Recursive Self Improvement

Overview
Foundations and a Taxonomy of Recursive Self-Improvement
- Bounded Self-Refinement and Open-Ended RSI
- A Complementary Autonomy-Centered View
  - Autonomy Levels from Execution to Meta-Improvement
L5 Recursive inheritance / meta-improvement AI revises and reuses mechanisms that govern subsequent improvement, such as improvers, evaluators, search policies, or research-control procedures
Full RSI Entire successor-generation stack Yes Endogenous + grounded verification Closed
Deployment-Time Self-Evolution
Training-Time Self-Iteration
Self-Evaluation, Verification, and Reward
Automated Research and Algorithm Discovery
Multi-Agent Scaling and Research Swarms
Recursive Amplification, Bottlenecks, and the Path to Open-Ended RSI
Challenges, Safety, and Open Research Questions
Citation

Overview

Recursive self-improvement (RSI) describes a class of AI systems in which AI becomes an increasingly important input into the process that produces better AI. The strongest version is a closed development loop: a system contributes to designing, implementing, evaluating, training, and deploying a more capable successor, which can then perform the same process more effectively. The central idea predates modern language models. Gödel Machines: Self-Referential Universal Problem Solvers Making Provably Optimal Self-Improvements by Schmidhuber (2003) formalized a self-referential system that rewrites its own program when it can prove that the rewrite increases expected utility, while Recursive Self-Improvement framed recursion as turning improvement of the system’s own cognitive machinery into an object-level optimization problem.
Modern RSI is broader than literal source-code rewriting. A contemporary AI system is a stack containing model weights, inference algorithms, prompts, tools, memory, agent scaffolding, training data, reward signals, evaluators, distributed systems, and the research process that designs all of them. Self-improvement can therefore occur at several layers simultaneously. Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) organizes this landscape around deployment-time self-evolution, training-time self-iteration, self-evaluation, and automated research, while distinguishing these mechanisms by how completely the improvement loop is closed.
The key distinction is therefore between self-improvement and recursive self-improvement. An LLM that critiques an answer and produces a better answer has self-refined, but the improvement disappears when the episode ends. A model that generates training examples subsequently used to update its own weights produces a persistent improvement, but still need not constitute RSI. An agent that improves its coding harness, creates better evaluation tools, discovers a more efficient training algorithm, uses that algorithm to train a stronger model, and then delegates the next iteration to that stronger model is much closer to genuine recursion. RSI begins to become consequential when improvements persist and feed back into the machinery responsible for generating subsequent improvements.

The Core Feedback Loop

A useful abstraction is to represent an AI development system at iteration \(t\) as
\[S_t = \left(M_t,\; H_t,\; D_t,\; E_t,\; C_t,\; R_t\right)\]
- where \(M_t\) is the model, \(H_t\) its harness or agentic scaffolding, \(D_t\) its data, \(E_t\) its evaluators and verifiers, \(C_t\) the available computational resources, and \(R_t\) the research and engineering process used to construct the next system.
The ordinary AI-development process can be represented as
\[S_{t+1} = F(S_t, H_{\text{human}}, C_t)\]
- where human researchers remain the principal optimizer. RSI progressively replaces part of \(H_{\text{human}}\) with capabilities supplied by \(S_t\) itself:
  \[S_{t+1} = F(S_t, A(S_t), H_{\text{human}}, C_t)\]
  - where \(A(S_t)\) denotes AI-generated research, code, experiments, data, evaluations, architectures, training recipes, or other improvements. Full loop closure is approached as the human contribution becomes supervisory rather than operational:
    \[S_{t+1} \approx F(S_t, A(S_t), C_t)\]
This formulation captures why RSI is better understood as a spectrum of loop closure than as a binary event. When AI builds itself describes essentially this progression: human-written AI systems give way to chatbot-assisted development, coding agents, autonomous agents capable of delegating work to other agents, and eventually systems capable of designing and developing successor systems. Current systems have moved materially along this continuum, but autonomous execution is considerably easier than autonomously determining which research directions should be pursued.
The following figure (When AI builds itself) shows the progression from human-driven AI development through chatbot assistance, autonomous coding agents, multi-agent workers, and ultimately a closed loop in which AI systems increasingly perform the work required to create their successors.

From Assistance to Recursion

The path toward RSI can be understood as increasing both the persistence and scope of AI-generated improvements.
At the shallowest level, the system improves an artifact without changing itself. Methods such as Self-Refine: Iterative Refinement with Self-Feedback by Madaan et al. (2023) repeatedly generate, critique, and revise outputs, demonstrating that iterative inference can improve task performance without modifying model weights. This is useful self-correction, but it is not recursive because the improved output does not make the underlying improver permanently better.
A deeper level persists improvements into the model or its environment. STaR: Bootstrapping Reasoning With Reasoning by Zelikman et al. (2022) iteratively generates rationales and fine-tunes on successful reasoning trajectories, illustrating how a model can help create the data from which its later version learns. Self-Rewarding Language Models by Yuan et al. (2024) goes further by allowing the model to participate in generating the preference judgments used for its own alignment, moving both policy generation and evaluation partially inside the AI system.
Agentic self-modification pushes the loop further still. Gödel Agent: A Self-Referential Agent Framework for Recursive Self-Improvement by Yin et al. (2024) allows an agent to inspect and modify its own logic rather than restricting optimization to a predefined component. Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents by Zhang et al. (2025) replaces the requirement for formally proven improvements with empirical evaluation, maintaining and testing an evolving population of agent modifications. These approaches make the harness itself an optimization target, meaning that successful modifications can alter how subsequent modifications are generated and evaluated.
Automated algorithm discovery provides another important bridge. Mathematical discoveries from program search with large language models by Romera-Paredes et al. (2024) introduced FunSearch, which repeatedly samples programs from an LLM, evaluates them with an executable objective, and feeds high-performing programs back into an evolutionary search. AlphaEvolve: A coding agent for scientific and algorithmic discovery by Novikov et al. (2025) generalizes this approach to algorithmic and systems optimization, including improvements to computational infrastructure and an optimization that accelerated training of the model underlying AlphaEvolve itself. These systems are significant because the output of AI-guided search can improve components of the infrastructure on which future AI runs.

The Conditions for Recursive Amplification

Not every feedback loop produces accelerating improvement. A useful first-order model is
\[Q_{t+1}=Q_t+\Delta Q_t\]
- where \(Q_t\) represents effective AI capability and \(\Delta Q_t\) is the improvement generated during iteration \(t\). The central RSI question is not merely whether
  \[\Delta Q_t > 0\]
  - but whether increasing capability improves the system’s ability to generate the next improvement:
    \[\frac{\partial \Delta Q_{t+1}}{\partial Q_t}>0\]
A strongly recursive regime would require this feedback to be sufficiently large that better systems systematically make the improvement process itself faster or more productive. In conceptual terms, three conditions matter: the loop must close, improvements must increase the ability to produce subsequent improvements, and the gains must survive the frictions introduced as the system scales.
This produces an important distinction between capability growth and improvement-rate growth. Suppose AI-assisted research creates a constant capability increment:
\[Q_{t+1}=Q_t+c\]
Capability improves, but the process is approximately linear. By contrast, a simple recursive model might take the form
\[Q_{t+1}=Q_t+\alpha Q_t\]
- giving
  \[Q_t=Q_0(1+\alpha)^t\]
Here, greater capability increases the amount of improvement generated during the next cycle. This is the mathematical intuition behind an intelligence-explosion argument. It is not, however, evidence that real AI development will obey such dynamics. Real systems contain bottlenecks, saturation effects, serial dependencies, evaluator errors, resource constraints, and research problems whose difficulty may increase as easier improvements are exhausted.
A more realistic abstraction therefore includes a friction term:
\[Q_{t+1} = Q_t + G(Q_t,C_t,V_t,D_t) - L(Q_t,C_t,V_t,D_t)\]
- where \(G\) captures useful improvement and \(L\) captures losses arising from coordination overhead, imperfect verification, duplicated work, distributional degradation, limited compute, and other bottlenecks. RSI becomes strongly accelerating only when the marginal growth of \(G\) persistently exceeds the marginal growth of \(L\).
This framing reconciles two observations that can otherwise appear contradictory. AI systems can already make AI development substantially faster while full RSI remains unachieved. The relevant question is not whether AI contributes to AI research. It increasingly does. The question is whether those contributions can eventually encompass the entire causal chain required to generate a more capable successor and whether the resulting successor increases the efficiency of that same chain.

Verification as the Load-Bearing Component

The most important technical constraint on self-improvement is defining and measuring “better.” Any self-improvement loop implicitly contains an evaluator
\[E(x) \rightarrow r\]
- which maps a candidate modification \(x\) to a quality signal \(r\). The optimizer then searches for
  \[x^*=\arg\max_x E(x)\]
If \(E\) accurately measures the desired property, repeated optimization can produce genuine progress. If \(E\) is only an imperfect proxy, stronger optimization can increasingly exploit the discrepancy between the proxy and the intended objective.
This explains why some of the strongest demonstrations of automated discovery occur in domains with cheap, objective verification. A generated program can be compiled and benchmarked. A mathematical construction can often be checked mechanically. A scheduling algorithm can be run against a simulator. FunSearch is explicitly built around problems that are difficult to solve but comparatively easy to evaluate, while AlphaEvolve similarly depends on automated evaluators that can rapidly score large populations of candidate programs.
Open-ended AI research is harder because many important decisions do not have an equivalent verifier. Determining whether an implementation passes its unit tests is comparatively straightforward. Determining whether a new architecture is scientifically important, whether an experimental result reveals a genuine mechanism, or which research direction deserves several months of compute is much less amenable to a deterministic evaluation function. The recent RSI literature consequently places evaluator quality at the center of the problem, distinguishing formal verifiers and execution feedback from learned reward models, LLM judges, rubrics, and ultimately intrinsic self-assessment.
This distinction is crucial because recursive improvement ultimately requires improving not only the object being optimized but potentially the optimization criterion itself. Once an AI can modify its evaluator, the loop becomes
\[(S_t,E_t) \rightarrow (S_{t+1},E_{t+1})\]
- rather than
  \[S_t \xrightarrow{E} S_{t+1}\]
That transition substantially increases the potential scope of improvement, but also makes it harder to establish that measured progress corresponds to genuine progress.

Why Multi-Agent Scaling Matters

RSI need not depend exclusively on producing a much smarter individual model. A second axis is the amount of effective cognitive labor that can be instantiated from a capable model. If one agent provides useful research labor, many copies can search different hypotheses, run experiments, inspect code, critique results, and aggregate findings concurrently.
A simple approximation is
\[W(N)=N\eta(N)w\]
- where \(N\) is the number of agents, \(w\) is useful work from one agent, and \(\eta(N)\) is parallel efficiency. Perfect scaling would have \(\eta(N)=1\). Real multi-agent systems generally have \(\eta(N)<1\) because tasks contain serial dependencies, duplicated exploration, communication overhead, context fragmentation, and aggregation costs.
The significance for RSI is that a modest increase in individual-agent capability can interact with enormous increases in available agent-hours. Noam Brown – Agent swarms, alignment, & recursive self-improvement discusses multi-agent inference as a way to convert additional compute into parallel cognitive effort, while emphasizing that scaling efficiency is domain-dependent: search-like and mathematical tasks can parallelize considerably better than tightly coupled creative tasks.
This creates two distinct routes to faster AI research:
\[\text{Research throughput} \approx \text{capability per agent} \times \text{number of agents} \times \text{parallel efficiency}\]
RSI could therefore accelerate through better researchers, more researchers, faster researchers, or some combination of all three.

RSI Is Better Viewed as a Stack Than a Single Algorithm

The modern path toward RSI is unlikely to consist of a model simply opening its own source code and repeatedly making itself smarter. The practical system is more naturally viewed as a nested stack of improvement loops:
\[\text{outputs} \rightarrow \text{skills and memory} \rightarrow \text{agent harness} \rightarrow \text{training data} \rightarrow \text{reward/evaluation} \rightarrow \text{model weights} \rightarrow \text{training algorithms} \rightarrow \text{AI research process}\]
Each layer has a different persistence timescale. Output refinement lasts for a single inference episode. Memory and skill updates can persist across episodes. Harness modifications can permanently change agent behavior. Training changes model parameters. Algorithmic discoveries can change the process used to produce every subsequent model. Automated research can, in principle, modify the entire stack.
This layered view also prevents ordinary iterative refinement from being conflated with full RSI. Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) makes this distinction explicit: bounded self-refinement operates against relatively fixed objectives and evaluators, whereas open-ended RSI progressively places the system, its improvement machinery, and potentially its evaluative machinery inside the loop.

Where the Frontier Currently Lies

The empirical frontier is best characterized as partial loop closure rather than full RSI. AI systems can already generate and revise code, operate development environments, run experiments, construct training examples, produce preference signals, optimize agent scaffolding, search over programs, and discover useful algorithms. In sufficiently verifiable domains, these pieces can be connected into long-running automated optimization loops.
The remaining gap is disproportionately concentrated in activities that require reliable long-horizon judgment: selecting worthwhile research questions, recognizing when an apparently successful research program is optimizing the wrong target, designing genuinely informative experiments, interpreting ambiguous results, and determining whether an improvement transfers outside the environment in which it was discovered. AI researchers debate how close we are to recursive self-improvement discusses this frontier in terms of generalization, long-horizon reinforcement learning, possible paradigm shifts, and whether current learning systems can discover the innovations required to escape future diminishing returns.
Accordingly, the central empirical question for RSI is no longer whether AI can improve pieces of AI systems. It demonstrably can. The deeper question is whether these individually successful loops can be composed into a persistent, sufficiently grounded, sufficiently general research process whose outputs improve the process that generated them.
Conceptually:
\[\boxed{ \text{RSI} = \text{persistent self-improvement} + \text{loop closure} + \text{reliable evaluation} + \text{recursive amplification} }\]
Removing any one of these terms changes the phenomenon. Without persistence, the system merely reasons longer. Without loop closure, humans remain the optimizer coordinating the improvement cycle. Without reliable evaluation, optimization can amplify errors or proxies rather than capability. Without recursive amplification, AI may dramatically accelerate R&D while progress remains approximately linear or saturating rather than explosively recursive.
This distinction will guide the rest of the primer: RSI should be analyzed not as a single speculative threshold, but as the progressive closure of increasingly consequential improvement loops, from inference-time refinement through self-training and self-modifying agents to automated AI research and successor-model development.

Foundations and a Taxonomy of Recursive Self-Improvement

Recursive self-improvement is best understood as a family of feedback mechanisms rather than a single algorithm. The phrase covers systems ranging from models that iteratively improve their outputs to agents that modify their own scaffolding, models that learn from self-generated data and rewards, evaluators that themselves evolve, and automated research systems that participate in designing future AI systems. These mechanisms differ substantially in what is being improved, how persistent the improvement is, what provides the supervisory signal, and how much of the improvement loop remains under human control. Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) formalizes this distinction using two primary axes: the object being improved and the degree of loop closure.
A useful conceptual decomposition is
\[\text{Self-improvement mechanism} = (\text{improvement target},\; \text{update mechanism},\; \text{evaluator},\; \text{persistence},\; \text{loop closure})\]
This decomposition matters because two systems described as “self-improving” may have almost nothing technically in common. A model rewriting a draft while keeping its parameters fixed is fundamentally different from an agent modifying its own orchestration code, and both are fundamentally different from an automated research system that proposes and evaluates new training algorithms.

The most important conceptual boundary is between bounded self-refinement and open-ended recursive self-improvement.
In bounded self-refinement, the optimization target and evaluation procedure remain substantially fixed. Let \(S_t\) denote the system at iteration \(t\) and let \(E\) be an external evaluator. Improvement takes the form
\[S_{t+1} = \operatorname{Improve}(S_t;E)\]
- subject to
  \[E(S_{t+1}) > E(S_t)\]
The system can search extensively for better solutions, but “better” continues to be defined by a relatively stable external criterion. Unit tests, theorem checkers, benchmark suites, environment rewards, and human preference labels are examples.
This regime encompasses a large fraction of today’s practical self-improvement methods. Self-Refine: Iterative Refinement with Self-Feedback by Madaan et al. (2023), for example, repeatedly uses the same LLM to generate an output, critique it, and revise it without updating the model parameters. The paper reports improvements across seven tasks, demonstrating meaningful test-time self-refinement while leaving the underlying improvement mechanism fixed.
Open-ended RSI relaxes this assumption. The system may modify not only the candidate solution but also parts of the machinery that generates and evaluates future candidates:
\[(S_{t+1},E_{t+1},H_{t+1}) = \operatorname{Improve}(S_t,E_t,H_t)\]
- where \(H_t\) denotes the system’s harness, search procedure, tools, memory, orchestration, or other improvement infrastructure.
The distinction is subtle but fundamental. Bounded optimization asks:
\[\text{"How can I score better under }E\text{?"}\]
Open-ended self-improvement can additionally ask:
\[\text{"How should I search, learn, evaluate, and improve in the next iteration?"}\]
The latter begins to make the improvement procedure itself an optimization target. Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) uses precisely this distinction to separate convergent, externally evaluable refinement from the more ambitious case in which the system can modify the criteria or machinery responsible for improvement.

A Complementary Autonomy-Centered View

A second taxonomy asks a different question: not only what changes, but which decisions in the improvement loop have become endogenous to the AI system. The Last AI Built by Humans: Toward Genuine Recursive Self-Improvement by Duan et al. (2026) treats the complete improvement loop as the unit of analysis and defines RSI as persistent self-change in which inherited changes can affect how later improvements are generated, evaluated, selected, or consolidated. This complements the object-of-improvement taxonomy above because two systems may modify the same artifact while differing substantially in how much responsibility they assume for deciding what to improve and how.
The paper decomposes an improvement loop into the AI system, persistent system state, experience, target, improver, strategy, verifier, accepted improvement, and successor. In compact form:
\[S_t \xrightarrow{\text{experience}} I_t \xrightarrow{\text{strategy}} \Delta S_t \xrightarrow{\text{verifier}} S_{t+1}\]
- where an accepted change becomes part of the state inherited by the successor. The key RSI question is whether the successor merely contains a better artifact or also inherits a better mechanism for producing later improvements.
This leads to three recurring diagnostic questions:
Where does the improvement loop close?
What state is updated and inherited across rounds?
Which improvement decisions remain externally controlled?
These questions distinguish ordinary automation from recursive improvement. A system may automate substantial engineering work while leaving its search procedure, evaluator, task distribution, and acceptance rule fixed. Conversely, a narrower system can exhibit genuine structural recursion if it persistently revises one of those mechanisms and the revised mechanism governs a later improvement round.

Autonomy Levels from Execution to Meta-Improvement

Duan et al. organize RSI into a baseline and five autonomy levels. The levels describe the progressive internalization of responsibility for the improvement process rather than raw model capability:

Level Internalized responsibility Persistent effect ———————– —————————————— —————————————————————————————————————————————————– B0 In-task refinement only Output changes, but no persistent system change

L1 Improvement execution AI carries out a human-specified improvement procedure
L2 Improvement strategy AI diagnoses weaknesses and selects how to improve under a fixed objective and evaluator
L3 Experience acquisition AI determines what data, tasks, interactions, or practice it needs for the next update
L4 Deployment adaptation AI decides which consequences of deployment experience should persist in memory, skills, harnesses, code, or parameters

L5 Recursive inheritance / meta-improvement AI revises and reuses mechanisms that govern subsequent improvement, such as improvers, evaluators, search policies, or research-control procedures
The progression can be summarized as
\[\text{B0} \rightarrow \text{L1 execution} \rightarrow \text{L2 strategy} \rightarrow \text{L3 experience} \rightarrow \text{L4 adaptation} \rightarrow \text{L5 meta-improvement}\]
At L1, humans still specify the target, method, and success criterion while the AI executes the update. At L2, the system can diagnose a weakness and choose an intervention, but the objective and evaluation boundary remain externally supplied. At L3, the system additionally controls the acquisition of future learning experience, such as generating tasks near its capability frontier or deciding which interactions would be most informative. At L4, deployment outcomes can change persistent state, allowing later tasks to inherit memories, skills, tools, harness changes, code changes, or parameter updates.
L5 is the most direct bridge to recursive self-improvement. It begins when the mechanism responsible for future improvement becomes an editable and inheritable target:
\[I_{t+1} = \operatorname{Improve}(I_t;\mathcal{E}_t)\]
- followed by
  \[S_{t+2} = I_{t+1}(S_{t+1},\mathcal{E}_{t+1})\]
The second expression is essential. Merely producing a modified improver is insufficient; the revised improver must actually participate in a later improvement round. The same principle applies to evaluators, research policies, successor-generation procedures, and other meta-level components.
The following figure (The Last AI Built by Humans: Toward Genuine Recursive Self-Improvement) shows how the improvement loop expands from execution autonomy through strategy selection, experience acquisition, deployment adaptation, and finally recursive inheritance of the improvement mechanism itself.

Structural Recursion versus Effective Recursion

An important refinement is the distinction between structural and effective recursion.
Structural recursion asks whether a revised improvement mechanism is retained and invoked in a later round:
\[I_t \rightarrow I_{t+1} \rightarrow S_{t+1} \rightarrow I_{t+1}(S_{t+1})\]
Effective recursion imposes a stronger requirement: the inherited mechanism must produce better successors under comparable resources and independent evaluation. If \(Q\) measures externally assessed successor quality and \(B\) denotes the improvement budget, the relevant comparison is not merely
\[Q(S_{t+1}) > Q(S_t)\]
- but whether
  \[Q\!\left(I_{t+1}(S;B)\right) > Q\!\left(I_t(S;B)\right)\]
  - for comparable starting states and budgets.
This distinction prevents a common category error. Better task performance can demonstrate that a candidate system improved, but it does not by itself demonstrate that the process for producing future improvements became better. Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents by Zhang et al. (2025), for example, evolves and retains coding-agent variants, but its archive management and parent-selection procedure remain external to self-modification. By contrast, Gödel Agent: A Self-Referential Agent Framework for Recursive Self-Improvement by Yin et al. (2024) exposes both task behavior and recursive update logic to modification, making the improvement procedure itself part of the inherited state.
Self-Taught Optimizer (STOP): Recursively Self-Improving Code Generation by Zelikman et al. (2023) provides another direct example: an improver program receives its own source code as an optimization target, generates successor improvers, and evaluates them by the downstream programs they produce. This makes the search procedure itself the object of recursive improvement, while the task distribution, utility function, base model, and resource limits remain externally specified.

Safe Inheritance, Attribution, and Verification

The autonomy hierarchy also sharpens what evidence is required for an RSI claim. Duan et al. identify three recurring issues.
First, persistent inheritance can propagate regressions as well as improvements. An accepted modification can affect many later decisions before its weakness becomes visible. Reliable RSI therefore requires versioned state, transfer evaluation, regression testing, and rollback rather than assuming that persistence implies progress.
Second, autonomy must be attributed to the component that actually made the improvement decision. If candidate generation is model-driven but parent selection, evaluator design, promotion thresholds, or task construction remain fixed, those parts of the loop should remain classified as external. A useful representation is an autonomy vector:
\[A = (A_{\text{execute}}, A_{\text{strategy}}, A_{\text{experience}}, A_{\text{adapt}}, A_{\text{meta}})\]
- rather than a single binary label of “autonomous” or “not autonomous.”
Third, verification must remain credible under repeated optimization. If the system can repeatedly query or modify its evaluator, improvements in score may reflect exploitation or changing standards rather than increased capability. The paper therefore motivates protected evaluation, matched computational budgets, independent anchors, and explicit provenance for evaluator changes.
These requirements yield a stronger operational criterion for recursive progress:
\[\text{credible RSI} = \text{persistent inheritance} + \text{attributable autonomy} + \text{independent verification} + \text{mechanism reuse}\]

Measuring Recursive Improvement Across Generations

For L5 systems, evaluation should measure trajectories rather than only endpoints. The Last AI Built by Humans: Toward Genuine Recursive Self-Improvement by Duan et al. (2026) proposes evaluating adaptivity, retention, transfer, efficiency, stability, and meta-recursion. This can be represented as
\[\mathcal{M} = ( G, R, T, C, S, M )\]
- where \(G\) is improvement gain or trajectory, \(R\) retention of prior capabilities, \(T\) transfer to held-out tasks or domains, \(C\) resource cost, \(S\) stability across updates, and \(M\) evidence that the revised improvement mechanism is reused and produces stronger successors.
This framing is particularly useful for distinguishing recursive amplification from additional search. A system that obtains better results by spending more tokens or running more candidate trials has improved its outcome, but has not necessarily improved its improvement efficiency. Stronger evidence compares original and revised mechanisms under matched total budgets and independent evaluation:
\[\eta_t = \frac{\text{validated capability gain}_t} {\text{compute}_t+\lambda_H\text{human effort}_t}\]
Evidence for effective recursive improvement requires demonstrating that inherited changes increase this improvement productivity across later rounds, rather than merely increasing the resources consumed by the loop.

Axis I: What Is Being Improved?

A practical taxonomy begins by identifying the object of improvement. Four major categories capture most current approaches:
\[\mathcal{I} = \{ \text{deployment behavior}, \text{trained policy}, \text{evaluator}, \text{research process} \}\]
These categories should not be interpreted as mutually exclusive. A sufficiently sophisticated system may operate across all four simultaneously.
The following figure (Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops) shows the two-axis taxonomy of self-improvement methods, organized by what component is improved and how completely the corresponding improvement loop is closed.

Deployment-Time Self-Evolution

Deployment-time self-evolution improves the behavior of an already deployed system. The base model may remain frozen, or some parameters may be adapted temporarily, while the system modifies its outputs, context, memory, tools, skills, or harness.
The simplest instance is iterative output refinement:
\[y_0 \sim \pi_\theta(\cdot \mid x)\] \[f_t = \operatorname{Critique}_{\theta}(x,y_t)\] \[y_{t+1} \sim \pi_\theta(\cdot \mid x,y_t,f_t)\]
Here \(\theta\) remains fixed. Improvement occurs entirely through additional computation and context. Self-Refine: Iterative Refinement with Self-Feedback by Madaan et al. (2023) is a canonical example: one model acts as generator, feedback provider, and refiner, with no additional supervised training or reinforcement learning.
A stronger variant adds an external verifier:
\[r_t = V(y_t)\] \[y_{t+1} \sim \pi_\theta(\cdot \mid x,y_t,r_t)\]
For code, \(V\) might execute unit tests. For mathematics, it might check a symbolic result. For retrieval, it might compare claims against external documents. External verification is important because purely intrinsic critique can correlate with the same errors that generated the original answer.
The persistence of deployment-time improvements varies substantially. Output refinement disappears when the episode terminates. Memory can persist across sessions. Learned skills and agent scaffolding can persist indefinitely. This creates a progression:
\[\text{output refinement} \rightarrow \text{test-time adaptation} \rightarrow \text{memory/skill accumulation} \rightarrow \text{harness evolution}\]
At the far end, the agent begins modifying the software that determines how it behaves. The distinction between “using an AI system” and “improving the AI system” consequently becomes increasingly blurred.

Harness and Agent Self-Modification

For modern agents, the effective policy is not merely the underlying neural network. It can be approximated as
\[\pi_{\text{agent}} = F( \pi_\theta, P, T, M, R, O )\]
- where \(P\) represents prompts, \(T\) tools, \(M\) memory, \(R\) retrieval or skill resources, and \(O\) orchestration logic.
Improving any of these components can improve the effective agent without retraining \(\theta\). This makes harness optimization one of the most concrete contemporary forms of self-modification.
An agent might, for example:
1. identify repeated failure patterns; 2. generate a new tool or reusable skill; 3. add tests for the new component; 4. evaluate the modified harness on held-out tasks; 5. retain the modification if performance improves; 6. use the improved harness to generate the next modification.
The loop can be expressed as
\[H_{t+1} = \arg\max_{H'\in\mathcal{N}(H_t)} E(\pi_\theta,H')\]
- where \(\mathcal{N}(H_t)\) is a set of candidate modifications generated from the current harness.
Gödel Agent: A Self-Referential Agent Framework for Recursive Self-Improvement by Yin et al. (2024) makes the agent’s own logic part of this search space, while Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents by Zhang et al. (2025) maintains an archive of empirically evaluated agent modifications rather than requiring each modification to be formally proven beneficial. These systems are especially relevant to RSI because a successful change persists into the machinery responsible for producing later changes.

Training-Time Self-Iteration

Training-time self-iteration moves improvement into model parameters. Instead of merely producing a better answer, the system produces information that becomes training signal for its successor.
A generic loop is
\[D_t^{\text{self}} = G(M_t)\] \[\tilde{D}_t = \operatorname{Filter} (D_t^{\text{self}},E_t)\] \[M_{t+1} = \operatorname{Train} (M_t,\tilde{D}_t)\]
The critical difference from test-time refinement is persistence:
\[\theta_t \rightarrow \theta_{t+1}\]
STaR: Bootstrapping Reasoning With Reasoning by Zelikman et al. (2022) provides an early example. The model generates rationales, successful rationales become training data, the model is fine-tuned on them, and the process repeats. Thus, reasoning produced by one iteration contributes directly to the capabilities of the next.
The general pattern is broader than reasoning traces. A model can generate:
\[\begin{aligned} &\text{synthetic examples},\\ &\text{solutions},\\ &\text{rationales},\\ &\text{preferences},\\ &\text{criticisms},\\ &\text{reward signals},\\ &\text{adversarial tasks},\\ &\text{curricula}. \end{aligned}\]
Each moves some portion of the training-data production pipeline from humans to the model itself.

Self-Reward and Self-Evaluation

Self-generated training data still requires a mechanism for distinguishing useful data from errors. This makes evaluation a separate and particularly important axis of self-improvement.
Suppose a policy generates candidates
\[y_i \sim \pi_{\theta_t}(y\mid x)\]
An evaluator assigns
\[r_i=E_{\phi_t}(x,y_i)\]
The policy is then updated using these rewards:
\[\theta_{t+1} = \operatorname{Update} (\theta_t,\{(x,y_i,r_i)\})\]
Conventional RLHF places humans upstream of \(E_{\phi}\). Self-rewarding approaches increasingly move evaluation into the model itself.
Self-Rewarding Language Models by Yuan et al. (2024) uses the language model itself as an LLM judge to produce preference signals for iterative DPO, so that the model participates both in producing candidate behavior and in generating the reward signal used for subsequent training. The work is particularly relevant to RSI because the authors explicitly motivate improvement along two coupled axes: instruction-following capability and the ability to generate increasingly useful rewards.
Conceptually, this introduces a coupled dynamical system:
\[\theta_{t+1}=F(\theta_t,\phi_t)\] \[\phi_{t+1}=G(\phi_t,\theta_{t+1})\]
- where \(\theta\) parameterizes the policy and \(\phi\) parameterizes the evaluator.
If both improve together, the evaluator can provide increasingly sophisticated supervision as the policy becomes more capable. This is potentially more powerful than optimizing against a permanently frozen reward model.
It is also substantially harder to validate. If evaluator and policy share systematic errors, the two components can reinforce those errors rather than correct them. Consequently, evaluator improvement is not merely another self-improvement technique. It determines whether improvement measured elsewhere in the loop corresponds to actual progress.

Self-Play and Curriculum Generation

Another route removes externally supplied tasks rather than externally supplied rewards.
Ordinary training assumes a task distribution
\[x \sim p_{\text{human}}(x)\]
Self-play allows the system to construct part of its own curriculum:
\[x_t \sim q_{\phi_t}(x\mid \pi_{\theta_t})\]
- where a proposer generates tasks targeted at the current solver.
The solver then learns from those tasks:
\[\theta_{t+1} = \operatorname{Train} (\theta_t,x_t,r_t)\]
As the solver improves, the proposer can generate harder problems:
\[q_{\phi_t} \rightarrow q_{\phi_{t+1}}\]
The resulting interaction can produce an automatically advancing curriculum. This principle has deep precedents in game-playing systems, but recent language-model work extends it to general reasoning. Absolute Zero: Reinforced Self-play Reasoning with Zero Data by Zhao et al. (2025), for example, explores a proposer-solver setup in which reasoning tasks and learning signals emerge through self-play without starting from a conventional curated reasoning dataset. The RSI survey treats zero-data self-play as an important training-time mechanism because both the curriculum and solver increasingly originate within the loop.
Self-play is nevertheless not synonymous with open-ended RSI. If the environment, reward, task grammar, and optimization algorithm remain fixed, the system still operates inside a human-designed optimization envelope. It may discover increasingly sophisticated behavior without modifying the machinery that defines what improvement means.

Automated Research

The deepest current category moves from optimizing a model or agent to optimizing the research process that produces models and algorithms.
An automated research loop can be abstracted as
\[h_t = \operatorname{Propose}(K_t)\] \[e_t = \operatorname{DesignExperiment}(h_t)\] \[z_t = \operatorname{Execute}(e_t)\] \[c_t = \operatorname{Interpret}(z_t)\] \[K_{t+1} = \operatorname{UpdateKnowledge}(K_t,c_t)\]
- followed by another hypothesis:
  \[K_{t+1}\rightarrow h_{t+1}\]
Here \(K_t\) represents the accumulated research state, including previous hypotheses, experiments, failures, measurements, code, and conclusions.
Systems such as The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery by Lu et al. (2024) attempt to automate much of this scientific pipeline, while systems such as FunSearch and AlphaEvolve focus more tightly on automatically generating and evaluating algorithmic discoveries. The key RSI-relevant transition occurs when the output of automated research modifies the AI-development machinery itself.
For example:
\[M_t \rightarrow \text{AI researcher} \rightarrow \text{better training algorithm} \rightarrow M_{t+1}\]
If
\[M_{t+1}\]
- is consequently a better AI researcher than
  \[M_t\]
  - the process has acquired the defining recursive dependency.

Axis II: Degree of Loop Closure

The second major dimension asks who controls the improvement cycle.
A useful continuum is
\[\text{human-in-the-loop} \rightarrow \text{human-on-the-loop} \rightarrow \text{AI-closed loop}\]
These categories refer not to whether humans created the original system, but to how much human intervention is required for each additional improvement cycle.

Human-in-the-Loop

In a human-in-the-loop system, a person supplies information necessary for each iteration:
\[S_t \xrightarrow{\text{AI proposal}} P_t \xrightarrow{\text{human judgment}} J_t \xrightarrow{\text{update}} S_{t+1}\]
Examples include human preference labeling, manual code review, researcher-selected experiments, manually designed reward functions, and human approval of proposed modifications.
AI may dramatically increase researcher productivity in this regime, but the improvement loop cannot continue autonomously because human judgment lies directly on the critical path.

Human-on-the-Loop

Human-on-the-loop systems allow AI to execute most of the cycle while humans supervise, audit, or approve consequential steps:
\[S_t \rightarrow P_t \rightarrow E_t \rightarrow S_{t+1}\]
- with human intervention primarily when
  \[\operatorname{Risk}(P_t)>\tau\]
  - or
    \[\operatorname{Confidence}(E_t)<\gamma\]
This architecture can support far higher throughput because human attention is allocated selectively rather than required for every operation.
Many plausible near-term automated research systems naturally fall into this category. Agents can implement code, launch experiments, inspect metrics, and propose follow-ups while humans determine research direction, review ambiguous evidence, authorize expensive training runs, and adjudicate uncertain conclusions.

Closed Improvement Loops

A fully closed loop removes routine human intervention from the causal chain connecting one system generation to the next:
\[S_t \rightarrow \text{research} \rightarrow \text{design} \rightarrow \text{implementation} \rightarrow \text{evaluation} \rightarrow \text{training} \rightarrow S_{t+1}\]
For genuine recursive self-improvement, the resulting system must then be able to initiate the process again:
\[S_{t+1} \rightarrow S_{t+2} \rightarrow S_{t+3} \rightarrow\cdots\]
The important property is therefore not automation of one research run, but autonomous re-entry into the improvement cycle.
When AI builds itself describes this as “closing the loop”: the transition from AI assisting researchers to AI systems increasingly performing the work necessary to build successor AI systems. This framing also highlights why coding autonomy alone does not close the loop. Research direction-setting, evaluation, training infrastructure, experimental interpretation, and decisions about which modifications should propagate into the next generation must also be addressed.

Persistence as a Third Practical Dimension

Although the two-axis taxonomy captures much of the landscape, persistence provides another useful engineering distinction.
Let \(\tau_I\) denote the lifetime of an improvement. Different mechanisms occupy dramatically different timescales:
\[\tau_{\text{output}} < \tau_{\text{context}} < \tau_{\text{memory}} < \tau_{\text{harness}} < \tau_{\text{weights}} < \tau_{\text{algorithm}}\]
A corrected answer may survive for seconds. A memory may persist for months. A weight update persists until the model is replaced. A better training algorithm may affect multiple future model generations.
The following figure (Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops) shows deployment-time self-evolution ordered by persistence: refined outputs disappear with the episode, test-time adaptations persist longer, and harness or skill modifications can accumulate across future episodes.

Persistence matters because recursion requires information to survive long enough to influence future improvement cycles. A system can expend arbitrarily large amounts of test-time compute without recursively improving if every useful discovery disappears when the context window closes.
A basic requirement for cumulative self-improvement is therefore
\[I_t \rightarrow \mathcal{M}_{t+1}\]
- where \(I_t\) is information learned during iteration \(t\) and \(\mathcal{M}_{t+1}\) is some persistent substrate accessible during the next iteration.
That substrate could be model weights, source code, external memory, a skill library, an experiment database, a research notebook, improved prompts, evaluation suites, or training infrastructure. What matters is that later systems inherit useful discoveries rather than repeatedly rediscovering them.

A Unified View of the RSI Stack

Combining improvement target, loop closure, and persistence gives a more precise picture of progress toward RSI.
At one extreme is ephemeral self-refinement:
\[\text{fixed model} + \text{fixed evaluator} + \text{temporary improvement} + \text{fixed improvement procedure}\]
At the other is open-ended recursive improvement:
\[\text{modifiable system} + \text{modifiable improvement process} + \text{persistent knowledge} + \text{autonomous evaluation} + \text{successor generation}\]
The intermediate space contains most current research:

Regime Primary object improved Persistent? Evaluator Typical loop closure ————————- ———————————– ————- ———————————— ———————- Output refinement Response No Model or external feedback Low

Test-time adaptation Temporary policy/state Partially Task feedback Low to medium
Memory/skill evolution Agent knowledge/harness Yes Environment or benchmark Medium
Self-training Model weights Yes Filter/verifier Medium
Self-reward learning Policy + reward signal Yes Model-generated judgment Medium
Self-play Policy + curriculum Yes Environment/verifier Medium to high
Agent self-modification Harness/source code Yes Benchmarks/verifiers High
Automated AI research Improvement process Yes Experiments + evaluators Potentially high

Full RSI Entire successor-generation stack Yes Endogenous + grounded verification Closed
This spectrum clarifies why “AI improving AI” is already real without implying that full RSI has been achieved. Several individual links of the recursive chain exist today. The open technical problem is whether those links can be composed while preserving reliability, cumulative progress, generality, and sufficient external grounding.
A compact way to express the transition is
\[\boxed{ \text{Refinement} \rightarrow \text{Learning} \rightarrow \text{Self-evaluation} \rightarrow \text{Self-modification} \rightarrow \text{Auto-research} \rightarrow \text{Loop closure} }\]
The important quantity is not simply how autonomous any individual stage becomes. It is whether the output of one improvement cycle increases the system’s capacity to execute the next cycle. That recursive dependency separates increasingly powerful automation from recursive self-improvement proper.

Deployment-Time Self-Evolution

Deployment-time self-evolution improves an AI system while it is being used, rather than waiting for a conventional offline training cycle. It spans a spectrum from ephemeral output revision to persistent modification of an agent’s memory, skills, tools, prompts, and executable scaffolding. This makes it one of the most immediately realizable forms of self-improvement: the deployed system can observe its own failures, obtain feedback, generate candidate corrections, evaluate them, and sometimes retain successful changes for future tasks.
Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) separates deployment-time self-evolution into output refinement, test-time training, and harness or skill evolution. The central distinction among them is persistence. Output refinement changes the current artifact, test-time training can alter model state for a query or session, and harness evolution can preserve improvements across future episodes.
A useful abstraction is
\[S_{t+1} = U(S_t,x_t,f_t)\]
- where \(S_t\) is the deployed system state, \(x_t\) is the current task, \(f_t\) is feedback obtained while solving the task, and \(U\) is an update mechanism. Deployment-time self-evolution becomes increasingly RSI-like as \(S_{t+1}\) persists, generalizes beyond \(x_t\), and improves the system’s ability to perform future updates.

The simplest deployment-time loop keeps the underlying model fixed and recursively improves its output.
Given an input \(x\), a model first produces
\[y_0 \sim \pi_\theta(y\mid x)\]
A critic then generates feedback
\[f_t = C_\theta(x,y_t)\]
- and a refinement step produces
  \[y_{t+1} \sim R_\theta(y\mid x,y_t,f_t)\]
The process repeats until a stopping condition is reached:
\[\operatorname{Stop}(y_t,f_t)=1\]
Self-Refine: Iterative Refinement with Self-Feedback by Madaan et al. (2023) provides a canonical implementation of this pattern. The same LLM can serve as generator, feedback provider, and refiner, without supervised fine-tuning or reinforcement learning. The method therefore demonstrates self-improvement at inference time while leaving the underlying parameters unchanged.
The implementation can be represented as a three-stage loop:
\[\text{GENERATE} \rightarrow \text{FEEDBACK} \rightarrow \text{REFINE} \rightarrow \text{FEEDBACK} \rightarrow\cdots\]
The feedback should ideally be actionable rather than merely scalar. Instead of returning
\[f_t=0.6\]
- a critic can identify concrete deficiencies such as an unsupported claim, an inefficient algorithm, an unmet constraint, or a missing reasoning step. The refinement model can then condition directly on these defects.
For example, a coding agent might receive
\[f_t= \{ \text{test 4 fails}, \text{runtime exceeds limit}, \text{edge case }n=0\text{ unhandled} \}\]
- rather than a single reward. This converts evaluation into information that can guide the next search step.

Why Self-Critique Alone Is Limited

A self-refinement loop contains an important statistical dependency: the generator and critic may share the same blind spots.
Suppose the true quality of an output is
\[Q(y)\]
- but the model can observe only its internal estimate
  \[\hat{Q}_\theta(y)\]
Refinement optimizes
\[y^* = \arg\max_y \hat{Q}_\theta(y)\]
- not necessarily
  \[y^* = \arg\max_y Q(y)\]
If
\[\hat{Q}_\theta(y)\approx Q(y)\]
- self-refinement can work well. If the model systematically misjudges some property, however, repeatedly querying the same judgment mechanism does not guarantee correction.
This creates a distinction between generating alternatives and knowing which alternative is actually better. A model may be capable of producing a correct solution while still being unable to reliably distinguish it from an incorrect one.
For deployment-time self-improvement, evaluator quality therefore often matters more than the mere number of refinement iterations.

The refinement loop becomes considerably stronger when the evaluator receives information independent of the model’s own judgment.
Let
\[V(y,x,e)\rightarrow r\]
- be a verifier operating on candidate \(y\), task \(x\), and external evidence \(e\). Refinement then becomes
  \[y_{t+1} \sim \pi_\theta ( y\mid x,y_t,V(y_t,x,e) )\]
External evidence can take several forms:
\[e \in \{ \text{compiler output}, \text{unit tests}, \text{formal proofs}, \text{environment observations}, \text{retrieved documents}, \text{simulator results}, \text{experimental measurements} \}\]
The distinction is important because these signals can reveal information unavailable through introspection.
For coding tasks, the loop might be
\[\text{write code} \rightarrow \text{compile} \rightarrow \text{run tests} \rightarrow \text{inspect failures} \rightarrow \text{patch code}\]
For an embodied agent:
\[\text{plan} \rightarrow \text{act} \rightarrow \text{observe environment} \rightarrow \text{update plan}\]
For retrieval-grounded reasoning:
\[\text{answer} \rightarrow \text{extract claims} \rightarrow \text{retrieve evidence} \rightarrow \text{identify unsupported claims} \rightarrow \text{revise}\]
This leads to a general engineering principle for self-improving systems:
\[\boxed{ \text{Generate internally, verify externally whenever possible.} }\]
The stronger the verifier, the more aggressively the system can search. When candidate quality can be evaluated cheaply and reliably, the model can generate many possibilities without requiring every generation to be correct.

Search Over Candidate Solutions

Once evaluation is available, deployment-time self-improvement need not follow a single linear refinement trajectory.
Instead of
\[y_0\rightarrow y_1\rightarrow y_2\rightarrow y_3\]
- the system can generate a population
  \[\mathcal{Y}_t = \{y_t^{(1)},y_t^{(2)},\ldots,y_t^{(K)}\}\]
Each candidate receives a score
\[r_t^{(i)} = E(y_t^{(i)})\]
- after which the system retains or expands promising candidates:
  \[\mathcal{Y}_{t+1} = \operatorname{SelectAndExpand} ( \mathcal{Y}_t, \{r_t^{(i)}\}_{i=1}^{K} )\]
This converts refinement into search.
The search procedure can take several forms, including best-of-\(N\) sampling, beam-style search, tree search, evolutionary selection, or repeated mutation of an incumbent solution. The underlying principle is the same:
\[\text{proposal distribution} + \text{reliable evaluator} + \text{search budget}\]
Increasing inference compute can then improve performance even if the base model remains unchanged.
This distinction becomes important for RSI because an improvement in the search procedure itself can improve every subsequent inference episode. If the system discovers that a different branching strategy, critic prompt, tool sequence, or candidate-selection mechanism works better, preserving that discovery moves the system from output refinement toward harness evolution.

Test-Time Training

Output refinement changes the context or generated artifact but leaves model parameters fixed. Test-time training instead adapts model state during deployment.
Test-Time Training with Self-Supervision for Generalization under Distribution Shifts by Sun et al. (2020) introduced a general framework in which an unlabeled test example is converted into a self-supervised learning problem and model parameters are updated before prediction, demonstrating that adaptation can occur after deployment rather than exclusively during offline training.
Suppose the deployed model has parameters \(\theta_t\). Given test input \(x_t\), an auxiliary self-supervised objective produces
\[\mathcal{L}_{\text{TTT}} ( \theta_t;x_t )\]
The model performs an update
\[\theta_t' = \theta_t - \eta \nabla_\theta \mathcal{L}_{\text{TTT}} ( \theta_t;x_t )\]
- and prediction is made using
  \[y_t \sim \pi_{\theta_t'}(y\mid x_t)\]
The important conceptual transition is
\[\text{inference} \rightarrow \text{learning during inference}\]
For RSI, however, test-time adaptation becomes more significant when the update survives beyond a single example.
If parameters are reset after each query,
\[\theta_{t+1}=\theta_0\]
- the improvement is ephemeral.
If updates accumulate,
\[\theta_{t+1}=\theta_t'\]
- deployment becomes an online learning process.
This creates a direct bridge from test-time computation to persistent self-improvement.

Persistent Memory as Self-Improvement

Not every persistent update needs to modify neural-network parameters. External memory can serve as a lower-cost and more auditable persistence mechanism.
Let an agent maintain memory
\[M_t = \{m_1,m_2,\ldots,m_n\}\]
After completing task \(x_t\), it extracts reusable information
\[m_{n+1} = G(x_t,\tau_t,r_t)\]
- where \(\tau_t\) is the task trajectory and \(r_t\) its evaluation.
The next system state becomes
\[M_{t+1} = M_t\cup\{m_{n+1}\}\]
Future actions condition on retrieved memories:
\[a \sim \pi_\theta ( a\mid x, \operatorname{Retrieve}(M_{t+1},x) )\]
The agent has therefore changed its future behavior without changing \(\theta\).
The challenge is deciding what deserves to enter persistent memory. Naively storing every trajectory causes memory growth, duplication, contradiction, and retrieval noise. A self-improving memory system therefore needs an admission policy:
\[A(m) = \mathbb{1} [ U(m)>\tau_U \land C(m)>\tau_C ]\]
- where \(U(m)\) estimates future utility and \(C(m)\) estimates confidence.
It may also require consolidation:
\[M_{t+1} = \operatorname{Consolidate} ( M_t\cup\Delta M_t )\]
- which can merge duplicates, resolve conflicts, remove obsolete information, and compress repeated experiences into more general rules.
The result resembles continual learning implemented in an external symbolic or textual substrate.

From Memories to Reusable Skills

A stronger form of persistence converts successful trajectories into executable or declarative skills.
Suppose an agent solves task \(x_t\) through trajectory
\[\tau_t = (a_1,o_1,a_2,o_2,\ldots,a_T,o_T)\]
A skill extractor maps this trajectory to
\[s_t = G_{\text{skill}}(\tau_t)\]
- where \(s_t\) may be a prompt template, procedure, script, tool wrapper, retrieval strategy, or reusable piece of code.
The skill is retained only if validation succeeds:
\[E(s_t;\mathcal{D}_{\text{val}}) > E(H_t;\mathcal{D}_{\text{val}}) + \epsilon\]
It can then be added to the agent’s skill library:
\[\mathcal{S}_{t+1} = \mathcal{S}_t\cup\{s_t\}\]
Future tasks retrieve appropriate skills:
\[s^* = \operatorname{Retrieve} ( \mathcal{S}_{t+1},x )\]
This is more consequential than storing a transcript. A trajectory records what happened once; a skill attempts to extract a reusable transformation that changes how future tasks are solved.
The progression is therefore
\[\text{experience} \rightarrow \text{reflection} \rightarrow \text{abstraction} \rightarrow \text{skill} \rightarrow \text{reuse}\]
If successful reuse produces further skills, the process becomes cumulative.

Harness Evolution

The most persistent form of deployment-time self-evolution changes the agent’s own scaffolding.
A contemporary agent can be represented as
\[A_t = ( M, P_t, T_t, \mathcal{S}_t, \mathcal{M}_t, O_t )\]
- where \(M\) is the base model, \(P_t\) prompts and policies, \(T_t\) tools, \(\mathcal{S}_t\) skills, \(\mathcal{M}_t\) memory, and \(O_t\) orchestration code.
The base model may remain fixed:
\[M_{t+1}=M_t\]
- while the effective system changes substantially:
  \[A_{t+1} \neq A_t\]
This is important because the behavior of an agent is determined by the entire system, not merely its neural weights.
Harness evolution turns these components into a search space:
\[h = (P,T,\mathcal{S},\mathcal{M},O)\]
The system generates candidate modifications
\[h_t^{(i)} \sim G(h_t,\mathcal{H}_t)\]
- where \(\mathcal{H}_t\) contains previous experiments and observations.
Each candidate is evaluated:
\[r_t^{(i)} = E(h_t^{(i)};\mathcal{B})\]
- where \(\mathcal{B}\) is an evaluation suite.
The accepted harness becomes
\[h_{t+1} = \arg\max_{h_t^{(i)}}r_t^{(i)}\]
Crucially, the next search begins from \(h_{t+1}\) rather than the original harness.
The recursion is therefore
\[h_t \xrightarrow{\text{agent}} h_{t+1} \xrightarrow{\text{improved agent}} h_{t+2}\]
This is qualitatively different from repeatedly asking a frozen agent to solve harder problems.

Gödel Agent and Self-Referential Modification

Gödel Agent: A Self-Referential Agent Framework for Recursive Self-Improvement by Yin et al. (2024) explicitly makes the agent’s own logic and behavior available for modification rather than restricting optimization to a predefined set of manually selected components. The framework uses LLMs to propose modifications under high-level objectives, allowing the agent implementation itself to become part of the optimization space.
The underlying shift is from optimizing parameters inside a fixed algorithm,
\[\theta^* = \arg\max_\theta E(A(\theta))\]
- to searching over implementations:
  \[A^* = \arg\max_{A'\in\mathcal{A}} E(A')\]
Here \(\mathcal{A}\) can contain agents with different prompts, tool-use strategies, memory systems, reasoning procedures, control flows, or source-code modifications.
This dramatically expands the search space.
A fixed optimization algorithm specifies
\[A_{t+1} = U(A_t)\]
- where \(U\) is immutable.
A self-referential agent can, in principle, modify both:
\[(A_{t+1},U_{t+1}) = F(A_t,U_t)\]
This is much closer to the conceptual structure of RSI because the mechanism responsible for improvement can itself become an object of improvement.

Darwin Gödel Machine and Empirical Self-Modification

The classical Gödel-machine formulation places an exceptionally strong requirement on self-modification: the system should prove that a proposed rewrite increases expected utility before executing it. For contemporary AI agents, obtaining such proofs for meaningful software modifications is generally impractical.
Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents by Zhang et al. (2025) replaces this proof requirement with empirical validation. A foundation model proposes modifications to coding agents, the resulting agents are evaluated on coding benchmarks, and successful variants enter a growing archive. The paper reports improvements from \(20.0\%\) to \(50.0\%\) on SWE-bench and from \(14.2\%\) to \(30.7\%\) on Polyglot within its experimental setup.
Rather than maintaining only one incumbent,
\[A_0\rightarrow A_1\rightarrow A_2\rightarrow\cdots\]
- the Darwin Gödel Machine maintains an archive
  \[\mathcal{A}_t = \{A_1,A_2,\ldots,A_n\}\]
An agent is selected:
\[A_i \sim P_{\text{select}}(\mathcal{A}_t)\]
- a modification is proposed:
  \[A' = \operatorname{Modify}(A_i)\]
  - and the candidate is evaluated:
    \[r' = E(A')\]
Promising candidates are added:
\[\mathcal{A}_{t+1} = \mathcal{A}_t\cup\{A'\}\]
This tree-like structure matters because self-improvement is not guaranteed to follow a single monotonic path. A modification that appears mediocre now may contain a useful stepping stone for a later branch. Maintaining diversity preserves alternative evolutionary trajectories.
The following figure (Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents) illustrates the open-ended self-improvement process in which coding agents modify existing agents, evaluate the resulting variants, and accumulate successful variants in an archive that supplies starting points for subsequent generations.

Why Persistence Changes the Nature of the Loop

The defining difference among these deployment-time mechanisms is what survives the current episode.
For output refinement,
\[S_{t+1}=S_t\]
- after the interaction ends.
For memory evolution,
\[M_{t+1}=M_t+\Delta M_t\]
For skill evolution,
\[\mathcal{S}_{t+1} = \mathcal{S}_t+\Delta\mathcal{S}_t\]
For harness evolution,
\[H_{t+1} = H_t+\Delta H_t\]
For test-time parameter adaptation,
\[\theta_{t+1} = \theta_t+\Delta\theta_t\]
- if the update is retained.
The following figure (Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops) orders deployment-time mechanisms by persistence, from output-level refinements that vanish after an episode to harness and skill changes that can accumulate across future interactions.

Persistence turns inference into experience.
If a system repeatedly solves tasks but retains nothing,
\[\mathcal{I}_{t+1} = \mathcal{I}_t\]
- where \(\mathcal{I}_t\) denotes persistent information available to the system.
If useful information accumulates,
\[\mathcal{I}_{t+1} = \mathcal{I}_t + \Delta\mathcal{I}_t\]
- then later episodes can begin from a better state than earlier ones.
For RSI, the stronger condition is that accumulated information improves the improvement process itself:
\[\Delta\mathcal{I}_t \rightarrow \operatorname{Improve} ( U_{t+1} )\]
- where \(U_{t+1}\) is the mechanism responsible for generating future updates.
That is the point at which deployment-time learning begins to become recursively self-improving rather than merely adaptive.

An Implementation Architecture for Persistent Deployment-Time Improvement

A practical deployment-time self-improvement system can be organized around a persistent improvement controller.
For each task, the system records
\[z_t = ( x_t, \tau_t, y_t, f_t, r_t )\]
- where \(x_t\) is the task, \(\tau_t\) the execution trajectory, \(y_t\) the result, \(f_t\) structured feedback, and \(r_t\) an external evaluation.
The improvement controller analyzes accumulated failures:
\[F_t = \operatorname{ClusterFailures} ( z_1,\ldots,z_t )\]
It then generates candidate interventions:
\[\Delta_t = \{ \Delta P, \Delta T, \Delta M, \Delta S, \Delta O \}\]
- corresponding to prompt, tool, memory, skill, and orchestration changes.
Every modification should be tested against a validation suite:
\[\Delta^* = \arg\max_{\Delta\in\Delta_t} \left[ E(H_t+\Delta;\mathcal{D}_{\text{val}}) - E(H_t;\mathcal{D}_{\text{val}}) \right]\]
A modification is committed only when its estimated improvement exceeds a threshold:
\[H_{t+1} = \begin{cases} H_t+\Delta^*, & \Delta E>\epsilon,\\ H_t, & \text{otherwise}. \end{cases}\]
A stronger implementation would additionally require regression constraints:
\[E_k(H_{t+1}) \ge E_k(H_t)-\delta_k \qquad \forall k\]
- where each \(E_k\) measures a distinct capability, safety property, latency constraint, or cost metric.
This prevents optimization of one benchmark from silently destroying performance elsewhere.
The resulting architecture is
\[\boxed{ \text{Act} \rightarrow \text{Observe} \rightarrow \text{Evaluate} \rightarrow \text{Diagnose} \rightarrow \text{Propose modification} \rightarrow \text{Validate} \rightarrow \text{Commit} \rightarrow \text{Act again} }\]
This structure is already sufficient for meaningful cumulative self-improvement without retraining the foundation model.

The Transition Toward RSI

Deployment-time self-evolution becomes progressively more recursive along three dimensions:
\[\text{persistence} \times \text{scope of modification} \times \text{autonomy}\]
A self-refining response has low persistence, narrow scope, and limited autonomy. A persistent skill-learning agent has greater persistence but still modifies a constrained substrate. A self-referential coding agent can modify much of its own harness. A system that can additionally improve the evaluator and modification algorithm begins to approach open-ended RSI.
The transition can be summarized as
\[\text{better output} \rightarrow \text{better state} \rightarrow \text{better memory} \rightarrow \text{better skills} \rightarrow \text{better harness} \rightarrow \text{better improver}\]
The last transition is the critical one.
A system that produces better answers has improved its outputs. A system that stores useful lessons has improved its future behavior. A system that rewrites its harness has improved part of itself. But a system that improves the machinery responsible for discovering, evaluating, and retaining future improvements has begun to create the recursive dependency at the heart of RSI:
\[\boxed{ \operatorname{Improve}(S_t) \rightarrow S_{t+1} \rightarrow \operatorname{BetterImprove}(S_{t+1}) }\]
Deployment-time self-evolution therefore provides a practical bridge between ordinary inference-time adaptation and recursive self-improvement. The next major step is to move this feedback into the training process itself, where self-generated tasks, reasoning traces, rewards, and curricula can alter the model’s parameters and produce persistent successor policies.

Training-Time Self-Iteration

Training-time self-iteration moves self-improvement from transient inference behavior into the parameters of the model itself. Instead of merely revising an answer or modifying an agent harness, the system generates some portion of the data, reasoning traces, tasks, preferences, rewards, or curricula used to train its successor. This creates a more persistent feedback loop:
\[M_t \rightarrow \text{self-generated experience} \rightarrow \text{selection or reward} \rightarrow \text{training} \rightarrow M_{t+1}\]
The defining property is that information produced by \(M_t\) changes the learned policy of \(M_{t+1}\). Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) groups these mechanisms under training-time self-iteration and distinguishes several increasingly autonomous forms, including self-training from generated reasoning, self-rewarding optimization, self-play, and zero-data curriculum generation.
A general formulation is
\[D_t^{\text{gen}} \sim G(M_t)\] \[D_t^{\text{train}} = F(D_t^{\text{gen}},E_t)\] \[\theta_{t+1} = \operatorname{Train} ( \theta_t, D_t^{\text{train}} )\]
- where \(G\) generates experience, \(E_t\) evaluates it, and \(F\) selects or weights the resulting training examples.
The key RSI question is whether this loop merely extracts more information from a fixed source or whether increasingly capable models can generate increasingly useful training signal:
\[M_t \rightarrow D_t \rightarrow M_{t+1} \rightarrow D_{t+1} \rightarrow M_{t+2}\]
If the quality, difficulty, or diversity of \(D_{t+1}\) improves because \(M_{t+1}\) is stronger than \(M_t\), the training process acquires a recursive component.

Self-Training as the Basic Loop

The simplest form of training-time self-iteration uses the model’s own outputs as training examples.
Let an existing dataset contain inputs
\[\mathcal{X} = \{x_1,\ldots,x_N\}\]
The model generates candidate outputs:
\[\hat{y}_i \sim \pi_{\theta_t}(y\mid x_i)\]
A filtering function retains sufficiently reliable examples:
\[\mathcal{D}_t^+ = \{ (x_i,\hat{y}_i): E(x_i,\hat{y}_i)>\tau \}\]
The next model is trained on these examples:
\[\theta_{t+1} = \arg\min_\theta \left[ -\sum_{(x,y)\in\mathcal{D}_t^+} \log \pi_\theta(y\mid x) \right]\]
This resembles conventional pseudo-labeling, but modern language models can generate much richer supervision than a single label. A generated training record can include an answer, reasoning trajectory, critique, proof, program, preference comparison, tool trace, or complete multi-step interaction.
The self-training loop therefore becomes
\[\text{model} \rightarrow \text{experience generator} \rightarrow \text{training corpus} \rightarrow \text{model}\]
The critical component is the filter. Training indiscriminately on model-generated outputs risks reinforcing errors. Self-training becomes considerably more reliable when generated outputs can be checked using an independent signal.

Bootstrapping Reasoning with STaR

STaR: Bootstrapping Reasoning With Reasoning by Zelikman et al. (2022) provides an influential example of iterative reasoning self-training. STaR starts with a small number of rationale demonstrations, generates rationales for a larger dataset, fine-tunes on rationales associated with successful answers, and repeats the process.
For question \(x_i\), the model generates a rationale \(z_i\) and answer \(y_i\):
\[(z_i,y_i) \sim \pi_{\theta_t}(z,y\mid x_i)\]
If the answer matches the known target,
\[y_i=y_i^*\]
- the rationale can be treated as useful supervision:
  \[(x_i,z_i,y_i) \in \mathcal{D}_{t}^{+}\]
The model is then fine-tuned:
\[\theta_{t+1} = \arg\max_\theta \sum_{(x,z,y)\in\mathcal{D}_{t}^{+}} \log \pi_\theta(z,y\mid x)\]
The improved model subsequently generates a new set of rationales, potentially solving questions that the previous iteration could not.
The loop is therefore
\[\theta_t \rightarrow \text{generate rationales} \rightarrow \text{filter successful reasoning} \rightarrow \theta_{t+1}\]
STaR also uses rationalization for initially incorrect answers: the model is shown the correct answer and asked to generate reasoning leading to it. This expands the set of usable reasoning trajectories beyond those the model could initially generate unaided.
From an RSI perspective, STaR demonstrates a central mechanism: outputs generated by one model generation can become internalized capabilities of the next. However, the task distribution and answer labels remain externally supplied, so the loop is not closed.

Distinguishing Generation from Verification

Training-time self-iteration becomes easier to reason about when generation and verification are treated as separate computational roles.
Let
\[G_{\theta_t}(x)\]
- generate candidate experience and
  \[V_t(x,y)\]
  - evaluate it.
The useful-data distribution is
\[p_t^+(x,y) \propto p_t(x) \pi_{\theta_t}(y\mid x) \mathbb{1} [ V_t(x,y)=1 ]\]
Training then attempts to move the policy toward this filtered distribution.
This decomposition exposes a central asymmetry:
\[\text{generation can be difficult} \qquad \text{while} \qquad \text{verification can be cheap}\]
A model may have a low probability of generating a correct program, proof, or solution, but if correctness can be tested cheaply, the system can sample many candidates and retain the successful ones.
Suppose an independently generated candidate is correct with probability \(p\). With \(N\) samples, the probability of obtaining at least one correct candidate is
\[P(\text{success}) = 1-(1-p)^N\]
When verification is reliable, additional compute can therefore convert a moderately capable generator into a much stronger source of training examples.
This generate-and-verify asymmetry is one of the most important ingredients in scalable self-training.

From Binary Filtering to Reward-Weighted Learning

Generated trajectories need not be classified simply as accepted or rejected. A richer evaluator can assign
\[r_i = E(x_i,y_i)\]
- and training can weight examples according to reward:
  \[\mathcal{L}(\theta) = - \sum_i w(r_i) \log \pi_\theta(y_i\mid x_i)\]
Alternatively, the generated samples can directly define an RL objective:
\[J(\theta) = \mathbb{E}_{ x\sim\mathcal{D}, y\sim\pi_\theta(\cdot\mid x) } [ r(x,y) ]\]
The policy update seeks
\[\theta_{t+1} = \arg\max_\theta J(\theta)\]
This transition is important because it allows the model to learn from relative quality rather than only perfectly correct outputs. But it also increases dependence on the reward function. If the reward is systematically misspecified, stronger optimization can improve reward while degrading the intended capability.
Training-time RSI therefore creates a recurring tradeoff:
\[\text{more autonomous supervision} \quad\Longleftrightarrow\quad \text{greater dependence on evaluator reliability}\]

Self-Rewarding Language Models

A natural next step is to move the evaluator itself inside the model.
Self-Rewarding Language Models by Yuan et al. (2024) uses the language model as an LLM judge to generate preference signals for its own iterative training. The work reports that iterative DPO improves both instruction-following performance and the model’s ability to provide rewards, motivating a coupled loop in which the policy and its feedback mechanism can improve together.
Suppose the current model generates two responses:
\[y_a,y_b \sim \pi_{\theta_t}(\cdot\mid x)\]
The model, operating as a judge, produces a preference
\[y_w \succ y_l\]
These preferences form
\[\mathcal{D}_t^{\text{pref}} = \{ (x,y_w,y_l) \}\]
A DPO-style objective can then update the policy. In simplified form:
\[\mathcal{L}_{\text{DPO}} = - \mathbb{E}_{(x,y_w,y_l)} \left[ \log \sigma \left( \beta \left[ \log \frac{\pi_\theta(y_w\mid x)} {\pi_{\text{ref}}(y_w\mid x)} - \log \frac{\pi_\theta(y_l\mid x)} {\pi_{\text{ref}}(y_l\mid x)} \right] \right) \right]\]
The resulting model becomes
\[M_{t+1} = \operatorname{DPO} ( M_t, \mathcal{D}_t^{\text{pref}} )\]
The recursive possibility appears because \(M_{t+1}\) may be both a stronger policy and a stronger judge:
\[M_t \rightarrow \begin{cases} \text{better responses}\\ \text{better preferences} \end{cases} \rightarrow M_{t+1}\]
If evaluator improvement keeps pace with policy improvement, each generation can potentially provide better supervision for the next.
If it does not, evaluator quality becomes a ceiling.

The Coupled Policy-Evaluator System

More generally, training-time self-improvement can be modeled using separate policy and evaluator parameters:
\[\pi_{\theta_t} \qquad\text{and}\qquad E_{\phi_t}\]
The evaluator trains the policy:
\[\theta_{t+1} = F(\theta_t,\phi_t)\]
- while information from the improved policy can train the evaluator:
  \[\phi_{t+1} = G(\phi_t,\theta_{t+1})\]
This creates the coupled dynamical system
\[(\theta_t,\phi_t) \rightarrow (\theta_{t+1},\phi_{t+1})\]
A favorable trajectory requires both
\[Q_\pi(\theta_{t+1}) > Q_\pi(\theta_t)\]
- and
  \[Q_E(\phi_{t+1}) > Q_E(\phi_t)\]
  - where \(Q_\pi\) measures policy capability and \(Q_E\) evaluator fidelity.
Improving only the policy creates a supervision bottleneck:
\[Q_\pi \uparrow, \qquad Q_E \approx \text{constant}\]
Eventually the evaluator may be unable to distinguish increasingly subtle differences between candidate outputs.
Improving only the evaluator is also insufficient:
\[Q_E \uparrow, \qquad Q_\pi \approx \text{constant}\]
The strongest self-training regime therefore requires co-evolution.

Self-Play Fine-Tuning

Self-play provides another mechanism for generating training signal without repeatedly acquiring stronger external supervision.
Self-Play Fine-Tuning Converts Weak Language Models to Strong Language Models by Chen et al. (2024) introduces SPIN, in which the current model learns by distinguishing responses from previous iterations from responses drawn from the target data distribution; successive iterations can improve performance without requiring additional human-annotated data or feedback from a stronger LLM.
At iteration \(t\), a previous policy
\[\pi_{\theta_t}\]
- acts as an opponent by generating synthetic responses. The next policy is optimized to distinguish these responses from target responses, progressively moving toward the target distribution.
Conceptually:
\[M_t \rightarrow \text{generate opponent responses} \rightarrow \text{self-play objective} \rightarrow M_{t+1}\]
Then
\[M_{t+1}\]
- becomes the opponent used during the next iteration.
The important structural feature is temporal self-play:
\[M_{t+1} \text{ learns against } M_t\]
The system does not require an independently trained stronger model at every iteration. Its previous version becomes part of the training environment for its successor.
However, SPIN still relies on an existing target distribution derived from human demonstrations. It reduces the need for additional supervision rather than eliminating the external anchor entirely.

Curriculum Generation

A more ambitious form of self-iteration asks the model to generate not only answers but also the tasks on which it learns.
Let a proposer generate a task:
\[x \sim q_{\phi_t}(x)\]
A solver attempts the task:
\[y \sim \pi_{\theta_t}(y\mid x)\]
A verifier produces reward:
\[r = V(x,y)\]
The solver update is
\[\theta_{t+1} = \operatorname{RL} ( \theta_t, x,y,r )\]
The proposer is simultaneously trained to generate tasks with high learning value.
The crucial question is how to define that value.
Tasks that are too easy produce little new information:
\[P_{\theta_t}(\text{solve}\mid x)\approx1\]
Tasks that are impossibly difficult may also produce weak learning signals:
\[P_{\theta_t}(\text{solve}\mid x)\approx0\]
Useful curriculum generation therefore tends to target an intermediate region:
\[P_{\theta_t}(\text{solve}\mid x) \in [\alpha,\beta]\]
- for suitable
  \[0<\alpha<\beta<1\]
As the solver improves, this frontier moves. A self-generated curriculum can therefore track the model’s changing capability automatically.

Absolute Zero and Zero-Data Self-Play

Absolute Zero: Reinforced Self-play Reasoning with Zero Data by Zhao et al. (2025) pushes this principle further by eliminating externally supplied reasoning tasks from the training loop. A single model learns both to propose code reasoning tasks that maximize learning progress and to solve them, while a code executor provides verifiable feedback.
The architecture contains three critical components:
\[\text{proposer} + \text{solver} + \text{verifier}\]
The proposer generates
\[x_t \sim q_{\theta_t}(x)\]
- the solver produces
  \[y_t \sim \pi_{\theta_t}(y\mid x_t)\]
  - and the code executor evaluates the interaction:
    \[r_t = V_{\text{exec}}(x_t,y_t)\]
Both task generation and task solving can then be optimized using reinforcement learning.
The important design choice is the external execution environment. Although the training tasks are self-generated, correctness is not determined solely by the model’s own opinion:
\[\text{self-generated task} + \text{external executable verification}\]
This preserves grounding while reducing dependence on human-curated datasets.
The resulting loop is approximately
\[M_t \rightarrow \text{generate frontier tasks} \rightarrow \text{solve} \rightarrow \text{execute and verify} \rightarrow \text{RL update} \rightarrow M_{t+1}\]
If \(M_{t+1}\) can propose more informative tasks than \(M_t\), the curriculum itself improves as the model improves.
That property makes zero-data self-play especially relevant to RSI.

Challenger-Solver Co-Evolution

R-Zero: Self-Evolving Reasoning LLM from Zero Data by Huang et al. (2025) develops a related architecture in which a Challenger and Solver are initialized from a base LLM and optimized separately. The Challenger learns to propose tasks near the edge of the Solver’s capabilities, while the Solver learns to solve the resulting curriculum; the two roles therefore co-evolve without a pre-existing task-and-label dataset.
Let
\[C_{\phi_t}\]
- denote the Challenger and
  \[S_{\theta_t}\]
  - the Solver.
The Challenger generates
\[x_t \sim C_{\phi_t}(x)\]
The Solver attempts
\[y_t \sim S_{\theta_t}(y\mid x_t)\]
The Solver receives reward for correctness:
\[r_S = V(x_t,y_t)\]
- while the Challenger receives a reward designed to favor informative difficulty:
  \[r_C = g \left( P_{\theta_t}(\text{solve}\mid x_t) \right)\]
A suitable \(g\) rewards tasks that are neither trivial nor hopeless.
The joint update becomes
\[\theta_{t+1} = U_S(\theta_t,r_S)\] \[\phi_{t+1} = U_C(\phi_t,r_C)\]
The resulting process resembles an automated moving frontier:
\[\text{stronger solver} \rightarrow \text{harder useful tasks} \rightarrow \text{stronger solver}\]
This is a particularly clear example of recursive curriculum generation, although it remains bounded by the task-generating language, verifier, environment, optimization algorithm, and compute budget.

Learning Progress as a Curriculum Objective

A useful generalization is to reward task generation according to learning progress rather than raw difficulty.
For task \(x\), define performance at iteration \(t\) as
\[p_t(x)\]
The learning progress induced by a task distribution can be approximated as
\[LP_t(x) = p_{t+1}(x)-p_t(x)\]
A curriculum generator can seek
\[q_t^* = \arg\max_q \mathbb{E}_{x\sim q} [ LP_t(x) ]\]
This differs from simply generating the hardest possible tasks.
If
\[p_t(x)\approx0\]
- and remains zero after training, then
  \[LP_t(x)\approx0\]
Likewise, if
\[p_t(x)\approx1\]
- there is little remaining improvement.
The ideal curriculum concentrates on tasks where additional training changes the policy:
\[\frac{\partial Q_{\theta}} {\partial \text{training on }x}\]
- is large.
This provides a more precise interpretation of self-generated curricula: the objective is not maximal difficulty, but maximal marginal learning value.

The Role of Reinforcement Learning with Verifiable Rewards

Self-generated reasoning becomes particularly powerful when combined with reinforcement learning with verifiable rewards.
Suppose the model samples a trajectory
\[\tau = (y_1,\ldots,y_T) \sim \pi_\theta(\tau\mid x)\]
- and a deterministic or highly reliable verifier provides
  \[r(\tau)\in\{0,1\}\]
The optimization objective is
\[J(\theta) = \mathbb{E}_{x,\tau} [ r(\tau) ]\]
A policy-gradient estimator takes the familiar form
\[\nabla_\theta J \approx \mathbb{E} \left[ A(\tau) \nabla_\theta \log \pi_\theta(\tau\mid x) \right]\]
- where \(A(\tau)\) is an advantage estimate.
The RSI relevance is not any particular RL algorithm. It is that the reward can be produced automatically at very high scale.
For mathematics, this may be answer verification.
For code:
\[r = \mathbb{1} [ \operatorname{TestsPass}(y) ]\]
For theorem proving:
\[r = \mathbb{1} [ \operatorname{ProofChecker}(y)=\text{valid} ]\]
For systems optimization:
\[r = f( \text{latency}, \text{memory}, \text{throughput}, \text{correctness} )\]
Once verification is machine-executable, the cost of generating training feedback can fall dramatically relative to human labeling.
This creates the scalable pattern
\[\boxed{ \text{self-generate} + \text{externally verify} + \text{learn} + \text{repeat} }\]
- that underlies several of the strongest current approaches to autonomous self-training.

Why Self-Generated Data Can Collapse

The main difficulty is that recursive data generation does not automatically produce recursive knowledge generation.
Suppose the model-generated training distribution is
\[q_t(x,y)\]
Training the next model primarily on samples from \(q_t\) gives
\[\theta_{t+1} \approx \operatorname{Fit}(q_t)\]
If \(q_t\) contains systematic errors or lacks important modes, the next model may reproduce or amplify those defects.
Repeated iteration can produce
\[q_0 \rightarrow q_1 \rightarrow q_2 \rightarrow\cdots\]
- with decreasing support over the true data distribution.
A simplified diversity measure is entropy:
\[H(q_t) = - \sum_x q_t(x)\log q_t(x)\]
Diversity collapse corresponds roughly to
\[H(q_{t+1})<H(q_t)\]
- over repeated iterations.
This matters because a self-improving system requires novelty. If the system increasingly trains on variations of what it already knows, it can become more confident and optimized without expanding its effective capability frontier.
The challenge highlighted by Lossy self-improvement is therefore useful when framed constructively: a self-improvement loop must generate enough new useful information to compensate for losses introduced by imperfect generation, selection, training, and coordination.
A generic iteration can be written as
\[I_{t+1} = I_t + G_t - L_t\]
- where \(I_t\) is useful learned information, \(G_t\) is genuinely new information acquired during the iteration, and \(L_t\) represents information lost through filtering, approximation, mode contraction, optimization error, or evaluator mistakes.
Sustained self-improvement requires
\[G_t>L_t\]
Recursive acceleration requires the stronger condition that the net gain itself improves:
\[(G_{t+1}-L_{t+1}) > (G_t-L_t)\]
- over a meaningful range of iterations.

Novelty Is a Consumable Resource Without Grounding

A self-generated curriculum can only recombine information already inside the system unless interaction with an external process introduces new evidence.
This creates a useful distinction between endogenous and exogenous information:
\[I_{t+1} = I_t + I_t^{\text{endo}} + I_t^{\text{exo}}\]
Endogenous information comes from reasoning, recombination, search, simulation, self-play, and deduction.
Exogenous information comes from environments, experiments, execution, measurements, humans, sensors, external corpora, or other processes not reducible to resampling the model’s current beliefs.
Endogenous search can produce genuine discoveries. A theorem can be deduced from known axioms, and a new algorithm can be discovered by searching program space. But the reliability of such discoveries usually depends on an external constraint:
\[\text{proposal} \rightarrow \text{world or verifier} \rightarrow \text{new evidence}\]
For open-ended RSI, this suggests that the strongest systems will not be purely introspective. They will continually acquire grounded information from executable environments, scientific experiments, software systems, simulations, human institutions, and the physical world.

Preventing Self-Training Drift

A robust self-training system should therefore preserve several forms of anchoring.
Let the total training objective be
\[\mathcal{L} = \lambda_{\text{self}} \mathcal{L}_{\text{self}} + \lambda_{\text{anchor}} \mathcal{L}_{\text{anchor}} + \lambda_{\text{div}} \mathcal{L}_{\text{div}} + \lambda_{\text{reg}} \mathcal{L}_{\text{reg}}\]
Here \(\mathcal{L}_{\text{self}}\) learns from self-generated experience, \(\mathcal{L}_{\text{anchor}}\) preserves performance against externally grounded examples, \(\mathcal{L}_{\text{div}}\) discourages curriculum collapse, and \(\mathcal{L}_{\text{reg}}\) constrains undesirable policy drift.
The system can additionally maintain a replay buffer
\[\mathcal{B}_t = \mathcal{B}_{\text{human}} \cup \mathcal{B}_{\text{verified}} \cup \mathcal{B}_{\text{frontier}}\]
- where the three components contain externally anchored data, previously verified self-generated examples, and newly generated frontier tasks.
Training batches can deliberately mix these distributions rather than replacing old data with the latest self-generated corpus.
This turns continual self-training into a controlled accumulation process rather than an unconstrained generational replacement process.

Measuring Whether an Iteration Actually Improved the Model

A training-time loop should not assume that a new checkpoint is better merely because its training reward increased.
Let
\[\mathbf{E}(M) = ( E_1(M),E_2(M),\ldots,E_K(M) )\]
- be a vector of evaluations covering different capabilities.
A candidate successor \(M_{t+1}\) should ideally satisfy
\[E_i(M_{t+1}) \ge E_i(M_t)-\delta_i\]
- for protected dimensions, while producing statistically credible gains on target dimensions.
Evaluation should also distinguish memorization of the generated curriculum from generalization.
Let
\[\mathcal{D}_{\text{self}}\]
- be the distribution used during self-training and
  \[\mathcal{D}_{\text{transfer}}\]
  - a separately constructed evaluation distribution.
A meaningful improvement requires gains on
\[\mathcal{D}_{\text{transfer}}\]
- not merely
  \[\mathcal{D}_{\text{self}}\]
This becomes increasingly important as the system gains control over its own curriculum. If the same process generates both training tasks and evaluation tasks, the system can inadvertently make the metric easier rather than make the model better.

The Training-Time RSI Loop

Combining these mechanisms produces a general architecture:
\[M_t \rightarrow \text{generate tasks} \rightarrow \text{generate solutions} \rightarrow \text{verify} \rightarrow \text{construct training signal} \rightarrow \text{update model} \rightarrow M_{t+1}\]
A stronger implementation adds evaluator and curriculum updates:
\[(M_t,C_t,E_t) \rightarrow (D_t,R_t) \rightarrow (M_{t+1},C_{t+1},E_{t+1})\]
- where \(C_t\) is the curriculum generator and \(E_t\) the evaluator.
The complete recursive condition is then not simply
\[Q(M_{t+1})>Q(M_t)\]
It is
\[Q(M_{t+1})>Q(M_t)\]
- together with
  \[Q(C_{t+1})>Q(C_t)\]
  - and ideally
    \[Q(E_{t+1})>Q(E_t)\]
In other words, the learner, teacher, and examiner must remain mutually compatible as capability increases.
The training-time path toward RSI can therefore be summarized as
\[\boxed{ \text{self-generated solutions} \rightarrow \text{self-generated feedback} \rightarrow \text{self-generated tasks} \rightarrow \text{self-generated curricula} \rightarrow \text{co-evolving learner and evaluator} }\]
The progression is significant because each step removes another externally supplied component of the training pipeline. Yet removing human-generated data is not itself the objective. The objective is to replace scarce supervision with scalable sources of information that remain grounded enough to distinguish genuine capability gains from self-reinforcing errors.
Training-time self-iteration therefore exposes one of the central tensions in RSI. A loop becomes more autonomous as it internalizes task generation, evaluation, and learning, but those same changes weaken the independent anchors that make improvement measurable. The next layer of RSI consequently becomes indispensable: self-evaluation, process supervision, verifiers, and meta-evaluation mechanisms capable of determining whether an increasingly autonomous system is actually getting better.

Self-Evaluation, Verification, and Reward

Every self-improvement loop depends on an evaluator. A system can generate new answers, training examples, agent architectures, curricula, or research ideas at enormous scale, but none of these constitute improvement unless the system can reliably determine which candidates are better. This makes evaluation a central technical bottleneck for recursive self-improvement rather than merely a downstream benchmarking problem.
Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) makes self-evaluation a distinct category of self-improvement and proposes a hierarchy ranging from formal verification to intrinsic self-assessment. The central observation is that demonstrated self-improvement is strongest when the evaluation signal is externally grounded and difficult to manipulate, while weaker evaluators place progressively stronger limits on how far the improvement loop can safely optimize.
The basic loop can be expressed as
\[c_1,\ldots,c_N \sim G(S_t)\] \[r_i = E_t(c_i)\] \[c^* = \arg\max_{c_i}r_i\] \[S_{t+1} = U(S_t,c^*)\]
Here the generator proposes candidate improvements, the evaluator scores them, and the update mechanism incorporates the selected candidate. The quality of the entire loop is therefore constrained by the relationship between evaluator score and actual quality.
If true utility is
\[U(c)\]
- while the system observes only
  \[E(c)\]
  - successful optimization requires
    \[E(c) \approx U(c)\]
    - over the region explored by the optimizer.
This requirement becomes more demanding as the system becomes better at optimization.

Evaluation as the Core of Self-Improvement

The evaluator performs at least three distinct roles in an RSI system.
First, it supplies a selection signal:
\[c^* = \arg\max_c E(c)\]
Second, it determines whether a proposed change should persist:
\[S_{t+1} = \begin{cases} \operatorname{Commit}(S_t,c^*), & E(c^*)>\tau,\\ S_t, & \text{otherwise}. \end{cases}\]
Third, it defines the effective direction of improvement.
Even if the nominal objective is specified separately, repeated selection according to evaluator \(E\) makes the system behave approximately as though it were optimizing
\[\max_c E(c)\]
This means an evaluator is not simply measuring the self-improvement process. It partially defines it.
For bounded tasks, this can be straightforward. A compiler can determine whether code compiles. A theorem checker can determine whether a proof satisfies formal rules. A game engine can determine whether an agent won. A simulator can measure latency or energy consumption.
For open-ended tasks such as scientific importance, research taste, helpful dialogue, creative quality, or long-horizon strategic value, the target is considerably harder to formalize.
This difference produces a verification frontier:
\[\text{capabilities that can be generated} \quad\text{vs.}\quad \text{capabilities that can be reliably evaluated}\]
An RSI system can expand most reliably where the second frontier keeps pace with the first.

A Verification Hierarchy

The evaluator landscape can be organized according to how directly its signal is connected to the property being optimized.
A useful hierarchy is
\[\boxed{ \text{formal verification} > \text{executable verification} > \text{grounded evaluation} > \text{learned reward models} > \text{LLM judges} > \text{intrinsic self-assessment} }\]
This is not an absolute ordering for every task. A poorly specified formal objective can measure the wrong property, while a well-designed learned evaluator can capture dimensions unavailable to a simple executable test. The hierarchy instead describes the degree to which correctness can be anchored independently of the model being improved.
At the strongest end, a candidate can be checked against explicit rules.
At the weakest end, the same model that generated a candidate may simply be asked whether the candidate is good.
The latter creates the most direct possibility of correlated errors:
\[\operatorname{Error}_{G} \approx \operatorname{Error}_{E}\]
If generator and evaluator share the same failure mode, evaluation may confirm rather than correct the mistake.

Formal Verification

Formal verification provides one of the strongest possible feedback signals because acceptance depends on explicit logical constraints rather than subjective judgment.
Let \(c\) be a candidate proof or artifact and \(V\) a sound verifier. Ideally,
\[V(c)=1 \Rightarrow c\in\mathcal{C}_{\text{valid}}\]
The generator can therefore search aggressively:
\[c_1,c_2,\ldots,c_N \sim G_\theta\]
- while the verifier filters candidates:
  \[\mathcal{C}^{+} = \{ c_i:V(c_i)=1 \}\]
The generator itself does not need to be perfectly reliable. It only needs to place sufficient probability mass on valid solutions.
This creates an important asymmetry for self-improvement:
\[\text{hard to generate} \not\Rightarrow \text{hard to verify}\]
Formal proof systems provide the clearest example. A language model may need substantial search to construct a valid proof, but once the proof has been translated into a formal language, a proof assistant can mechanically check whether every inference follows from the permitted rules.
Such domains are especially attractive for recursive improvement because the evaluator can remain trustworthy even as the generator becomes substantially more capable.

Executable Verification

Many useful domains lack formal proofs but still provide machine-executable feedback.
For generated code, a simple verifier can be
\[V_{\text{code}}(p) = \mathbb{1} [ \operatorname{TestsPass}(p) ]\]
More realistic evaluation can incorporate multiple dimensions:
\[E(p) = w_c C(p) + w_l L(p) + w_m M(p) + w_s S(p)\]
- where \(C\) measures correctness, \(L\) latency, \(M\) memory use, and \(S\) another desired system property.
Training Verifiers to Solve Math Word Problems by Cobbe et al. (2021) demonstrates the broader generate-and-verify principle: multiple candidate solutions are generated and a trained verifier ranks them, substantially improving mathematical problem-solving performance relative to relying on generation alone.
Software and algorithm discovery are particularly amenable to this architecture because candidate implementations can often be executed.
For example:
\[\text{candidate algorithm} \rightarrow \begin{cases} \text{correctness tests}\\ \text{runtime benchmark}\\ \text{memory benchmark}\\ \text{hardware measurement} \end{cases} \rightarrow r\]
The evaluator can therefore produce an empirical signal independent of whether the generating model believes its proposal is good.
This is one reason algorithmic discovery provides an important testing ground for self-improvement.

Outcome Supervision

Outcome supervision evaluates only the final result of a trajectory.
Let
\[\tau = (s_1,s_2,\ldots,s_T)\]
- represent a reasoning trajectory. An outcome evaluator provides
  \[r_{\text{outcome}} = E(s_T)\]
For a mathematics problem this may mean checking only the final numerical answer. For code it may mean running the final program against tests.
Outcome supervision is attractive because labels can often be generated automatically and cheaply.
However, the signal contains little information about where success or failure occurred.
Two trajectories
\[\tau_a\]
- and
  \[\tau_b\]
  - may receive identical reward even if one follows a valid reasoning process while the other reaches the correct answer through an erroneous intermediate step.
The credit-assignment problem becomes increasingly difficult as trajectory length grows:
\[T\uparrow \quad\Rightarrow\quad \text{ambiguity of failure location}\uparrow\]
For long-horizon self-improving agents, this becomes particularly important because a final failure may originate hundreds or thousands of actions earlier.

Process Supervision

Process supervision addresses this problem by evaluating intermediate steps.
Instead of one terminal reward,
\[r_T\]
- the evaluator provides
  \[r_1,r_2,\ldots,r_T\]
A process reward model can estimate
\[P( s_t\text{ is valid} \mid s_1,\ldots,s_t )\]
The trajectory score can then aggregate step-level judgments.
Let’s Verify Step by Step by Lightman et al. (2023) directly compares outcome-supervised and process-supervised reward models on mathematical reasoning. The study finds that process supervision substantially improves the ability to select correct solutions on the evaluated MATH problems and releases PRM800K, containing approximately 800,000 step-level labels.
The distinction is especially relevant for RSI because the artifact being evaluated may itself be an improvement process.
Suppose an agent proposes a software modification through trajectory
\[\tau = ( \text{diagnose}, \text{design}, \text{edit}, \text{test}, \text{interpret} )\]
Evaluating only whether the final benchmark improved gives
\[r=E(S_{t+1})\]
Process evaluation can additionally ask whether the diagnosis was supported, whether the experiment isolated the intended variable, whether the implementation introduced hidden regressions, and whether the interpretation followed from the evidence.
This produces richer information for subsequent self-improvement.

Learned Reward Models

Not every desirable property admits deterministic verification.
For qualities such as helpfulness, clarity, instruction following, style, research relevance, or preference satisfaction, evaluation may require a learned model.
A reward model can be trained on comparisons
\[(x,y_w,y_l)\]
- where humans or another trusted source prefer \(y_w\) to \(y_l\).
The model learns
\[R_\phi(x,y)\rightarrow\mathbb{R}\]
A standard preference objective can be expressed as
\[\mathcal{L}_{R} = - \mathbb{E} \left[ \log \sigma \left( R_\phi(x,y_w) - R_\phi(x,y_l) \right) \right]\]
The resulting evaluator can score new candidates at much larger scale than direct human evaluation.
This introduces a compression step:
\[\text{human judgments} \rightarrow R_\phi \rightarrow \text{millions of automated evaluations}\]
The benefit is scalability.
The limitation is that the reward model approximates the human preference distribution represented by its training data rather than directly observing the intended objective.
As optimization pressure increases, the distinction becomes increasingly important:
\[\arg\max_y R_\phi(x,y)\]
- need not equal
  \[\arg\max_y U_{\text{human}}(x,y)\]
The self-improvement system can eventually discover regions where the approximation is inaccurate.

LLM-as-a-Judge

LLM judges extend learned evaluation by asking a capable language model to evaluate another model’s output directly.
A judge receives
\[(x,y,\rho)\]
- where \(x\) is the task, \(y\) the candidate, and \(\rho\) an evaluation rubric.
It returns
\[J(x,y,\rho) \rightarrow (r,f)\]
- where \(r\) is a score or preference and \(f\) is explanatory feedback.
Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena by Zheng et al. (2023) studies this paradigm and reports strong agreement between capable LLM judges and human preferences in its evaluation setting, while also identifying systematic effects including position bias, verbosity bias, self-enhancement bias, and limitations in reasoning.
LLM judges are attractive for self-improvement because they can evaluate open-ended outputs that lack deterministic verifiers:
\[\text{essay} \rightarrow \text{judge}\] \[\text{research proposal} \rightarrow \text{judge}\] \[\text{agent trajectory} \rightarrow \text{judge}\]
They can also produce structured critiques rather than scalar rewards.
For example,
\[J(x,y) = ( r_{\text{correctness}}, r_{\text{relevance}}, r_{\text{clarity}}, r_{\text{evidence}}, f )\]
This provides substantially richer feedback than a binary outcome.
However, an LLM judge is still a model. Its evaluations are predictions rather than proofs.

Pairwise Evaluation

For subjective tasks, comparing two candidates can be easier than assigning an absolute score.
Instead of
\[E(y)\rightarrow r\]
- the evaluator computes
  \[E(y_a,y_b) \rightarrow P(y_a\succ y_b)\]
Pairwise comparisons reduce the burden of defining an absolute scale.
Given many comparisons, systems can estimate latent candidate quality using ranking models.
For example, a Bradley-Terry formulation gives
\[P(y_i\succ y_j) = \frac{\exp(q_i)} {\exp(q_i)+\exp(q_j)}\]
- where \(q_i\) and \(q_j\) are latent quality parameters.
This architecture is useful for self-improvement because candidate generation naturally produces populations:
\[\{c_1,c_2,\ldots,c_N\}\]
Rather than asking whether each candidate exceeds some difficult-to-calibrate absolute threshold, the evaluator can identify which candidate appears better than the incumbent.
The acceptance question becomes
\[P(c_{\text{new}}\succ c_{\text{old}}) > \tau\]

Rubric-Based Evaluation

A single scalar judgment can hide important tradeoffs. A more robust evaluator decomposes quality into explicit dimensions.
Define
\[\mathbf{r}(y) = ( r_1, r_2, \ldots, r_K )\]
- where dimensions might include correctness, completeness, efficiency, robustness, novelty, safety, and cost.
The aggregate reward can be
\[R(y) = \sum_{k=1}^{K} w_k r_k(y)\]
For an agent modification, the vector might instead be
\[\mathbf{r}(A) = ( \text{task success}, \text{latency}, \text{token cost}, \text{tool errors}, \text{regressions} )\]
A candidate should not necessarily be accepted merely because
\[R(A_{\text{new}}) > R(A_{\text{old}})\]
A stronger acceptance criterion can impose protected constraints:
\[r_k(A_{\text{new}}) \ge r_k(A_{\text{old}}) - \delta_k\]
- for designated dimensions.
This makes self-improvement closer to constrained optimization:
\[\max_A r_{\text{target}}(A)\]
- subject to
  \[r_k(A)\ge c_k\]
Such constraints become increasingly important as the scope of self-modification expands.

Evaluator Ensembles

A practical RSI system need not rely on a single evaluator.
Instead, it can combine
\[\mathcal{E} = \{ E_{\text{formal}}, E_{\text{exec}}, E_{\text{retrieval}}, E_{\text{judge}}, E_{\text{human}} \}\]
The final evaluation might be
\[R(c) = \sum_i w_iE_i(c)\]
More conservatively, acceptance can require agreement:
\[\operatorname{Accept}(c) = \mathbb{1} \left[ E_1(c)>\tau_1 \land E_2(c)>\tau_2 \land\cdots \right]\]
Different evaluators can catch different failure modes.
A coding agent, for example, might require:
\[\text{tests pass}\]
- together with
  \[\text{static analysis passes}\]
  - and
    \[\text{held-out benchmark does not regress}\]
An LLM judge can then assess properties not captured by deterministic checks, such as code readability or whether a change actually addresses the intended problem.
The combination is stronger because the evaluators do not fail in exactly the same way.

Meta-Evaluation

Once evaluators determine which self-modifications survive, evaluator quality itself becomes a first-class optimization target.
A meta-evaluator assesses
\[E_t\]
- rather than the candidate directly:
  \[M(E_t) \rightarrow q_t\]
Possible measurements include agreement with trusted labels, calibration, adversarial robustness, consistency, sensitivity to irrelevant formatting, and ability to identify deliberately constructed errors.
For a binary evaluator, calibration can be measured by comparing predicted confidence
\[p_i\]
- with empirical correctness
  \[y_i\]
A simple calibration loss is the Brier score:
\[\operatorname{BS} = \frac{1}{N} \sum_{i=1}^{N} (p_i-y_i)^2\]
Pairwise judges can be tested for invariance under candidate order:
\[J(a,b) \approx 1-J(b,a)\]
Rubric-based judges can be tested by constructing examples where only one rubric dimension changes.
Meta-evaluation therefore asks a different question from ordinary benchmarking:
\[\text{"How trustworthy is the mechanism deciding what counts as improvement?"}\]
This question becomes increasingly important as human review decreases.

Co-Evolving the Evaluator

A fully recursive system may attempt to improve its evaluator as well as its policy.
Let
\[S_t\]
- denote the system and
  \[E_t\]
  - its evaluator.
The coupled loop is
\[S_{t+1} = F(S_t,E_t)\] \[E_{t+1} = G(E_t,S_{t+1})\]
This creates an appealing possibility:
\[\text{better evaluator} \rightarrow \text{better policy} \rightarrow \text{harder evaluation problems} \rightarrow \text{better evaluator}\]
But evaluator modification creates a special problem. If the system changes the mechanism that determines whether its own changes are beneficial, the acceptance criterion itself is moving.
Ordinary self-improvement asks
\[E_t(S_{t+1})>E_t(S_t)\]
Evaluator self-improvement additionally requires establishing that
\[E_{t+1}\]
- is a better evaluator than
  \[E_t\]
That comparison requires some higher-level reference:
\[E^{*}(E_{t+1},E_t)\]
If \(E^{*}\) is itself learned and modifiable, the same question repeats.
This is the evaluator-regress problem at the center of open-ended RSI.

Self-Confirming Loops

A particularly important failure mode occurs when generation and evaluation become too tightly coupled.
Suppose
\[G_t\]
- generates candidate beliefs or artifacts and
  \[E_t\]
  - is derived from the same model family, training data, or reasoning patterns.
Then errors may be correlated:
\[P( E_t(c)=\text{accept} \mid c\text{ is wrong}, G_t\text{ generated }c )\]
- can be substantially larger than expected under independent evaluation.
The loop becomes
\[\text{generate mistaken candidate} \rightarrow \text{approve mistaken candidate} \rightarrow \text{train on mistaken candidate} \rightarrow \text{increase confidence in mistake}\]
Repeated iterations can transform an initially small bias into a persistent feature of the successor system.
This is why external grounding matters even when the model is an excellent judge on average.
The relevant quantity is not merely evaluator accuracy under the original distribution:
\[P(E(c)=U(c))\]
It is evaluator reliability under optimization:
\[P( E(c)=U(c) \mid c\sim\operatorname{OptimizeAgainst}(E) )\]
These can differ substantially.

Optimization Pressure and Evaluator Exploitation

As a system becomes better at search, evaluator imperfections become increasingly consequential.
Suppose
\[E(c) = U(c)+\epsilon(c)\]
- where \(\epsilon(c)\) is evaluator error.
If candidates are sampled randomly, positive and negative errors may approximately cancel.
But optimization selects
\[c^* = \arg\max_c [ U(c)+\epsilon(c) ]\]
This systematically favors candidates with both high true utility and positive evaluator error.
With sufficiently powerful search, the optimizer can increasingly exploit
\[\epsilon(c)\]
This produces a general principle:
\[\boxed{ \text{Evaluator robustness must scale with optimization power.} }\]
An evaluator adequate for ranking ten ordinary candidates may be inadequate when an autonomous system searches millions of adversarially unusual candidates.
Consequently, RSI evaluation must be tested under the distribution induced by optimization itself, not only on static benchmark examples.

Adversarial Evaluation of Evaluators

A robust improvement loop should explicitly search for evaluator failures.
Let an adversary generate
\[c_{\text{adv}} = \arg\max_c \left[ E(c)-U_{\text{proxy}}(c) \right]\]
- where \(U_{\text{proxy}}\) is a stronger or independently grounded approximation of actual quality.
These candidates are designed to receive high evaluator scores while being poor according to the stronger reference.
The resulting failures can be added to evaluator training:
\[D_{E,t+1} = D_{E,t} \cup \{ c_{\text{adv}} \}\]
This creates an evaluator-improvement loop:
\[E_t \rightarrow \text{red-team} \rightarrow \text{discover failure} \rightarrow \text{retrain} \rightarrow E_{t+1}\]
The evaluator can therefore co-evolve with the optimization process rather than remain static while the generator becomes increasingly capable.

Evaluation Under Distribution Shift

Self-improvement inherently changes the distribution being evaluated.
At iteration \(t\), candidates follow
\[c\sim p_t(c)\]
After improvement,
\[c\sim p_{t+1}(c)\]
The evaluator may have been validated primarily on
\[p_t\]
- while being asked to score increasingly novel candidates from
  \[p_{t+1}\]
Evaluator accuracy is therefore conditional:
\[A_E(p) = P_{c\sim p} [ E(c)=U(c) ]\]
It is possible that
\[A_E(p_t)\gg A_E(p_{t+1})\]
This creates a moving-target problem: every successful improvement step can push the generator farther from the evaluator’s original training distribution.
An RSI system therefore needs continual evaluator validation rather than a one-time certification.

Research Evaluation Is Harder Than Solution Verification

Evaluation becomes substantially more difficult when the object being optimized is research itself.
A theorem can sometimes be formally checked. A program can be executed. But consider a proposed research direction:
Should the system spend the next month investigating architecture A, data strategy B, or training algorithm C?
The utility of this decision may not become observable until substantial resources have been spent.
Let research direction \(d\) have eventual value
\[U(d)\]
- but suppose the system can initially observe only
  \[\hat{U}(d)\]
The delay
\[\Delta t\]
- between selecting \(d\) and observing useful evidence can be large.
The evaluation problem therefore becomes
\[d \rightarrow \text{experiment sequence} \rightarrow \text{evidence} \rightarrow U(d)\]
This is fundamentally different from checking whether a program passes unit tests.
Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) separates this bottleneck into two problems: evaluating whether a chosen research direction worked, which is still verification-like, and the logically prior problem of choosing which directions deserve evaluation at all.
The second problem cannot be solved merely by building a stronger verifier.

Direction Generation Versus Direction Verification

This distinction can be written as
\[d \sim P_{\text{direction}}(d\mid K_t)\]
- followed by
  \[E(d) = \operatorname{Experiment}(d)\]
Verification addresses
\[\text{"Did direction }d\text{ work?"}\]
- but research taste addresses
  \[\text{"Which }d\text{ should be tried?"}\]
A perfect experimental evaluator cannot recover promising directions that were never proposed.
If
\[\mathcal{D}_{\text{good}}\]
- is the set of potentially valuable research directions, the generator must assign sufficient probability mass to it:
  \[P_{\text{direction}} ( d\in\mathcal{D}_{\text{good}} ) >0\]
Thus open-ended research improvement requires both a strong verifier and a sufficiently broad prior over possible directions.
This provides a deeper interpretation of the RSI bottleneck:
\[\boxed{ \text{Research progress} = \text{good direction generation} \times \text{reliable direction evaluation}. }\]
Either term approaching zero constrains the loop.

A Practical Evaluation Stack for RSI

A robust self-improvement system should use the strongest available evaluator for each component rather than forcing all judgments through one general-purpose model.
For candidate code:
\[\text{compiler} \rightarrow \text{unit tests} \rightarrow \text{integration tests} \rightarrow \text{performance benchmarks}\]
For reasoning:
\[\text{answer verifier} \rightarrow \text{process evaluator} \rightarrow \text{independent judge}\]
For factual claims:
\[\text{claim extraction} \rightarrow \text{retrieval} \rightarrow \text{source validation} \rightarrow \text{judge}\]
For agent modifications:
\[\text{sandbox execution} \rightarrow \text{held-out tasks} \rightarrow \text{regression suite} \rightarrow \text{cost and safety checks}\]
For research proposals:
\[\text{literature grounding} \rightarrow \text{novelty check} \rightarrow \text{experiment} \rightarrow \text{replication} \rightarrow \text{longer-horizon assessment}\]
The evaluator should therefore be viewed as a heterogeneous verification stack rather than a single scalar reward model.

Acceptance Gates and Rollback

Evaluation becomes operational only when connected to an acceptance policy.
Let the incumbent system be
\[S_t\]
- and candidate
  \[S_t'\]
A simple gate is
\[\operatorname{Accept}(S_t') = \mathbb{1} [ E(S_t')>E(S_t)+\epsilon ]\]
A more realistic system requires multiple conditions:
\[\operatorname{Accept}(S_t') = \mathbb{1} \left[ \Delta Q>\epsilon_Q \land \Delta S\ge-\epsilon_S \land \Delta C\le\epsilon_C \land \operatorname{TestsPass}=1 \right]\]
- where \(Q\) is target capability, \(S\) a protected property, and \(C\) cost.
Every accepted update should preserve lineage:
\[S_0 \rightarrow S_1 \rightarrow \cdots \rightarrow S_t\]
If later evaluation discovers a regression, the system should be able to restore a known-good state:
\[S_t \xrightarrow{\text{rollback}} S_k, \qquad k<t\]
This turns self-improvement from unrestricted mutation into versioned, experimentally validated evolution.

Evaluation as the Limiting Resource

The preceding mechanisms reveal an important asymmetry in the path toward RSI.
Candidate generation can be scaled through sampling:
\[N\uparrow\]
Agent execution can be scaled through parallelism:
\[A\uparrow\]
Training can be scaled through compute:
\[C\uparrow\]
But if evaluator reliability remains fixed,
\[Q_E\approx\text{constant}\]
- additional optimization eventually encounters an evaluation ceiling.
A useful approximation is
\[Q_{\text{achievable}} \lesssim f( Q_{\text{generator}}, Q_{\text{evaluator}}, C )\]
Increasing generator capability alone does not guarantee increasing realized quality.
This is why evaluation occupies a structurally central position in recursive self-improvement. Every proposed improvement is ultimately a hypothesis:
\[H: S_{t+1}>S_t\]
The evaluator determines whether that hypothesis is accepted.
The most robust path therefore has the form
\[\boxed{ \text{Generate} \rightarrow \text{Verify} \rightarrow \text{Challenge the verifier} \rightarrow \text{Validate} \rightarrow \text{Commit} \rightarrow \text{Re-evaluate} }\]
As self-improvement becomes more autonomous, the evaluator must evolve from a benchmark into an active component of the system: grounded where possible, adversarially tested, calibrated under distribution shift, protected from correlated errors, and itself subject to independent evaluation.
The central challenge is consequently not only building systems capable of producing increasingly sophisticated improvements. It is maintaining a trustworthy answer to the question that every recursive step implicitly asks:
\[\boxed{ \text{How do we know the new system is actually better?} }\]

Automated Research and Algorithm Discovery

The most ambitious form of recursive self-improvement moves beyond improving answers, policies, or agent scaffolding and begins automating the process that produces new AI methods. Instead of treating research as an external human activity that periodically supplies better architectures, algorithms, data pipelines, or training recipes, an automated research system makes parts of that process executable by AI agents.
Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) identifies automated research as a distinct self-improvement regime. The important transition is from a system that improves within a human-designed algorithm to one that can search for modifications to the algorithms, experiments, and research processes responsible for producing future systems.
At a high level, an automated research loop can be represented as
\[K_t \rightarrow \text{hypothesize} \rightarrow \text{implement} \rightarrow \text{experiment} \rightarrow \text{evaluate} \rightarrow \text{update knowledge} \rightarrow K_{t+1}\]
- where \(K_t\) denotes the accumulated research state at iteration \(t\).
For RSI, the particularly important case is when the object being researched is the AI system itself:
\[S_t \rightarrow R(S_t) \rightarrow \Delta S_t \rightarrow S_{t+1}\]
- where \(R\) is an automated research process and \(\Delta S_t\) is a discovered improvement.
The stronger recursive condition is that
\[S_{t+1}\]
- is subsequently better at performing \(R\):
  \[Q_R(S_{t+1}) > Q_R(S_t)\]
The loop then becomes
\[\boxed{ \text{AI research capability} \rightarrow \text{better AI} \rightarrow \text{better AI research capability} }\]
- which is one of the clearest operational interpretations of recursive self-improvement.

From Research Assistance to Research Loops

AI-assisted research and autonomous research should be distinguished carefully.
A conventional research assistant might perform a function such as
\[A(x)\rightarrow y\]
- where a human researcher decides which problem to investigate, requests an analysis or implementation, interprets the result, and decides what to do next.
An automated research loop instead maintains a persistent research state:
\[R_t = ( K_t, H_t, X_t, E_t, A_t )\]
- where \(K_t\) is accumulated knowledge, \(H_t\) a set of hypotheses, \(X_t\) experimental results, \(E_t\) evaluation machinery, and \(A_t\) the current research agenda.
The system repeatedly applies
\[R_{t+1} = F(R_t)\]
A practical implementation decomposes this into specialized stages:
\[\text{problem selection} \rightarrow \text{hypothesis generation} \rightarrow \text{experiment design} \rightarrow \text{implementation} \rightarrow \text{execution} \rightarrow \text{analysis} \rightarrow \text{decision}\]
The central engineering challenge is not making an LLM perform each stage once. Modern agents can already participate in all of them. The challenge is connecting the stages into a persistent loop in which evidence from one experiment determines what research happens next.

The Research State

An autonomous researcher requires substantially more persistent state than a conventional conversational agent.
A useful abstraction is
\[R_t = ( L_t, I_t, X_t, C_t, B_t, P_t )\]
- where:
  \[L_t = \text{literature and prior knowledge}\] \[I_t = \text{research ideas and hypotheses}\] \[X_t = \text{completed experiments and observations}\] \[C_t = \text{code and experimental artifacts}\] \[B_t = \text{beliefs about what works}\]
  - and
    \[P_t = \text{current research priorities}\]
Each experiment modifies this state:
\[R_{t+1} = \operatorname{Update} ( R_t, x_t, o_t )\]
- where \(x_t\) is the experiment and \(o_t\) its observed result.
This persistent state is important because scientific progress is cumulative. A system that repeatedly generates isolated research ideas without remembering failed experiments, negative results, confounders, or earlier hypotheses does not form a meaningful research loop.

Hypothesis Generation

The first generative component proposes hypotheses or candidate interventions.
Given research state \(R_t\),
\[h_i \sim P_\theta(h\mid R_t)\]
- for
  \[i=1,\ldots,N\]
These hypotheses might correspond to a new architecture, loss function, optimizer, prompting strategy, agent architecture, data-selection rule, inference algorithm, evaluation technique, or systems optimization.
Generating many hypotheses is straightforward compared with deciding which deserve expensive experiments.
A research agent therefore needs a proposal-ranking function:
\[V(h_i\mid R_t) = f( N_i, P_i, C_i, I_i )\]
- where \(N_i\) represents estimated novelty, \(P_i\) plausibility, \(C_i\) experimental cost, and \(I_i\) expected information value.
A candidate can then be selected according to
\[h^* = \arg\max_{h_i} V(h_i\mid R_t)\]
This stage is analogous to action selection in reinforcement learning, except that actions may correspond to experiments consuming hours or days of compute.
The opportunity cost of a poor research choice can therefore be large.

Research as Sequential Experimental Design

Automated research can be formulated as sequential decision-making under uncertainty.
Suppose the system maintains beliefs
\[p_t(\theta)\]
- about unknown properties of a research problem.
It chooses experiment
\[x_t\]
- and observes
  \[o_t\]
Bayesian updating gives
\[p_{t+1}(\theta) = p(\theta\mid o_t,x_t)\]
The ideal experiment is not necessarily the one expected to produce the highest immediate benchmark score. It may instead be the one expected to reduce uncertainty most effectively.
A generic information-gain objective is
\[x_t^* = \arg\max_x \mathbb{E}_{o\sim p(o\mid x)} \left[ D_{\mathrm{KL}} \left( p(\theta\mid o,x) \Vert p(\theta) \right) \right]\]
This distinction is important for autonomous research.
A system optimizing only
\[\max_x \mathbb{E}[\text{benchmark improvement}]\]
- may repeatedly exploit known successful directions.
A system optimizing information gain can also perform experiments designed to determine why a method works, identify boundary conditions, eliminate hypotheses, and expose new directions.
Effective automated research therefore requires a balance between
\[\text{exploitation} \quad\text{and}\quad \text{epistemic exploration}\]

Experiment Design

After choosing a hypothesis, the system must translate it into an experiment capable of discriminating between competing explanations.
Let hypotheses be
\[H_0\]
- and
  \[H_1\]
A useful experiment should produce substantially different predicted observations:
\[P(o\mid H_0,x) \neq P(o\mid H_1,x)\]
The research agent therefore needs to reason not only about what implementation to run, but what conclusion will be justified by each possible outcome.
An experimental specification might include
\[X = ( H, \mathcal{D}, B, M, A, C )\]
- where \(H\) is the hypothesis, \(\mathcal{D}\) the dataset or environment, \(B\) baselines, \(M\) metrics, \(A\) ablations, and \(C\) controls.
A research agent should construct this specification before observing the result.
Otherwise, experiment interpretation can become post hoc:
\[\text{result} \rightarrow \text{invent explanation}\]
A stronger pipeline is
\[\text{hypothesis} \rightarrow \text{predicted outcomes} \rightarrow \text{experiment} \rightarrow \text{observation} \rightarrow \text{comparison with prediction}\]
This turns automated experimentation into hypothesis testing rather than benchmark fishing.

Implementation and Execution

Once an experiment has been specified, coding agents can convert it into executable artifacts.
The implementation loop can be represented as
\[X_t \rightarrow C_t \rightarrow \operatorname{Run}(C_t) \rightarrow O_t\]
But autonomous execution introduces failure modes that human researchers normally detect informally: incorrect dataset splits, silent preprocessing errors, mismatched baselines, stale checkpoints, invalid metrics, nondeterministic failures, or experiments that do not actually implement the intended hypothesis.
A robust automated research pipeline therefore requires implementation verification:
\[V_{\text{impl}} ( H_t, X_t, C_t ) \rightarrow \{0,1\}\]
The question is not merely
\[\text{"Does the code run?"}\]
- but
  \[\text{"Does the code implement the intended experiment?"}\]
These are substantially different verification problems.
Unit tests can validate components. Integration tests can validate pipelines. Small-scale smoke tests can verify expected behavior before expensive experiments. Static inspection or an independent agent can compare the experimental specification against the implementation.
A practical hierarchy is
\[\text{syntax} \rightarrow \text{unit tests} \rightarrow \text{smoke test} \rightarrow \text{specification audit} \rightarrow \text{full experiment}\]
This minimizes compute wasted on invalid experiments.

Result Interpretation

After execution, an automated researcher must convert measurements into claims.
Suppose experiment \(x_t\) produces observations
\[O_t = \{o_1,\ldots,o_n\}\]
The system computes statistics
\[Z_t = g(O_t)\]
- and updates its research state:
  \[B_{t+1} = U(B_t,Z_t)\]
The critical requirement is that the update should depend on what the evidence supports rather than what the agent expected to find.
A structured interpretation step can record:
\[\text{claim}, \quad \text{supporting evidence}, \quad \text{counterevidence}, \quad \text{uncertainty}, \quad \text{alternative explanations}\]
This produces an auditable research memory.
Negative results are also valuable:
\[H_i \xrightarrow{\text{experiment}} \text{not supported}\]
If retained correctly, a failed experiment reduces future search:
\[\mathcal{H}_{t+1} \subset \mathcal{H}_t\]
An autonomous research system that forgets negative results can repeatedly rediscover the same failures and waste increasing amounts of compute.

The AI Scientist

The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery by Lu et al. (2024) demonstrates an integrated research pipeline in which an LLM-based system generates research ideas, writes experimental code, executes experiments, visualizes results, writes a scientific paper, and performs an automated review process. The work applies the system to machine-learning research areas including diffusion modeling, language modeling, and learning dynamics.
Its significance for RSI is architectural.
Rather than automating a single research subtask,
\[\text{human research process} \rightarrow \text{AI coding assistant}\]
- it connects multiple research stages:
  \[\text{idea generation} \rightarrow \text{implementation} \rightarrow \text{experimentation} \rightarrow \text{analysis} \rightarrow \text{paper generation} \rightarrow \text{review}\]
The resulting artifacts can in principle seed another iteration:
\[R_t \rightarrow \text{research artifact} \rightarrow \text{evaluation} \rightarrow R_{t+1}\]
The system therefore illustrates how research can be represented as an agentic workflow rather than an indivisible human activity.
However, closing the procedural research loop does not by itself solve research direction-setting. The system still needs reliable mechanisms for deciding which hypotheses are genuinely important, whether experimental evidence supports a claim, and whether a new result constitutes meaningful progress rather than optimization against its automated reviewer.

Algorithm Discovery as a More Verifiable Research Domain

Algorithm discovery offers a particularly favorable setting for automated research because candidate discoveries can often be evaluated computationally.
Suppose an algorithm \(a\) has objective
\[J(a)\]
An automated discovery system searches
\[a^* = \arg\max_{a\in\mathcal{A}} J(a)\]
If \(J\) can be computed reliably, the research loop receives a strong external signal.
This converts part of scientific discovery into
\[\text{generate candidate} \rightarrow \text{execute candidate} \rightarrow \text{measure} \rightarrow \text{retain improvement}\]
Unlike open-ended research judgment, the evaluator does not need to determine whether an idea “sounds promising.” It can directly test what the candidate does.
This structure underlies systems such as FunSearch and AlphaEvolve.

FunSearch

Mathematical discoveries from program search with large language models by Romera-Paredes et al. (2024) introduces FunSearch, which combines an LLM with an evolutionary search procedure and an executable evaluator. Rather than directly generating a final mathematical object, FunSearch searches for programs that generate solutions. The system produced new results for the cap set problem and discovered improved heuristics for online bin packing.
The basic loop is
\[\mathcal{P}_t \rightarrow \operatorname{SamplePrograms} \rightarrow \operatorname{PromptLLM} \rightarrow \operatorname{Generate} \rightarrow \operatorname{Evaluate} \rightarrow \mathcal{P}_{t+1}\]
- where \(\mathcal{P}_t\) is the current program population.
For candidate program \(p_i\),
\[r_i = E(p_i)\]
High-performing programs become context for subsequent generations:
\[p_{\text{parent}} \rightarrow \text{LLM variation} \rightarrow p_{\text{child}}\]
The important mechanism is that successful discoveries alter the input distribution presented to the generator.
The LLM is therefore not repeatedly sampling independently from the same prior. Search progressively conditions generation on accumulated successful programs.

Program Space Instead of Solution Space

A central design choice in FunSearch is searching over programs rather than explicit solutions.
Suppose a solution object has size
\[O(n)\]
- while a program describing a structured family of solutions has description length
  \[O(k)\]
  - where
    \[k\ll n\]
Searching program space can therefore exploit structure and compression.
A discovered program can also generalize to problem instances not explicitly encountered during search.
The search target becomes
\[p^* = \arg\max_p E( \operatorname{Execute}(p) )\]
This is especially useful for algorithm discovery because the artifact returned by search is executable, inspectable, reusable, and independently verifiable.

Maintaining Diversity

FunSearch does not simply retain one best program. It uses an island-based evolutionary mechanism to preserve multiple populations, which helps prevent the search from collapsing prematurely around one local optimum.
Let
\[\mathcal{P}_t = \{ \mathcal{I}_t^{(1)}, \ldots, \mathcal{I}_t^{(m)} \}\]
- where each \(\mathcal{I}\) is an island.
Evolution occurs partly independently:
\[\mathcal{I}_t^{(j)} \rightarrow \mathcal{I}_{t+1}^{(j)}\]
This maintains multiple search trajectories.
The design is highly relevant to RSI because greedy self-improvement can erase stepping stones. A candidate that does not immediately dominate the incumbent may nevertheless enable later discoveries.
Open-ended search therefore benefits from preserving
\[\text{quality} + \text{diversity}\]

AlphaEvolve

AlphaEvolve: A Coding Agent for Scientific and Algorithmic Discovery by Novikov et al. (2025) generalizes the evolutionary coding-agent pattern to a wider range of scientific and computational problems. AlphaEvolve uses LLMs to propose code modifications, evaluates them with one or more automated evaluators, and repeatedly evolves the candidate population. Reported applications include data-center scheduling, hardware-circuit simplification, matrix multiplication, mathematical problems, and components of the computational stack used for AI training.
The generic loop is
\[P_t \rightarrow G_\theta \rightarrow P_t' \rightarrow E \rightarrow P_{t+1}\]
Here \(P_t\) is the current program database, \(G_\theta\) the LLM-based generator, and \(E\) one or more evaluators.
For multiple objectives,
\[\mathbf{r}(p) = ( r_1(p), r_2(p), \ldots, r_k(p) )\]
Selection can then optimize a scalarization
\[R(p) = \sum_{i=1}^{k} w_i r_i(p)\]
- or preserve a Pareto frontier of candidates that trade off different objectives.
The important distinction from ordinary code generation is persistence:
\[\text{successful code} \rightarrow \text{future search state}\]
Each successful candidate becomes part of the substrate from which later candidates are produced.

Improving AI Infrastructure

AlphaEvolve is especially relevant to RSI because some discovered optimizations were applied to infrastructure used for AI itself. The paper reports, among other applications, improvements to data-center scheduling, a simplification in hardware-accelerator circuit design, and an optimization that accelerated training of the LLM underlying AlphaEvolve.
This creates a partial recursive path:
\[\text{AI system} \rightarrow \text{discover infrastructure improvement} \rightarrow \text{cheaper or faster AI computation} \rightarrow \text{more effective future AI development}\]
The recursive effect need not initially involve modifying neural-network architecture.
Improving
\[\text{compiler}\]
- or
  \[\text{kernel}\]
  - or
    \[\text{scheduling}\]
    - or
      \[\text{training infrastructure}\]
      - can reduce the cost of subsequent improvement cycles.
If research capability per unit compute is
\[R = \frac{\text{useful research output}} {\text{compute cost}}\]
- an infrastructure improvement can increase
  \[R_{t+1}>R_t\]
  - even with the same underlying model.

From Algorithm Discovery to Self-Improving Agents

FunSearch and AlphaEvolve primarily optimize artifacts external to the generating model. A more recursive architecture makes the agent itself part of the search space.
Let
\[A_t\]
- be an agent implementation.
The agent proposes
\[\Delta A_t\]
- producing
  \[A_t' = A_t+\Delta A_t\]
Evaluation determines
\[r_t = E(A_t')\]
If accepted,
\[A_{t+1} = A_t'\]
The next iteration is then performed using the improved agent:
\[A_{t+1} \rightarrow \Delta A_{t+1}\]
The critical dependency is
\[P( \text{useful modification at }t+1 \mid A_{t+1} ) > P( \text{useful modification at }t \mid A_t )\]
Now an improvement changes not merely the target artifact but the mechanism producing future improvements.

Darwin Gödel Machine as Automated Agent Research

Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents by Zhang et al. (2025) makes this connection explicit. The system iteratively modifies the code of coding agents, empirically evaluates those variants, and stores successful agents in an archive. Because an improved coding agent can subsequently participate in creating further coding-agent variants, improvements can affect the machinery responsible for later improvements.
Rather than
\[A_t \rightarrow A_{t+1}\]
- along a single chain, DGM maintains
  \[\mathcal{A}_t = \{ A^{(1)},A^{(2)},\ldots,A^{(n)} \}\]
A parent is selected:
\[A_p \sim P_{\text{select}} ( \mathcal{A}_t )\]
- a modification is generated:
  \[A' = G(A_p)\]
  - and evaluation determines whether the candidate enters the archive:
    \[\mathcal{A}_{t+1} = \mathcal{A}_t \cup \{A'\}\]
The archive acts as research memory.
Instead of remembering research only as natural-language conclusions, the system retains executable descendants representing different hypotheses about how an agent should operate.
This creates an evolutionary research process in which the artifacts are themselves researchers.

Research Artifacts as Persistent Knowledge

Automated research can accumulate several kinds of persistent artifacts:
\[\mathcal{K}_t = \{ \text{papers}, \text{code}, \text{datasets}, \text{checkpoints}, \text{benchmarks}, \text{failed experiments}, \text{successful experiments}, \text{agent variants} \}\]
The quality of the research loop depends on whether future agents can effectively retrieve and use this information.
Given a new research question \(q\),
\[K_q = \operatorname{Retrieve} ( \mathcal{K}_t,q )\]
The next hypothesis distribution becomes
\[P(h\mid q,K_q)\]
- rather than
  \[P(h\mid q)\]
This allows experiments to produce persistent epistemic state rather than disappearing when an agent’s context window ends.
A mature RSI architecture therefore requires a research memory system comparable in importance to its model weights.

Automated Ablation and Causal Diagnosis

Benchmark improvements alone provide weak information about why a modification worked.
Suppose candidate system
\[S' = S+\Delta_1+\Delta_2+\Delta_3\]
- outperforms the baseline.
Without ablations, the research system cannot determine which changes caused the gain.
An automated researcher can construct
\[S_1=S+\Delta_1\] \[S_2=S+\Delta_2\] \[S_3=S+\Delta_3\]
- and interaction variants such as
  \[S_{12} = S+\Delta_1+\Delta_2\]
This permits estimation of marginal effects:
\[\Delta E_i = E(S_i)-E(S)\]
For interacting components:
\[I_{ij} = E(S_{ij}) - E(S_i) - E(S_j) + E(S)\]
A system capable of automatically generating these experiments can convert benchmark optimization into increasingly causal knowledge about its own architecture.
That knowledge can improve future proposal generation:
\[\text{experiment} \rightarrow \text{causal insight} \rightarrow \text{better hypothesis prior}\]
This is more valuable for recursive improvement than merely discovering one high-performing configuration.

Automated Benchmark Construction

Research automation can also extend to the benchmarks used to evaluate new systems.
Suppose the current benchmark distribution is
\[D_t\]
As the model improves,
\[P( \text{success}\mid D_t ) \rightarrow1\]
- causing the benchmark to saturate.
An automated evaluator can search for discriminating tasks:
\[x^* = \arg\max_x \operatorname{Var} [ E(M_1,x), \ldots, E(M_n,x) ]\]
Such tasks separate competing models and reveal capability differences hidden by saturated evaluations.
The benchmark can therefore evolve:
\[D_t \rightarrow D_{t+1}\]
This produces another coupled loop:
\[\text{better model} \rightarrow \text{harder benchmark} \rightarrow \text{better training signal} \rightarrow \text{better model}\]
But benchmark generation must remain grounded. If the same model controls both capability improvement and benchmark construction, it can inadvertently construct evaluations that favor its own behavior.
Held-out external tests and independent verification remain important.

Parallel Research Agents

Automated research does not need to operate serially.
Suppose there are
\[N\]
- research agents.
Each agent explores hypothesis
\[h_i\]
Parallel execution gives
\[\{h_1,\ldots,h_N\} \xrightarrow{\text{parallel experiments}} \{o_1,\ldots,o_N\}\]
A coordinator aggregates the results:
\[R_{t+1} = \operatorname{Synthesize} ( R_t, o_1,\ldots,o_N )\]
This architecture can substantially increase research throughput when experiments are decomposable.
However, naive parallelism creates duplication:
\[h_i\approx h_j\]
- for many agents.
A better orchestrator explicitly encourages coverage:
\[\max_{\{h_i\}} \sum_i V(h_i) + \lambda D( h_1,\ldots,h_N )\]
- where \(D\) rewards diversity among research directions.
The problem becomes portfolio allocation rather than simple task replication.

Compute Allocation as Part of Research

An autonomous research system must decide not only what to investigate but how much compute to allocate.
Let candidate project \(i\) have estimated value
\[V_i(c)\]
- as a function of compute \(c\).
Given total budget
\[C\]
- the system solves
  \[\max_{c_1,\ldots,c_N} \sum_{i=1}^{N} V_i(c_i)\]
  - subject to
    \[\sum_i c_i\le C\]
The marginal allocation rule is approximately
\[\frac{\partial V_i}{\partial c_i} \approx \frac{\partial V_j}{\partial c_j}\]
- for active projects.
This matters for RSI because compute is finite. Even a system capable of proposing millions of experiments cannot execute them all.
Research capability therefore depends on
\[\text{idea quality} + \text{evaluation quality} + \text{resource allocation}\]
A better research agent may improve all three.

Research Throughput and Recursive Amplification

Let research productivity at iteration \(t\) be
\[R_t = \frac{\text{validated improvements}} {\text{unit time}}\]
Suppose an AI-discovered improvement increases research productivity by factor
\[1+\alpha_t\]
Then
\[R_{t+1} = R_t(1+\alpha_t)\]
If
\[\alpha_t>0\]
- across repeated iterations, research throughput compounds:
  \[R_n = R_0 \prod_{t=0}^{n-1} (1+\alpha_t)\]
This is the mechanism behind the strongest RSI intuition.
But exponential growth is not automatic. Research throughput is constrained by several resources:
\[R_t = f( Q_t, C_t, V_t, D_t, H_t )\]
- where \(Q_t\) is model capability, \(C_t\) compute, \(V_t\) verification capacity, \(D_t\) available data or environments, and \(H_t\) remaining human input.
If one resource saturates,
\[\frac{\partial R_t}{\partial Q_t} \rightarrow0\]
- then further model improvements may yield diminishing research returns.
Recursive amplification therefore depends on the entire research production function rather than model intelligence alone.

Research Latency as a Bottleneck

Some research loops can execute in seconds:
\[\text{generate code} \rightarrow \text{benchmark}\]
Others require hours:
\[\text{modify training} \rightarrow \text{train model} \rightarrow \text{evaluate}\]
Scientific experiments may require days, months, or physical interaction.
Let one research cycle take
\[T_{\text{cycle}} = T_{\text{idea}} + T_{\text{implementation}} + T_{\text{experiment}} + T_{\text{evaluation}}\]
If
\[T_{\text{experiment}} \gg T_{\text{idea}}\]
- making hypothesis generation ten times faster produces little overall acceleration.
The maximum recursion rate is therefore constrained by the slowest stage:
\[R_{\text{loop}} \lesssim \frac{1} { \max( T_{\text{idea}}, T_{\text{implementation}}, T_{\text{experiment}}, T_{\text{evaluation}} ) }\]
This helps explain why software and algorithm research are natural early domains for autonomous research: the experimental loop can often be executed entirely in computation.

Research Direction-Setting as the Harder Problem

Automating experimentation does not necessarily automate research taste.
Suppose the set of possible research directions is
\[\mathcal{H}\]
Only a small subset
\[\mathcal{H}^{*} \subset\mathcal{H}\]
- may contain high-value discoveries.
The system’s proposal distribution
\[P_\theta(h)\]
- must assign enough probability to
  \[\mathcal{H}^{*}\]
A perfect evaluator can identify a valuable hypothesis after it has been tested, but it cannot evaluate hypotheses never generated.
The probability of discovering a useful direction after \(N\) independent proposals is approximately
\[P(\text{discovery}) = 1- (1-p^*)^N\]
- where
  \[p^* = P_\theta( h\in\mathcal{H}^{*} )\]
Increasing \(N\) helps, but when
\[p^*\]
- is extremely small and experiments are expensive, brute-force search becomes infeasible.
Research progress therefore depends on improving the proposal distribution itself:
\[P_{\theta_{t+1}} ( h\in\mathcal{H}^{*} ) > P_{\theta_t} ( h\in\mathcal{H}^{*} )\]
This is one of the deepest forms of recursive improvement: improving not merely the ability to solve research problems, but the prior over which problems and hypotheses are worth considering.

The Boundary Between Search and Research

Automated discovery systems reveal that the distinction between search and research is partly a matter of representation and evaluator availability.
When a problem can be expressed as
\[a^* = \arg\max_{a\in\mathcal{A}}E(a)\]
- with cheap reliable \(E\), much of the discovery process can be converted into search.
FunSearch demonstrates this pattern for programs describing mathematical constructions and algorithms. AlphaEvolve extends it to a broader collection of algorithmic and systems problems.
But many research questions cannot yet be reduced to a cheap evaluator.
The difficult frontier is therefore characterized by
\[\text{large hypothesis space} + \text{expensive experiments} + \text{weak evaluators} + \text{delayed feedback}\]
Progress in automated research can be interpreted as repeatedly converting parts of this frontier into more tractable generate-and-verify problems.

A Practical Architecture for an Automated AI Researcher

A complete automated research system can be organized around several persistent services.
The research memory stores
\[\mathcal{K}_t\]
A hypothesis generator proposes
\[\mathcal{H}_t = G(\mathcal{K}_t)\]
A research planner ranks hypotheses:
\[h_t^* = P(\mathcal{H}_t,\mathcal{K}_t,C_t)\]
An experiment designer produces
\[X_t = D(h_t^*)\]
A coding agent implements
\[C_t = I(X_t)\]
A sandbox executes
\[O_t = \operatorname{Run}(C_t)\]
An evaluator computes
\[r_t = E(O_t,X_t)\]
A scientific critic checks whether the conclusion follows:
\[v_t = V(h_t^*,X_t,O_t)\]
Finally, the memory system updates
\[\mathcal{K}_{t+1} = U( \mathcal{K}_t, h_t^*, X_t, O_t, r_t, v_t )\]
The loop then repeats.
In compact form:
\[\boxed{ \text{Remember} \rightarrow \text{Hypothesize} \rightarrow \text{Prioritize} \rightarrow \text{Design} \rightarrow \text{Implement} \rightarrow \text{Run} \rightarrow \text{Verify} \rightarrow \text{Learn} }\]
The research system becomes recursively self-improving when some hypotheses modify this very pipeline.

Closing the Research Loop

Consider an automated researcher
\[R_t\]
- operating on AI system
  \[S_t\]
Ordinary automated research gives
\[R_t(S_t) \rightarrow S_{t+1}\]
Recursive automated research requires that the new system improve the research process:
\[R_{t+1} = g(R_t,S_{t+1})\]
- with
  \[Q(R_{t+1}) > Q(R_t)\]
The combined system evolves as
\[(R_t,S_t) \rightarrow (R_{t+1},S_{t+1})\]
The strongest loop is therefore
\[\boxed{ \text{researcher} \rightarrow \text{better AI} \rightarrow \text{better researcher} \rightarrow \text{better AI} \rightarrow \cdots }\]
Current systems demonstrate important pieces of this architecture. The AI Scientist shows that multiple stages of the research workflow can be connected into an autonomous pipeline. FunSearch shows that LLM-generated programs combined with reliable evaluators can produce verifiable discoveries on established problems. AlphaEvolve broadens this paradigm to scientific and computational discovery and includes examples where discovered algorithms improve AI-related infrastructure. Darwin Gödel Machine moves the search target inward by evolving the code of the agents performing the improvement process itself.
Together, these systems suggest a progression:
\[\text{AI assists researchers} \rightarrow \text{AI executes experiments} \rightarrow \text{AI searches algorithms} \rightarrow \text{AI conducts research loops} \rightarrow \text{AI improves research agents} \rightarrow \text{AI improves the process that improves AI}\]
The final transition is the defining one for RSI. Once research capability itself becomes a persistent and improvable component of the system, improvements can propagate not only into what the AI can do, but into how effectively it discovers the next improvement.

Multi-Agent Scaling and Research Swarms

Recursive self-improvement does not require every improvement step to be performed by a single sequential agent. Once capable agents can be instantiated cheaply, an alternative is to scale the number of concurrent reasoning and research processes. Instead of asking one model to reason for increasingly long periods, a system can fork its state across many agents, explore multiple hypotheses in parallel, and combine the resulting work.
This introduces a second axis of inference-time scaling:
\[\text{compute scaling} = \text{serial reasoning depth} + \text{parallel agent breadth}\]
The distinction matters for RSI because research is inherently search-like. A single researcher can pursue only a limited number of hypotheses at once, whereas a population of AI researchers can potentially explore many branches simultaneously.
The September 2026 discussion Noam Brown – Agent swarms, alignment, & recursive self-improvement describes this emerging regime explicitly. Brown distinguishes the underlying capability of the model from the additional leverage obtained by allowing copies of that model to operate over long horizons and in parallel. He reports that multi-agent speedups are task-dependent and somewhat sublinear, with mathematics and web research substantially more parallelizable than tightly coupled creative work.
For RSI, the relevant question is therefore not simply whether more agents improve performance. It is whether parallel agents increase the rate at which useful, verified improvements to the AI-development process can be discovered.

Serial and Parallel Test-Time Compute

Conventional reasoning models primarily scale inference through additional sequential computation.
A single agent produces a trajectory
\[\tau = (a_1,a_2,\ldots,a_T)\]
Increasing test-time compute typically means increasing
\[T\]
This allows the model to search more deeply, revise earlier conclusions, call more tools, or spend additional computation on difficult intermediate steps.
However, sequential reasoning has a latency cost:
\[L_{\text{serial}} \propto T\]
If one reasoning trajectory requires one hour, spending ten times more serial compute can push latency toward ten hours.
Parallel agents offer another strategy. Instead of extending one trajectory, instantiate
\[N\]
- agents:
  \[A_1,A_2,\ldots,A_N\]
Each explores a trajectory
\[\tau_i\]
The system then aggregates
\[y = G( \tau_1,\tau_2,\ldots,\tau_N )\]
If the trajectories can execute concurrently, wall-clock latency is closer to
\[L_{\text{parallel}} \approx \max_i L(\tau_i) + L_{\text{aggregation}}\]
- rather than
  \[\sum_i L(\tau_i)\]
The tradeoff is that total compute increases.

Parallel Sampling Versus Multi-Agent Collaboration

Parallel inference can take several forms.
The simplest is independent sampling:
\[y_i \sim \pi_\theta(y\mid x)\]
- followed by
  \[y^* = \operatorname{Select} ( y_1,\ldots,y_N )\]
The agents do not communicate. They simply provide independent candidate solutions.
A more structured multi-agent system allows interaction:
\[m_{i\rightarrow j}^{(t)} = C( s_i^{(t)} )\]
- where \(m_{i\rightarrow j}^{(t)}\) is information passed from agent \(i\) to agent \(j\).
Agent state becomes
\[s_j^{(t+1)} = U \left( s_j^{(t)}, \{ m_{i\rightarrow j}^{(t)} \} \right)\]
This enables division of labor, critique, delegation, synchronization, and iterative synthesis.
The distinction is important. Independent sampling increases search breadth, while multi-agent collaboration additionally changes the computation graph through which information flows.

Multi-Agent Collaboration Graphs

A multi-agent system can be represented as graph
\[G=(V,E)\]
- where each vertex
  \[v_i\in V\]
  - is an agent and each directed edge
    \[e_{ij}\in E\]
    - permits information to flow from agent \(i\) to agent \(j\).
Different topologies create different computational structures.
A fully connected system has approximately
\[|E| = N(N-1)\]
- directed communication links.
Communication cost can therefore grow as
\[O(N^2)\]
A sparse hierarchy can reduce this substantially.
For example,
\[\text{workers} \rightarrow \text{team leads} \rightarrow \text{synthesizer}\]
- requires far fewer interactions.
Scaling Large-Language-Model-based Multi-Agent Collaboration by Qian et al. (2024) studies collaboration networks organized as directed acyclic graphs and reports scaling experiments involving more than one thousand agents. The work finds that network topology affects collaborative performance and reports a logistic-style collaborative scaling relationship rather than unlimited linear gains.
This suggests that agent count alone is an incomplete description of multi-agent compute:
\[Q_{\text{system}} = f( N, G, Q_{\text{agent}}, C_{\text{communication}}, A_{\text{aggregation}} )\]
The organization connecting the agents can matter nearly as much as their number.

Forking Agent State

AI agents have an unusual advantage over human organizations: internal working state can be copied.
Suppose a parent agent has state
\[s_t = ( x, c_t, m_t, p_t )\]
- containing the task, current context, memory, and plan.
A fork operation can create
\[s_t^{(1)} = s_t\] \[s_t^{(2)} = s_t\] \[\cdots\] \[s_t^{(N)} = s_t\]
The agents then diverge:
\[s_{t+k}^{(i)} \neq s_{t+k}^{(j)}\]
Each copy begins with the relevant shared context but can investigate a different branch.
Brown emphasizes this distinction in Noam Brown – Agent swarms, alignment, & recursive self-improvement: AI workers can be forked with their context and later have their work recombined, unlike human researchers who cannot simply be cloned with identical background knowledge.
For research, this enables a natural branching process:
\[\text{shared problem} \rightarrow \begin{cases} \text{hypothesis 1}\\ \text{hypothesis 2}\\ \text{hypothesis 3}\\ \vdots\\ \text{hypothesis N} \end{cases} \rightarrow \text{synthesis}\]

Breadth as Search

The simplest interpretation of an agent swarm is parallel search over a solution space.
Let
\[p\]
- be the probability that one approximately independent agent finds a successful solution.
With \(N\) agents, the probability that at least one succeeds is
\[P_N = 1-(1-p)^N\]
For small \(p\),
\[P_N \approx Np\]
Thus, initially, increasing the number of independent attempts can approximately linearly increase the probability of finding a rare successful trajectory.
But the gain eventually saturates:
\[\lim_{N\rightarrow\infty}P_N=1\]
More importantly, real agents are not independent.
If every agent begins from the same model, prompt, tools, and context, their trajectories may be highly correlated.
Define an effective number of independent attempts
\[N_{\text{eff}} \le N\]
Then practical search behaves more like
\[P_N \approx 1-(1-p)^{N_{\text{eff}}}\]
The value of a swarm therefore depends heavily on diversity.

Diversity of Agent Rollouts

A useful swarm should explore meaningfully different parts of the search space.
Diversity can be introduced through different prompts, temperatures, tools, roles, retrieved evidence, starting hypotheses, or explicit assignments.
Let trajectory distribution for agent \(i\) be
\[\tau_i \sim P_i(\tau)\]
If
\[P_i(\tau) \approx P_j(\tau)\]
- for all agents, scaling the population mostly produces redundant work.
A better objective balances candidate quality and coverage:
\[\max_{\{\tau_i\}} \sum_i Q(\tau_i) + \lambda D( \tau_1,\ldots,\tau_N )\]
- where \(D\) measures diversity.
Scaling Test-time Compute for LLM Agents by Zhu et al. (2025) systematically studies test-time scaling for language agents across parallel sampling, sequential revision, verification and merging strategies, and rollout diversification. The study reports that diversified rollouts improve agent task performance and that the mechanism used to verify and merge parallel trajectories materially affects the resulting gains.
The implication for RSI is direct: additional agents are valuable when they expand useful search coverage, not merely when they reproduce the same reasoning many times.

Agent Specialization

Rather than making every agent identical, a research swarm can assign specialized roles.
Suppose the research problem is
\[q\]
A coordinator decomposes it into
\[q \rightarrow \{ q_1, q_2, \ldots, q_K \}\]
Specialized agents might perform different functions:
\[A_{\text{literature}}\]
- for prior-work retrieval,
  \[A_{\text{theory}}\]
  - for mathematical analysis,
    \[A_{\text{implementation}}\]
    - for coding,
      \[A_{\text{experiment}}\]
      - for execution,
        \[A_{\text{critic}}\]
        
        for adversarial review,
        
        and
        \[A_{\text{synthesis}}\]
        
        for integrating the results.
The system output becomes
\[y = A_{\text{synthesis}} \left( A_1(q_1), \ldots, A_K(q_K) \right)\]
Specialization can reduce interference between incompatible objectives and allow prompts, tools, context, and compute budgets to be optimized for each role.
For example, an implementation agent may require repository access and test execution, while a literature agent requires broad retrieval and citation tracking.

Hierarchical Research Organizations

Large swarms require organization.
A flat architecture with one coordinator communicating with every worker creates coordinator context proportional to
\[O(N)\]
At sufficiently large \(N\), the coordinator becomes the bottleneck.
Hierarchical decomposition replaces one large aggregation step with multiple levels.
Suppose branching factor is
\[b\]
A hierarchy supporting approximately
\[N=b^d\]
- workers requires depth
  \[d = \log_b N\]
Information can be progressively compressed:
\[\text{workers} \rightarrow \text{local summaries} \rightarrow \text{regional synthesis} \rightarrow \text{global synthesis}\]
This resembles organizational hierarchies, distributed computing systems, and tree-reduction algorithms.
However, compression introduces information loss.
If each level preserves fraction
\[\rho\]
- of decision-relevant information, after \(d\) aggregation levels the retained fraction is approximately
  \[\rho^d\]
Thus deeper hierarchies improve scalability while potentially losing subtle evidence.
The architecture must balance
\[\text{communication scalability} \quad\text{against}\quad \text{information preservation}\]

Map-Reduce Research

Many research tasks naturally admit a map-reduce structure.
The map stage distributes independent investigations:
\[q \rightarrow \{ q_1,\ldots,q_N \}\]
Workers return
\[r_i = A_i(q_i)\]
The reduce stage computes
\[R = \operatorname{Aggregate} ( r_1,\ldots,r_N )\]
Examples include searching a literature corpus, testing many candidate algorithms, evaluating different hyperparameters, generating independent proofs, running ablations, or exploring different failure hypotheses.
This architecture is highly parallelizable because dependencies among workers are sparse.
The key condition is approximately
\[I(q_i;q_j) \approx0\]
- where the work on subproblem \(q_i\) does not strongly depend on intermediate results from \(q_j\).
When this condition fails, multi-agent scaling becomes less effective.

The Parallelizability of a Task

A useful abstraction is to divide work into serial and parallel components.
Let fraction
\[s\]
- of the computation be inherently serial and fraction
  \[1-s\]
  - be parallelizable.
With \(N\) agents, an Amdahl-like upper bound on speedup is
\[S(N) = \frac{1} { s+\frac{1-s}{N} }\]
As
\[N\rightarrow\infty\]
- the maximum speedup becomes
  \[S_{\max} = \frac{1}{s}\]
If only ten percent of the workflow is inherently serial,
\[s=0.1\]
- then even unlimited parallel compute cannot produce more than approximately
  \[10\times\]
  - speedup under this simple model.
This explains why the structure of the task matters so much.
Brown describes mathematics and web research as relatively parallelizable, while suggesting that tasks such as writing a coherent novel are much less so. In his reported multi-agent experiments, four agents can sometimes produce roughly a twofold reduction in completion time, while larger populations continue to help but with declining efficiency. These observations are explicitly described as benchmark-dependent rather than universal scaling laws.

Sparse Dependencies Favor Swarms

A more precise view focuses on dependency structure.
Represent a task as directed acyclic graph
\[G_T=(V_T,E_T)\]
- where vertices are subtasks and edges indicate dependencies.
If the graph is broad and shallow, many vertices can execute simultaneously.
If it is narrow and deep, execution remains largely sequential.
The critical path length is
\[L_{\text{crit}} = \max_{p\in\mathcal{P}} \sum_{v\in p}T(v)\]
Even with unlimited agents, total latency cannot be less than approximately
\[L_{\text{crit}}\]
Recent work reinforces this structural view. Rethinking Multi-Agent Collaboration: When More Is Less by Yuan et al. (2026) reports that multi-agent collaboration is most beneficial on long-horizon tasks with relatively sparse dependencies, while tightly coupled sequential workflows can favor stronger single-agent harnesses. The paper also finds that simply increasing agent count or recursion depth does not consistently improve outcomes.
Thus,
\[\boxed{ \text{multi-agent scalability is primarily a property of task structure, not agent count alone}. }\]

Communication Overhead

Parallelism is not free.
Let useful work per agent be
\[W\]
Let communication overhead be
\[C(N)\]
Total efficiency can be approximated as
\[\eta(N) = \frac{NW} {NW+C(N)}\]
If every agent communicates with every other agent,
\[C(N) \propto N^2\]
Eventually,
\[C(N)\gg NW\]
- and additional agents reduce efficiency.
This motivates sparse communication graphs.
If each agent communicates with only
\[k\]
- neighbors,
  \[C(N) \propto Nk\]
  - which scales much more favorably when
    \[k\ll N\]
The challenge is ensuring that relevant information still reaches the agents that need it.

Context Fragmentation

Parallel agents also fragment information.
Suppose a single agent has complete context
\[C\]
After decomposition,
\[C \rightarrow \{ C_1,C_2,\ldots,C_N \}\]
Each agent operates on only part of the total information.
This can improve focus, but dependencies may be lost.
Let task-relevant information for subproblem \(i\) be
\[I_i\]
If
\[I_i\nsubseteq C_i\]
- the worker may make locally reasonable but globally inconsistent decisions.
The coordinator must therefore solve a routing problem:
\[C_i = R(C,q_i)\]
- where \(R\) retrieves the subset of shared state needed by worker \(i\).
Effective multi-agent systems require not just task decomposition but context decomposition.

Aggregation Is a First-Class Problem

Generating many solutions is useful only if the system can identify and combine the valuable ones.
Suppose workers produce
\[y_1,\ldots,y_N\]
A naive aggregator computes
\[y^* = \arg\max_i E(y_i)\]
This works when one candidate contains the complete answer.
Research tasks often require synthesis:
\[y^* = G( y_1,\ldots,y_N )\]
- where different workers contribute complementary evidence.
The aggregation problem can itself be difficult:
\[Q_G \ge Q_{\text{required to distinguish useful contributions}}\]
If the synthesizer cannot reliably evaluate the workers, scaling worker count can simply overwhelm it with additional text.
This creates an aggregation bottleneck:
\[N\uparrow \quad\Rightarrow\quad \text{candidate information}\uparrow\]
- but also
  \[N\uparrow \quad\Rightarrow\quad \text{synthesis difficulty}\uparrow\]
Large swarms therefore require hierarchical filtering, structured outputs, or machine-verifiable intermediate results.

Verification Makes Parallel Search More Valuable

The strongest swarm architectures combine parallel generation with inexpensive verification.
Suppose
\[N\]
- agents independently generate candidate programs
  \[p_1,\ldots,p_N\]
A test suite evaluates
\[r_i = V(p_i)\]
Selection becomes inexpensive:
\[p^* = \arg\max_i r_i\]
This architecture scales much better than one in which a human or another LLM must deeply inspect every candidate.
The effective value of parallelism therefore depends on verifier throughput:
\[\text{useful swarm scale} \lesssim \text{evaluation capacity}\]
If candidate generation grows faster than verification,
\[G(N)>V(N)\]
- a queue forms and additional agents cease to improve research throughput.
For RSI, scaling researchers therefore requires scaling evaluators at the same time.

Debate and Adversarial Roles

Not all multi-agent interaction needs to be cooperative synthesis.
Agents can be assigned adversarial roles:
\[A_{\text{proposer}}\]
- produces a claim,
  \[A_{\text{critic}}\]
  - searches for failures,
    - and
      \[A_{\text{judge}}\]
      - evaluates the exchange.
The loop becomes
\[\text{proposal} \rightarrow \text{critique} \rightarrow \text{revision} \rightarrow \text{judgment}\]
For research, one agent can defend hypothesis
\[H_1\]
- while another defends
  \[H_0\]
The agents are then incentivized to surface evidence the other side may overlook.
This is useful when correctness cannot be determined by a simple executable verifier.
However, adversarial discussion does not create an external truth signal by itself. If all agents share the same blind spot, debate may converge confidently on the same mistake.
Thus,
\[\text{multi-agent disagreement} \neq \text{independent grounding}\]
External evidence remains important.

Research Swarms as Hypothesis Portfolios

A research swarm can be viewed as a portfolio of hypotheses.
Suppose there are candidate directions
\[h_1,\ldots,h_N\]
Each has uncertain payoff
\[R_i\]
Instead of selecting one direction immediately, the system allocates small initial budgets
\[c_i^{(0)}\]
After observing preliminary results, it reallocates compute:
\[c_i^{(t+1)} = f( c_i^{(t)}, o_i^{(t)} )\]
Unpromising branches are terminated:
\[P(R_i>\tau\mid O_i) < \epsilon \Rightarrow \operatorname{Stop}(i)\]
Promising branches receive additional resources.
This creates a successive-halving style research process:
\[N \rightarrow \frac{N}{k} \rightarrow \frac{N}{k^2} \rightarrow \cdots \rightarrow \text{few high-value directions}\]
The architecture is substantially more compute-efficient than giving every hypothesis the full experimental budget.

Dynamic Agent Creation

A sophisticated swarm does not need a fixed population.
The coordinator can create agents when uncertainty or workload warrants them:
\[N_{t+1} = N_t + \operatorname{Spawn}(R_t)\]
An agent might spawn sub-agents when
\[\operatorname{Complexity}(q_i)>\tau\]
- or when several plausible branches need investigation.
Conversely, agents can terminate when
\[\operatorname{ExpectedValueRemaining}(q_i) < \epsilon\]
The population therefore becomes dynamic:
\[N=N(t)\]
This is closer to recursive task decomposition than ordinary parallel sampling.
An agent receives a problem, decomposes it, creates workers, and those workers may recursively create additional workers.
The resulting computation forms a tree or DAG rather than a fixed pool.

Recursive Delegation

Let agent
\[A_0\]
- receive task \(q\).
It creates children:
\[A_0(q) \rightarrow \{ A_1(q_1), A_2(q_2), \ldots \}\]
Each child may recursively decompose:
\[A_i(q_i) \rightarrow \{ A_{i1}(q_{i1}), A_{i2}(q_{i2}), \ldots \}\]
If branching factor is \(b\) and recursion depth is \(d\), the potential number of workers is approximately
\[N = \sum_{k=0}^{d}b^k = \frac{b^{d+1}-1}{b-1}\]
This grows rapidly.
Even modest
\[b\]
- and
  \[d\]
  - can produce large agent populations.
Consequently, recursive delegation requires strict budgets:
\[C_{\text{total}} \le C_{\max}\] \[N \le N_{\max}\] \[d \le d_{\max}\]
Without such constraints, delegation itself can become an uncontrolled source of compute consumption.

Measuring Swarm Efficiency

Raw task accuracy is insufficient for evaluating multi-agent systems.
Suppose single-agent performance is
\[Q_1\]
- at cost
  \[C_1\]
An \(N\)-agent system obtains
\[Q_N\]
- at cost
  \[C_N\]
Marginal quality gain is
\[\Delta Q_N = Q_N-Q_1\]
Compute efficiency can be expressed as
\[\eta_C = \frac{\Delta Q_N} {C_N-C_1}\]
Latency speedup is
\[S_L = \frac{L_1}{L_N}\]
Parallel efficiency can be approximated as
\[\eta_P = \frac{S_L}{N}\]
A swarm may improve quality while having poor compute efficiency:
\[Q_N>Q_1\]
- but
  \[\eta_C\ll1\]
This may still be desirable for exceptionally valuable research problems, but it is not equivalent to an efficient scaling law.
Brown’s discussion makes this distinction concrete: four agents can sometimes finish a task roughly twice as quickly, but doing so uses more total compute, and efficiency declines as the population grows.

Swarms and RSI Throughput

The relevance to RSI becomes clearer when the target metric is research throughput rather than benchmark accuracy.
Let one research agent discover validated improvements at rate
\[r\]
With \(N\) perfectly independent agents, ideal throughput would be
\[R_N = Nr\]
In practice,
\[R_N = N\eta(N)r\]
- where
  \[0<\eta(N)\le1\]
  - captures duplication, communication overhead, aggregation cost, resource contention, and dependency structure.
Recursive improvement becomes faster if
\[R_N>R_1\]
But the more important condition is whether improvements discovered by the swarm increase future swarm productivity.
Suppose iteration \(t\) has
\[R_t = N_t\eta_t r_t\]
An AI-discovered improvement may increase agent quality:
\[r_{t+1}>r_t\]
- or coordination:
  \[\eta_{t+1}>\eta_t\]
  - or feasible population size:
    \[N_{t+1}>N_t\]
Then
\[R_{t+1} > R_t\]
Multi-agent systems therefore provide several distinct channels for recursive amplification.

Improving the Swarm Itself

A research swarm can optimize not only the target AI model but its own organization.
Let swarm architecture be
\[H_t = ( N_t, G_t, R_t, P_t, A_t )\]
- where \(N_t\) is population size, \(G_t\) communication topology, \(R_t\) role assignment, \(P_t\) prompting and routing policy, and \(A_t\) aggregation strategy.
The swarm can propose
\[H_t' = H_t+\Delta H_t\]
Benchmarking gives
\[E(H_t')\]
If improved,
\[H_{t+1}=H_t'\]
The research organization itself becomes an optimization target:
\[\text{swarm} \rightarrow \text{research} \rightarrow \text{better swarm architecture} \rightarrow \text{better research}\]
This is an RSI loop even when the underlying model weights remain unchanged.

Organizational Self-Improvement

This observation broadens the meaning of recursive self-improvement.
An AI system’s effective capability depends not only on model parameters
\[\theta\]
- but also on organizational structure
  \[O\]
Thus
\[Q = f(\theta,O)\]
A system can improve through
\[\theta_t\rightarrow\theta_{t+1}\]
- through
  \[O_t\rightarrow O_{t+1}\]
  - or both.
An organizational improvement might discover that certain research tasks benefit from independent parallel agents, while others benefit from one long-running agent with uninterrupted context.
It might learn optimal branching factors, when to spawn critics, when to merge contexts, how much compute to allocate to each branch, or when parallelism is no longer worthwhile.
These are meta-level improvements to the process that generates improvements.

The Limits of Agent-Count Scaling

Agent populations should not be interpreted as an unlimited substitute for model capability.
Brown explicitly argues that the core driver of the large-scale results he discusses is the strength of the underlying general-purpose model, with multi-agent execution providing additional leverage rather than replacing that capability.
A simple decomposition is
\[Q_{\text{swarm}} = f( Q_{\text{base}}, N, \eta, V )\]
- where \(Q_{\text{base}}\) is individual agent capability, \(N\) population size, \(\eta\) coordination efficiency, and \(V\) verification quality.
If
\[Q_{\text{base}}\]
- is too low to generate useful hypotheses, increasing
  \[N\]
  - may simply produce more low-quality hypotheses.
Likewise, if
\[V\]
- cannot distinguish strong work from weak work, more agents can increase evaluator load without improving final quality.
This means
\[N\uparrow\]
- does not imply
  \[Q_{\text{swarm}}\uparrow\]
  - indefinitely.
The marginal gain can eventually become
\[\frac{\partial Q_{\text{swarm}}}{\partial N} \rightarrow0\]
- or even negative when coordination costs dominate.

Stronger Models Versus More Agents

Given fixed compute, an RSI system may face a resource-allocation choice:
\[\text{one stronger agent}\]
- versus
  \[\text{many weaker agents}\]
Let total compute budget be
\[C\]
One configuration allocates
\[C\]
- to a single long trajectory.
Another allocates
\[\frac{C}{N}\]
- to each of \(N\) agents.
The optimal choice depends on the task.
For deeply sequential reasoning,
\[Q_{\text{serial}}(C) > Q_{\text{parallel}} \left( N,\frac{C}{N} \right)\]
- may hold.
For broad search,
\[Q_{\text{parallel}} \left( N,\frac{C}{N} \right) > Q_{\text{serial}}(C)\]
- may hold.
A capable research system should therefore learn a routing policy:
\[\pi_{\text{compute}} ( \text{task features} ) \rightarrow ( N, \text{depth}, \text{topology} )\]
Choosing how to think becomes part of the reasoning problem itself.

Hybrid Serial-Parallel Reasoning

The strongest architecture is likely neither purely serial nor purely parallel.
A hybrid loop can alternate:
\[\text{serial planning} \rightarrow \text{parallel exploration} \rightarrow \text{serial synthesis} \rightarrow \text{parallel verification} \rightarrow \text{serial decision}\]
For example, a lead research agent first identifies five plausible explanations. Five teams investigate them in parallel. A synthesizer updates the research model. Additional agents independently test the leading conclusion. The lead agent then decides which experiment to run next.
Formally,
\[s_t \xrightarrow{\text{decompose}} \{ q_1,\ldots,q_N \} \xrightarrow{\text{parallel}} \{ r_1,\ldots,r_N \} \xrightarrow{\text{synthesize}} s_{t+1}\]
This pattern can repeat recursively.
The serial stages maintain global coherence. The parallel stages expand search breadth.

Agent Swarms as a Bridge to Faster RSI

Multi-agent systems matter for RSI because they can scale the labor available for AI research without waiting for a corresponding increase in single-agent speed.
Suppose one AI researcher operates at productivity
\[p\]
If the system can instantiate
\[N\]
- useful copies, total effective research capacity becomes
  \[P = Np\eta(N)\]
A subsequent model improvement increases per-agent productivity:
\[p\rightarrow p'\]
The gain is multiplied across the population:
\[\Delta P = N\eta(N)(p'-p)\]
Thus a capability improvement to one model can simultaneously improve every copy instantiated from that model.
This creates an important amplification mechanism unique to software-based researchers:
\[\boxed{ \text{improve one researcher} \rightarrow \text{improve every future copy of that researcher}. }\]
The marginal value of improving the base model can therefore grow with the number of economically useful copies.

From Agent Swarms to Research Populations

At sufficiently large scale, the natural unit of analysis may cease to be the individual agent.
The system becomes a research population
\[\mathcal{R}_t = \{ A_1,\ldots,A_N \}\]
- with shared memory
  \[M_t\]
  - shared evaluation infrastructure
    \[E_t\]
    - and a resource allocator
      \[C_t\]
The full research system is then
\[S_t = ( \mathcal{R}_t, M_t, E_t, C_t )\]
Improvement can occur in any component:
\[\mathcal{R}_t \rightarrow \mathcal{R}_{t+1}\] \[M_t \rightarrow M_{t+1}\] \[E_t \rightarrow E_{t+1}\] \[C_t \rightarrow C_{t+1}\]
This reframes RSI from a single model repeatedly rewriting itself into a distributed optimization process involving populations of model instances, persistent knowledge stores, evaluators, and adaptive orchestration.

The Scaling Condition for Research Swarms

A useful final abstraction separates the benefit of additional agents from the cost they introduce.
Let useful research output be
\[U(N)\]
- and total resource cost
  \[C(N)\]
Marginal scaling remains attractive while
\[\frac{\partial U}{\partial N} > \lambda \frac{\partial C}{\partial N}\]
- where \(\lambda\) represents the value assigned to compute, latency, and coordination resources.
At small scale, this inequality may strongly favor adding agents.
At larger scale,
\[\frac{\partial U}{\partial N}\]
- typically declines because of duplicated search, serial dependencies, communication overhead, context fragmentation, evaluator saturation, and aggregation bottlenecks.
The goal is therefore not maximal population size. It is maximal effective research throughput.
This gives the multi-agent RSI loop:
\[\boxed{ \text{stronger model} \rightarrow \text{more capable research agents} \rightarrow \text{larger effective research population} \rightarrow \text{more validated experiments} \rightarrow \text{faster AI improvement} \rightarrow \text{stronger model} }\]
Agent swarms can accelerate the loop by parallelizing the parts of AI research that admit independent exploration. Their effectiveness depends on task structure, diversity, communication topology, context routing, aggregation, and verification rather than raw agent count. The resulting systems point toward an RSI architecture in which intelligence is not only scaled within a model but multiplied across a dynamically organized population of researchers.

Recursive Amplification, Bottlenecks, and the Path to Open-Ended RSI

The preceding mechanisms establish that self-improvement is not a single algorithm. It can occur through deployment-time refinement, persistent agent and harness changes, self-generated training data, self-evaluation, automated research, and populations of research agents. The central question is what happens when these mechanisms are connected so that an improvement at one stage increases the system’s ability to produce subsequent improvements.
Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) draws the central distinction between bounded self-improvement, where a system improves against a largely fixed external objective, and open-ended RSI, where the machinery responsible for producing and evaluating improvements increasingly becomes part of the optimization loop. The survey concludes that current systems demonstrate substantial pieces of this process, while open-ended RSI remains constrained by grounding, collapse dynamics, verification, and compute.
The transition can be expressed as
\[S_t \xrightarrow{I_t} S_{t+1}\]
- where \(I_t\) is the improvement process.
Ordinary improvement requires
\[Q(S_{t+1})>Q(S_t)\]
Recursive improvement additionally requires that the successor improve the improvement process itself:
\[Q(I_{t+1})>Q(I_t)\]
The resulting coupled system is
\[(S_t,I_t) \rightarrow (S_{t+1},I_{t+1})\]
This is the essential recursive structure:
\[\boxed{ \text{improvement} \rightarrow \text{greater capacity for improvement} \rightarrow \text{better improvement} }\]

Capability Improvement Versus Improvement-Rate Improvement

It is useful to distinguish increasing capability from increasing the rate of capability growth.
Let
\[Q_t\]
- represent system capability.
Ordinary progress might follow
\[Q_{t+1} = Q_t+\Delta Q\]
- where the increment is approximately constant.
This produces linear growth:
\[Q_t = Q_0+t\Delta Q\]
Recursive amplification instead requires the size or efficiency of subsequent improvements to depend positively on prior capability:
\[\Delta Q_{t+1} = f(Q_{t+1})\]
- with
  \[\frac{\partial \Delta Q_{t+1}} {\partial Q_t} >0\]
A simple multiplicative model is
\[Q_{t+1} = Q_t(1+\alpha)\]
- giving
  \[Q_t = Q_0(1+\alpha)^t\]
This exponential model is useful for illustrating the intuition behind RSI, but it is not a realistic default model of an actual AI-development process. It assumes that the recursive gain
\[\alpha\]
- remains positive and roughly constant while ignoring changing research difficulty, compute requirements, evaluator quality, experiment latency, and other bottlenecks.
A more realistic model is
\[Q_{t+1} = Q_t + G_t - L_t\]
- where \(G_t\) represents gross gains produced by the self-improvement process and \(L_t\) represents losses, friction, failed experiments, regressions, and overhead.
Sustained self-improvement requires
\[G_t>L_t\]
Accelerating self-improvement requires the stronger condition
\[G_{t+1}-L_{t+1} > G_t-L_t\]
The distinction is fundamental. A system can improve itself repeatedly without entering an accelerating regime.

Improvement as a Production Function

AI progress depends on more than model intelligence.
A useful abstraction is
\[\Delta Q_t = F( R_t, C_t, D_t, E_t, H_t, T_t )\]
- where \(R_t\) is research capability, \(C_t\) compute, \(D_t\) data and experimental environments, \(E_t\) evaluation quality, \(H_t\) remaining human contribution, and \(T_t\) elapsed time or experimental latency.
AI can directly improve some of these variables.
For example,
\[R_t\uparrow\]
- through stronger research agents,
  \[E_t\uparrow\]
  - through better automated evaluators,
    - and effective
      \[C_t\uparrow\]
      - through improved kernels, compilers, scheduling, or algorithms.
But the variables need not improve at the same rate.
If one becomes limiting, then
\[\frac{\partial F}{\partial R_t} \rightarrow0\]
- even while research-agent capability continues to increase.
This creates bottleneck migration: solving one constraint moves the system toward the next.

Amdahl’s Law for AI Research

The effect can be understood through an analogy to parallel computing.
Suppose fraction
\[a\]
- of AI research can eventually be accelerated by AI, while fraction
  \[1-a\]
  - remains unaffected.
If AI accelerates the automatable fraction by factor
\[k\]
- the overall speedup is
  \[S(k) = \frac{1} { (1-a)+\frac{a}{k} }\]
As AI research capability becomes arbitrarily fast,
\[k\rightarrow\infty\]
- the maximum speedup approaches
  \[S_{\max} = \frac{1}{1-a}\]
Thus even extremely powerful research agents do not create unlimited acceleration if some necessary parts of the research process remain serial or externally constrained.
This is one useful interpretation of the friction emphasized in Lossy self-improvement by Nathan Lambert (2026). The important point for an RSI primer is not that recursive improvement is impossible, but that improvements must propagate through a heterogeneous research pipeline whose components may scale differently.

The Complexity Brake

Research difficulty itself may change as easier improvements are exhausted.
Let the cost of discovering the next improvement be
\[C_{\text{research}}(Q)\]
If increasingly capable systems expose increasingly difficult remaining problems,
\[\frac{dC_{\text{research}}}{dQ}>0\]
Suppose research capability grows as
\[R(Q)\]
The effective improvement rate depends on the ratio
\[\frac{R(Q)} {C_{\text{research}}(Q)}\]
Recursive acceleration requires research capability to improve faster than research difficulty:
\[\frac{d\log R(Q)}{dQ} > \frac{d\log C_{\text{research}}(Q)}{dQ}\]
If instead both grow at comparable rates, the system can continue improving without dramatic acceleration.
This provides a more precise way to formulate one of the core uncertainties around RSI. The existence of AI-assisted research does not determine the shape of the resulting capability curve. The answer depends on the scaling relationship between improving research capability and the difficulty of finding the next useful improvement.

Compute as Both Input and Improvement Target

Compute occupies a special role because it is both a constraint and something AI research can make more efficient.
Let effective compute be
\[C_{\text{eff}} = C_{\text{physical}}\eta\]
- where \(C_{\text{physical}}\) is available hardware and \(\eta\) is computational efficiency.
AI may not be able to immediately increase physical accelerator supply, but it can potentially improve
\[\eta\]
- through better algorithms, kernels, compilers, scheduling, quantization, memory management, and hardware design.
Thus
\[\eta_t \rightarrow \eta_{t+1}\]
- can produce
  \[C_{\text{eff},t+1} > C_{\text{eff},t}\]
  - without increasing physical compute.
This creates a recursive channel:
\[\text{AI research} \rightarrow \text{compute-efficiency improvement} \rightarrow \text{more effective AI compute} \rightarrow \text{more AI research}\]
However, physical resources still impose ceilings. Training runs consume chips, energy, networking capacity, fabrication capacity, and wall-clock time.
Algorithmic improvements can shift those constraints rather than eliminate them.

Experiment Latency

Research loops also encounter irreducible or partially reducible delays.
Let one improvement cycle require
\[T_{\text{cycle}} = T_{\text{proposal}} + T_{\text{implementation}} + T_{\text{training}} + T_{\text{evaluation}} + T_{\text{validation}}\]
Coding agents may reduce
\[T_{\text{implementation}}\]
- dramatically.
Research swarms may reduce
\[T_{\text{proposal}}\]
Automated evaluators may reduce
\[T_{\text{evaluation}}\]
But if
\[T_{\text{training}}\]
- dominates, the overall loop remains bounded by training latency.
The maximum number of serial generations of improvement within wall-clock interval \(T\) is approximately
\[N_{\text{iterations}} \le \frac{T} {T_{\text{cycle}}}\]
Parallel experiments can increase breadth, but they cannot eliminate dependencies where the next experiment requires the result of the previous one.

Verification as a Scaling Constraint

Verification creates another fundamental bottleneck.
Suppose candidate generation rate is
\[G_t\]
- and reliable verification capacity is
  \[V_t\]
If
\[G_t\le V_t\]
- most candidates can be meaningfully evaluated.
If
\[G_t\gg V_t\]
- the system accumulates an evaluation backlog.
Effective improvement throughput becomes approximately
\[R_t \le \min(G_t,V_t)\]
Increasing generation beyond this point has little value.
This means that a recursive system must improve verification alongside generation:
\[G_t\uparrow \quad\Rightarrow\quad V_t\uparrow\]
The problem becomes particularly difficult as the system reaches domains where correctness cannot be cheaply tested.
The strongest existing self-improvement results tend to occur where the evaluator is comparatively strong: code execution, games, formal mathematics, deterministic environments, and other domains with objective feedback. Chen et al. explicitly connect demonstrated self-improvement strength to this verification hierarchy.

Grounding and Exogenous Information

A completely closed system cannot necessarily manufacture all information required for further improvement.
Let the model’s internal information state be
\[K_t\]
Purely endogenous transformation gives
\[K_{t+1} = f(K_t)\]
The system can reorganize, combine, search, compress, and derive consequences from existing information, but many research advances require observations from outside the current state.
A more realistic loop is
\[K_{t+1} = f( K_t, O_t )\]
- where \(O_t\) represents external observations.
These can include experiment results, compiler outputs, benchmark measurements, simulator trajectories, sensor observations, newly retrieved documents, human feedback, or measurements from physical systems.
Grounding therefore does not prevent RSI. It changes its architecture.
The loop becomes
\[\text{internal generation} \rightarrow \text{external interaction} \rightarrow \text{observation} \rightarrow \text{learning}\]
Open-ended improvement is consequently better understood as an increasingly autonomous interaction with external sources of evidence rather than as pure introspection.

Self-Generated Data and Information Recycling

Training-time self-improvement introduces a related issue.
Suppose the model generates distribution
\[q_t(x)\]
- and subsequently trains on samples from that distribution.
Then
\[D_{t+1} \sim q_t\]
If this process repeatedly amplifies high-probability modes, distributional diversity may decline.
Entropy
\[H(q_t) = - \sum_x q_t(x)\log q_t(x)\]
- can decrease across generations:
  \[H(q_{t+1})<H(q_t)\]
The result is not necessarily immediate catastrophic collapse. More generally, the training distribution can progressively lose rare modes, alternative reasoning strategies, or information not favored by the current model.
Recent empirical work continues to find this issue in recursive code training. When AI Reviews Its Own Code: Recursive Self-Training Collapse in Code LLMs by Song et al. (2026) compares recursive code-model training under no review, model-independent gates, and AI self-gating. The study reports that self-gating can initially appear effective while eventually becoming less discriminating, illustrating why externally grounded quality control matters for recursive training.
A robust loop therefore benefits from continuing exogenous information:
\[D_t = D_t^{\text{self}} \cup D_t^{\text{external}}\]

Diversity as a Consumable Resource

Recursive search can also consume diversity even without retraining.
Suppose candidate population is
\[\mathcal{P}_t\]
Selection repeatedly retains candidates maximizing evaluator \(E\):
\[\mathcal{P}_{t+1} = \operatorname{Select}_E ( \mathcal{P}_t )\]
Over time,
\[\operatorname{Diversity} ( \mathcal{P}_{t+1} ) < \operatorname{Diversity} ( \mathcal{P}_t )\]
- may occur.
This can improve short-term performance while narrowing the set of future stepping stones.
A system searching for open-ended improvements should therefore optimize more than immediate reward:
\[J(c) = E(c) + \lambda N(c)\]
- where \(N(c)\) rewards novelty or behavioral diversity.
Population archives, island models, novelty search, independent research agents, and explicit exploration budgets all serve this function.
The deeper principle is
\[\boxed{ \text{the best current candidate need not be the best ancestor of future candidates}. }\]

Frame Lock-In

Even a stable, grounded, diverse self-improvement loop can continue optimizing the wrong abstraction.
Suppose objective is
\[E_t\]
The system becomes progressively better at maximizing
\[E_t(S)\]
But the objective itself may represent only a partial proxy for the broader intended outcome
\[U(S)\]
Then
\[E_t(S)\uparrow\]
- does not guarantee
  \[U(S)\uparrow\]
This differs from ordinary evaluator exploitation. The evaluator can be internally accurate and still encode a research frame that has become too narrow.
For example, a research system might become extraordinarily effective at improving one benchmark family while failing to notice that the benchmark no longer tracks the capability of interest.
Open-ended RSI therefore needs mechanisms not only for optimizing objectives but for reconsidering them:
\[E_t \rightarrow E_{t+1}\]
But changing the objective reintroduces the meta-evaluation problem:
\[\text{How is }E_{t+1}\text{ judged to be better than }E_t?\]
This is one of the places where fully closed RSI becomes conceptually difficult.

Direction-Setting Remains Prior to Verification

Automated verification answers
\[\text{"Did this intervention work?"}\]
- but research requires an earlier decision:
  \[\text{"Which intervention should be attempted?"}\]
Let
\[\mathcal{H}\]
- be the hypothesis space and
  \[\mathcal{H}^*\]
  - the subset containing important discoveries.
A research system samples
\[h \sim P_t(h)\]
Even with perfect verification, useful discovery depends on
\[P_t( h\in\mathcal{H}^* )\]
A sufficiently narrow proposal distribution can prevent discovery even when the evaluator is flawless.
Chen et al. characterize this as a distinction between the verification problem and the prior problem of research direction-setting.
Thus research capability can be decomposed approximately as
\[R = Q_{\text{proposal}} \times Q_{\text{execution}} \times Q_{\text{verification}}\]
If any factor is weak, overall research productivity is constrained.

Human Bottlenecks Can Move Rather Than Disappear

As AI automates implementation, experimentation, and analysis, human contribution may migrate toward less easily automated parts of the loop.
Initially:
\[\text{human} \rightarrow \text{idea} \rightarrow \text{code} \rightarrow \text{experiment} \rightarrow \text{analysis}\]
After coding automation:
\[\text{human} \rightarrow \text{idea} \rightarrow \boxed{\text{AI implementation}} \rightarrow \text{experiment} \rightarrow \text{analysis}\]
After experimental automation:
\[\text{human} \rightarrow \text{direction} \rightarrow \boxed{\text{AI research loop}}\]
The remaining human role may become concentrated in direction-setting, objective specification, adjudicating ambiguous evidence, resource allocation, and decisions about which discoveries matter.
This does not imply those tasks must remain permanently human. It means that loop closure should be measured by identifying where indispensable external decisions still enter the process.

Measuring Loop Closure

A binary label such as “self-improving” hides substantial differences among systems.
A useful decomposition is
\[L = ( L_{\text{proposal}}, L_{\text{execution}}, L_{\text{evaluation}}, L_{\text{commit}}, L_{\text{direction}} )\]
Each component can range from human-controlled to autonomous.
A coding agent might have high
\[L_{\text{execution}}\]
- but low
  \[L_{\text{direction}}\]
An evolutionary program search system might have high proposal, execution, evaluation, and commit autonomy inside a human-specified search problem.
A stronger RSI system would progressively increase all components while preserving reliable external grounding.
This makes loop closure measurable rather than rhetorical.

A Spectrum of Recursive Amplification

It is useful to distinguish several regimes.
In the first regime,
\[Q_{t+1}>Q_t\]
- but future improvement ability is unchanged.
This is ordinary self-improvement.
In the second,
\[Q_{t+1}>Q_t\]
- and
  \[R_{t+1}>R_t\]
  - but only modestly.
This is recursive amplification.
In the third,
\[\frac{R_{t+1}}{R_t}>1\]
- persistently enough that improvement cycles become increasingly rapid.
This is accelerating RSI.
In the strongest hypothetical regime,
\[\frac{R_{t+1}}{R_t}\]
- itself increases over time.
This corresponds to super-exponential improvement.
These regimes should not be conflated.
Evidence that AI accelerates AI research establishes some degree of feedback:
\[\text{AI} \rightarrow \text{AI research} \rightarrow \text{better AI}\]
It does not by itself establish the long-run functional form of that feedback.

Positive and Negative Feedback

The dynamics of RSI can be represented as competing feedback loops.
Positive feedback includes
\[\text{better model} \rightarrow \text{better coding} \rightarrow \text{faster experiments} \rightarrow \text{better model}\] \[\text{better model} \rightarrow \text{better evaluator} \rightarrow \text{better training signal} \rightarrow \text{better model}\]
- and
  \[\text{better model} \rightarrow \text{better algorithms} \rightarrow \text{more effective compute} \rightarrow \text{better model}\]
Negative feedback includes
\[\text{better model} \rightarrow \text{harder remaining problems}\] \[\text{more agents} \rightarrow \text{greater coordination overhead}\] \[\text{more optimization} \rightarrow \text{greater evaluator exploitation}\]
- and
  \[\text{more self-generated data} \rightarrow \text{greater distributional dependence}\]
Net recursion depends on their balance:
\[R_{t+1} = R_t + F_t^{+} - F_t^{-}\]
The central empirical question is therefore
\[F_t^{+} \overset{?}{>} F_t^{-}\]
- and how that relationship changes as capability grows.

Why Software Is an Early RSI Domain

Software engineering has unusually favorable properties for recursive improvement.
The artifact is digital:
\[\text{code}\in\text{machine-readable state}\]
Modification is cheap:
\[C_{\text{edit}}\ll C_{\text{physical redesign}}\]
Execution is automated:
\[p \rightarrow \operatorname{Run}(p)\]
Feedback can often be machine-generated:
\[p \rightarrow \text{tests, benchmarks, traces}\]
Successful changes can immediately become part of the next agent:
\[A_t+\Delta A_t \rightarrow A_{t+1}\]
This creates short feedback loops with relatively strong verification.
The same properties explain why coding agents, evolutionary program search, self-modifying harnesses, and automated algorithm discovery appear repeatedly in current RSI research.

Why AI Research Is a Particularly Important Target

Improving arbitrary software produces local benefits.
Improving AI-research software can have multiplicative downstream effects.
Suppose one improvement increases AI-research productivity by
\[\alpha\]
If future research output is proportional to productivity,
\[R_{t+1} = (1+\alpha)R_t\]
If those future discoveries also improve research productivity, the effect compounds.
This is why AI systems working on AI research are structurally different from AI systems optimizing unrelated industrial processes.
The output feeds back into the mechanism generating future outputs:
\[\boxed{ \text{AI} \rightarrow \text{AI research} \rightarrow \text{AI} }\]
The degree of recursion then depends on how much of the research pipeline the resulting AI can improve.

A Practical Path Toward Open-Ended RSI

Rather than requiring one sudden transition, the literature supports a staged path.
The first stage is bounded output refinement:
\[y_t\rightarrow y_{t+1}\]
The second adds persistent skills and harness changes:
\[H_t\rightarrow H_{t+1}\]
The third updates model policies through self-generated experience:
\[\theta_t\rightarrow\theta_{t+1}\]
The fourth improves evaluators:
\[E_t\rightarrow E_{t+1}\]
The fifth automates research:
\[R_t\rightarrow R_{t+1}\]
The sixth allows research improvements to modify the mechanisms responsible for subsequent research:
\[(R_t,S_t) \rightarrow (R_{t+1},S_{t+1})\]
The final step toward open-ended RSI is not simply greater autonomy. It is increasingly comprehensive closure of the causal loop between current capability and the process that produces future capability.

The Open-Ended RSI Condition

A useful conceptual definition is that an RSI system must satisfy four properties over repeated iterations.
First, improvement must be persistent:
\[Q(S_{t+1})>Q(S_t)\]
Second, the system must materially participate in producing the improvement:
\[S_t \in \operatorname{Cause}(S_{t+1})\]
Third, improvement must increase future improvement capacity:
\[R(S_{t+1})>R(S_t)\]
Fourth, this relationship must persist across multiple generations rather than appearing as a one-time optimization:
\[R(S_{t+k})>R(S_t)\]
- for meaningful
  \[k>1\]
Open-ended RSI adds the requirement that the system is not permanently confined to one fixed improvement target or narrow evaluator.
Its search process must be capable of modifying
\[\text{what is improved}\] \[\text{how improvement is produced}\]
- and eventually
  \[\text{how improvement is evaluated}\]
That is a substantially stronger requirement than self-training or self-refinement.

What Evidence Would Demonstrate Strong RSI?

Claims of RSI should therefore be evaluated using longitudinal rather than single-generation evidence.
A convincing experiment would begin with system
\[S_0\]
It would allow the system to produce successor
\[S_1\]
Then, critically, \(S_1\) rather than \(S_0\) would perform the next improvement cycle:
\[S_1 \rightarrow S_2\]
This continues:
\[S_0 \rightarrow S_1 \rightarrow S_2 \rightarrow \cdots \rightarrow S_n\]
At each generation, one should measure both capability
\[Q_t\]
- and improvement productivity
  \[R_t\]
Evidence for recursive amplification requires
\[Q_{t+1}>Q_t\]
- and
  \[R_{t+1}>R_t\]
  - across multiple generations.
The evaluation should additionally use held-out or externally grounded measures so that apparent progress cannot be explained merely by adapting to the benchmark.
This type of experiment is more informative than showing that a model can improve one descendant once.

Toward an Empirical Science of RSI

RSI ultimately needs measurable quantities rather than only conceptual categories.
Relevant measurements include improvement magnitude,
\[\Delta Q_t = Q_{t+1}-Q_t\]
- improvement rate,
  \[R_t = \frac{\Delta Q_t}{\Delta t}\]
  - recursive gain,
    \[g_t = \frac{R_{t+1}}{R_t}\]
    - human dependence,
      \[H_t = \frac{\text{critical human interventions}} {\text{improvement cycle}}\]
      - verification independence,
        \[V_t = P( \text{evaluation remains correct under optimization} )\]
        
        and compute efficiency,
        \[\eta_t = \frac{\Delta Q_t}{C_t}\]
A system exhibiting strong RSI should ideally show
\[\Delta Q_t>0\] \[g_t>1\] \[H_t\downarrow\]
- while maintaining
  \[V_t\]
  - and avoiding unbounded growth in
    \[C_t\]
This turns RSI from a qualitative claim into a testable research program.

The Central Open Question

Current systems establish several important ingredients: models can refine their own outputs, generate useful training data, participate in their own evaluation, modify persistent agent scaffolding, search over executable programs, automate substantial portions of research workflows, and operate in parallel research populations.
What remains unresolved is the composition of these capabilities.
The central question is not whether each component can work independently. It is whether they can be connected into a stable system where
\[\text{improvement capability}\]
- grows faster than
  \[\text{research difficulty} + \text{verification difficulty} + \text{coordination cost} + \text{resource constraints}\]
In compact form:
\[\boxed{ \frac{d\,\text{capacity to improve}} {dt} > \frac{d\,\text{difficulty of further improvement}} {dt} }\]
- over sufficiently many generations.
If this inequality holds persistently, recursive amplification can become increasingly strong.
If the two sides rise together, substantial self-improvement may occur without runaway acceleration.
If bottlenecks rise faster, the loop converges toward a new capability frontier.
This framing makes the empirical question clearer. Recursive self-improvement is not determined merely by whether an AI can edit its own code or train a successor. It depends on the dynamics of the entire improvement system.
The final architecture is therefore best represented not as a model modifying itself in isolation, but as a coupled ecosystem:
\[\boxed{ \begin{aligned} &\text{Models} \rightarrow \text{Agents} \rightarrow \text{Research}\\ &\qquad\downarrow \hspace{2.5em} \downarrow \hspace{2.5em} \downarrow\\ &\text{Training} \leftarrow \text{Evaluation} \leftarrow \text{Experiments}\\ &\qquad\downarrow\\ &\text{Successor models} \rightarrow \text{better agents} \rightarrow \text{better research}. \end{aligned} }\]
Whether that ecosystem becomes open-ended depends on how effectively its positive feedback loops overcome its moving bottlenecks.
The next and final section can therefore focus specifically on the challenges, failure modes, safety considerations, and open research questions that determine whether such a system remains stable as the loop closes.

Challenges, Safety, and Open Research Questions

The technical case for recursive self-improvement rests on a feedback loop: AI systems increasingly participate in generating, evaluating, and implementing the changes that produce their successors. The same feedback structure that makes RSI potentially powerful also makes errors persistent. A mistake in an ordinary inference disappears when the episode ends; a mistake admitted into training data, persistent memory, an evaluator, or a shared agent scaffold can influence subsequent generations.
Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops by Chen et al. (2026) organizes these concerns around several recurring failure modes: self-confirming evaluation loops, model and diversity collapse, persistent corruption, safety drift, weak verification, and the unresolved problem of research direction-setting. It also notes an imbalance in the literature: only 60 of the 1,250 papers surveyed fall into the foundations, limits, and safety category.
The underlying difficulty can be summarized as
\[\text{recursive capability} \quad\text{requires}\quad \text{recursive quality control}\]
If the capability-generation process improves faster than the mechanisms validating it, the reliability of the overall loop can deteriorate even while measured performance rises.

Error Amplification Across Generations

Consider a sequence of systems
\[S_0 \rightarrow S_1 \rightarrow S_2 \rightarrow \cdots\]
Suppose each successor inherits information from its predecessor.
Let
\[e_t\]
- represent an error introduced at generation \(t\).
If the error affects only one output,
\[e_t \rightarrow \varnothing\]
- after the episode.
But if it is incorporated into persistent state,
\[e_t \rightarrow M_{t+1}\]
- where \(M\) might be memory, training data, evaluator state, code, or a reusable skill.
Future systems can then inherit it:
\[e_t \rightarrow S_{t+1} \rightarrow S_{t+2} \rightarrow \cdots\]
The risk is therefore determined partly by persistence.
A useful abstraction is
\[R_{\text{error}} \propto P_{\text{accept}} \times P_{\text{persist}} \times P_{\text{propagate}} \times I_{\text{downstream}}\]
- where the terms represent the probability of accepting the error, storing it, propagating it to successors, and the impact of that propagation.
This explains why persistent self-modification demands stronger validation than ordinary inference-time refinement.

Self-Confirming Loops

One of the most important RSI failure modes occurs when the generator and evaluator share correlated errors.
Suppose generator
\[G\]
- produces candidate
  \[c\]
Evaluator
\[E\]
- assigns score
  \[r=E(c)\]
The candidate is then used to improve the generator:
\[G_{t+1} = U(G_t,c,r)\]
If both systems share bias
\[b\]
- then an error caused by
  \[b\]
  - may also be approved because of
    \[b\]
The loop becomes
\[\text{shared error} \rightarrow \text{incorrect output} \rightarrow \text{positive evaluation} \rightarrow \text{training reinforcement}\]
Instead of correcting the mistake, recursion increases its confidence.
Chen et al. identify these self-confirming loops as a characteristic consequence of weak verification in self-improvement systems.
The key issue is correlation:
\[P( E\text{ misses error} \mid G\text{ makes error} )\]
- can be substantially larger than
  \[P( E\text{ misses random error} )\]
This is why simply using a second instance of the same model as a judge does not necessarily provide independent verification.

Evaluator Independence

One mitigation is to increase independence between generator and evaluator.
Suppose the generator is
\[G_\theta\]
- and evaluator
  \[E_\phi\]
If their error correlation is
\[\rho_{GE}\]
- a robust evaluation architecture seeks
  \[\rho_{GE}\downarrow\]
Independence can come from different models, independently generated tests, external execution environments, formal verifiers, human audits, separately trained reward models, or empirical measurements.
The strongest architecture separates
\[\text{generation}\]
- from
  \[\text{verification}\]
For example,
\[\text{LLM-generated code} \rightarrow \text{independent compiler and tests}\]
The verifier does not need to reproduce the model’s reasoning. It only needs to determine whether the artifact satisfies externally defined constraints.
This is why verifiable domains provide particularly strong environments for self-improvement.

Evaluator Exploitation

Even an evaluator that works well initially can become unreliable under sustained optimization.
Suppose true utility is
\[U(c)\]
- and evaluator score is
  \[E(c)\]
Let
\[E(c) = U(c)+\epsilon(c)\]
- where \(\epsilon\) represents evaluator error.
During weak optimization, candidates may encounter approximately random values of
\[\epsilon\]
Under strong optimization,
\[c^* = \arg\max_c E(c)\]
- the search process actively discovers regions where
  \[\epsilon(c)\]
  - is unusually positive.
Thus
\[E(c^*)\gg U(c^*)\]
- can emerge even if the evaluator is accurate on ordinary samples.
This is a general optimization phenomenon: the stronger the optimizer, the more aggressively it probes evaluator imperfections.
RSI intensifies this because the optimizer itself may improve:
\[G_t \rightarrow G_{t+1}\]
An evaluator sufficient for generation \(t\) may therefore become inadequate at generation \(t+1\).
The evaluation system must evolve at least as quickly as the optimization pressure applied to it.

Verification Debt

This suggests the concept of verification debt.
Let optimization capability be
\[O_t\]
- and evaluator robustness be
  \[V_t\]
Define verification debt informally as
\[D_t = O_t-V_t\]
If
\[D_t\le0\]
- verification capacity approximately keeps pace with optimization.
If
\[D_t>0\]
- the system can search more effectively than the evaluator can reliably distinguish genuine improvements from exploits.
Recursive improvement becomes increasingly fragile as
\[D_t\]
- grows.
A safe engineering principle is therefore
\[\boxed{ \Delta V_t \gtrsim \Delta O_t }\]
- over successive improvement cycles.
Capability scaling without corresponding evaluator scaling accumulates verification debt.

Model Collapse

Training on recursively generated data introduces a different feedback problem.
Let the original data distribution be
\[p_0(x)\]
A model trained on it generates
\[q_1(x)\]
A successor trains increasingly on
\[q_1(x)\]
- producing
  \[q_2(x)\]
Repeated recursively:
\[p_0 \rightarrow q_1 \rightarrow q_2 \rightarrow \cdots\]
If each generation imperfectly approximates the preceding distribution, rare modes can progressively disappear.
Suppose mode
\[x_i\]
- has probability
  \[p_t(x_i)\]
If
\[p_t(x_i)\]
- becomes sufficiently small, finite sampling may omit it entirely:
  \[n p_t(x_i)\ll1\]
Once absent from the generated training set,
\[p_{t+1}(x_i)\approx0\]
Information can therefore be lost asymmetrically: common patterns are repeatedly reproduced while rare patterns vanish.
The broader survey identifies model collapse as one of the characteristic failure modes of insufficiently grounded recursive training.

Diversity Collapse

Even when average performance improves, the search process can become less diverse.
Let population
\[\mathcal{P}_t\]
- contain candidate strategies.
Define diversity measure
\[D(\mathcal{P}_t)\]
Strong selection pressure can produce
\[D(\mathcal{P}_{t+1}) < D(\mathcal{P}_t)\]
Eventually, most candidates may descend from the same narrow family:
\[\mathcal{P}_t \rightarrow \text{local basin}\]
This can create excellent performance on the current objective while reducing the probability of discovering qualitatively different improvements.
The problem is particularly important for open-ended RSI because innovation frequently requires temporarily preserving ideas that do not maximize immediate reward.
A broader objective can include novelty:
\[J(c) = Q(c) + \lambda N(c)\]
- where
  \[N(c)\]
  - measures novelty relative to the current population.
Other mechanisms include island populations, quality-diversity archives, independent agent populations, stochastic parent selection, and explicit exploration budgets.
The objective is not diversity for its own sake. It is preserving useful stepping stones.

Catastrophic Forgetting Across Improvement Cycles

A successor may improve one capability while degrading another.
Suppose capability vector is
\[\mathbf{Q}_t = ( q_t^{(1)}, q_t^{(2)}, \ldots, q_t^{(k)} )\]
An update might produce
\[q_{t+1}^{(1)} > q_t^{(1)}\]
- while
  \[q_{t+1}^{(j)} < q_t^{(j)}\]
  - for several other dimensions.
If the evaluator primarily measures the first capability, the system may classify the update as an improvement despite broad regressions.
This motivates regression constraints:
\[q_{t+1}^{(j)} \ge q_t^{(j)}-\epsilon_j\]
- for protected capabilities.
A candidate successor should therefore be evaluated on both target gains and preservation metrics:
\[\operatorname{Accept}(S') = \mathbb{1} [ \Delta Q_{\text{target}}>\tau \land \Delta Q_{\text{protected}}\ge-\epsilon ]\]
The protected set should include safety properties as well as capability metrics.

Safety Drift Without an Adversary

Safety degradation need not require a system intentionally trying to remove safeguards.
Suppose total optimization objective is
\[J = Q_{\text{task}} - \lambda C_{\text{constraint}}\]
A modification that improves task performance but slightly weakens a safety constraint may still appear favorable if the evaluator underweights that degradation.
Across many iterations,
\[\delta_1+\delta_2+\cdots+\delta_n\]
- can produce substantial drift even if every individual change appears small.
The relevant failure mode is therefore cumulative:
\[S_0 \xrightarrow{\text{small acceptable change}} S_1 \xrightarrow{\text{small acceptable change}} \cdots \xrightarrow{} S_n\]
No single transition needs to look alarming.
This makes longitudinal evaluation necessary.
Safety properties should be measured as trajectories:
\[Q_{\text{safety}}(t)\]
- rather than only as pass/fail tests on the latest candidate.

Persistent Corruption

Persistent agent systems introduce another risk: corrupted information can enter reusable memory or skill stores.
Suppose shared skill library is
\[\mathcal{L}_t\]
Agent \(A_i\) proposes skill
\[s\]
If accepted,
\[\mathcal{L}_{t+1} = \mathcal{L}_t\cup\{s\}\]
Future agents retrieve from
\[\mathcal{L}_{t+1}\]
An incorrect skill can therefore affect many future trajectories.
If skill stores are shared across a population,
\[s_{\text{bad}} \rightarrow A_1,A_2,\ldots,A_N\]
Chen et al. highlight this accumulation-without-verification problem as especially important for persistent self-evolving agent systems: errors in transient outputs disappear, while corrupted persistent artifacts can propagate through the population.
The admission threshold for persistent knowledge should consequently be higher than the threshold for ephemeral reasoning.

Trustworthy Accumulation

A robust system should distinguish between candidate knowledge and trusted knowledge.
Let
\[\mathcal{M}^{\text{candidate}}\]
- contain newly discovered artifacts.
Only after validation should an artifact move to
\[\mathcal{M}^{\text{trusted}}\]
The transition is
\[s \in \mathcal{M}^{\text{candidate}} \xrightarrow{V(s)} \mathcal{M}^{\text{trusted}}\]
The verifier might require repeated success:
\[V(s) = \mathbb{1} [ n_{\text{success}}\ge k \land n_{\text{regression}}=0 ]\]
Higher-risk artifacts can require stronger evidence.
The same principle applies to memory, skills, prompts, source-code changes, evaluator modifications, datasets, and model checkpoints.
Persistence should be earned through validation.

Provenance

Every persistent improvement should retain provenance.
For artifact
\[a\]
- store metadata
  \[P(a) = ( \text{creator}, \text{parent}, \text{evidence}, \text{tests}, \text{timestamp}, \text{dependencies} )\]
This creates an improvement lineage:
\[a_0 \rightarrow a_1 \rightarrow a_2 \rightarrow \cdots\]
If a downstream failure is discovered, the system can trace which descendants depend on the faulty artifact.
Without provenance, recursive systems lose the ability to distinguish
\[\text{newly introduced error}\]
- from
  \[\text{inherited error}\]
Provenance is therefore not merely observability infrastructure. It is part of the verification architecture.

Reversibility and Rollback

Self-improvement should not imply irreversible replacement.
Maintain checkpoint sequence
\[S_0,S_1,\ldots,S_t\]
A candidate successor
\[S_{t+1}'\]
- is first deployed in a restricted environment.
If regression is detected,
\[S_{t+1}' \rightarrow S_t\]
The architecture should preserve the ability to restore earlier states even if the current agent prefers the new state.
A basic commit protocol is
\[\text{propose} \rightarrow \text{sandbox} \rightarrow \text{evaluate} \rightarrow \text{canary} \rightarrow \text{commit}\]
The stronger the persistence of the modification, the more important rollback becomes.

Sandboxing Self-Modification

Current self-modifying systems generally constrain what can be changed.
Instead of giving the agent unrestricted access to
\[S\]
- define mutable subset
  \[\mathcal{M} \subset S\]
  - and immutable or separately controlled subset
    \[\mathcal{I} = S\setminus\mathcal{M}\]
The agent can propose
\[\Delta\mathcal{M}\]
- but cannot directly modify
  \[\mathcal{I}\]
This creates architectural separation between the self-improvement mechanism and critical controls.
For example,
\[\mathcal{M} = \{ \text{prompts}, \text{tools}, \text{skills}, \text{workflow code} \}\]
- while
  \[\mathcal{I}\]
  - might contain authorization boundaries, resource limits, audit logging, deployment gates, or other external controls.
The deeper requirement is that a self-modifying system should not automatically inherit authority over every mechanism constraining it.

Capability and Authority Should Be Separated

A crucial architectural distinction is between what an agent can reason about and what it is authorized to change.
Let capability be
\[C(A)\]
- and authority be
  \[P(A)\]
Increasing
\[C(A)\]
- does not require increasing
  \[P(A)\]
  - at the same rate.
A system may be capable of proposing a new training pipeline without being authorized to deploy it.
Thus
\[\text{proposal capability} \neq \text{deployment authority}\]
This separation permits increasingly capable research agents while retaining external approval boundaries for consequential actions.

Immutable Evaluation Channels

If a system can modify both candidate and evaluator simultaneously, evaluation loses its role as an independent reference.
Suppose
\[S_t\]
- proposes both
  \[S_{t+1}\]
  - and
    \[E_{t+1}\]
Then apparent improvement
\[E_{t+1}(S_{t+1}) > E_t(S_t)\]
- is difficult to interpret because the measurement scale changed.
A safer architecture retains an external evaluation channel
\[E_{\text{anchor}}\]
- that the candidate cannot modify.
Then
\[E_{\text{anchor}}(S_{t+1}) > E_{\text{anchor}}(S_t)\]
- provides a stable comparison.
The self-improving evaluator can still evolve:
\[E_t\rightarrow E_{t+1}\]
- but its quality is assessed against
  \[E_{\text{anchor}}\]
This creates a hierarchy of evaluators rather than a fully self-referential loop.

Meta-Evaluation

Eventually even external evaluators may become outdated.
The system therefore needs mechanisms for evaluating evaluators.
Let evaluator performance be
\[Q_E = f( \text{accuracy}, \text{calibration}, \text{robustness}, \text{coverage} )\]
Meta-evaluation uses independently labeled or otherwise grounded tasks:
\[D_{\text{meta}} = \{ (c_i,u_i) \}\]
- where
  \[u_i\]
  - represents trusted reference judgments.
Evaluator error is
\[L_E = \frac{1}{N} \sum_i \ell( E(c_i), u_i )\]
A new evaluator should be accepted only if
\[L_{E_{t+1}} < L_{E_t}\]
- on sufficiently independent meta-evaluation.
This creates
\[\text{generator} \rightarrow \text{evaluator} \rightarrow \text{meta-evaluator}\]
But recursion can continue:
\[\text{Who evaluates the meta-evaluator?}\]
At some point the chain must terminate in a trusted external signal, formal guarantee, empirical observation, or human judgment.
This is the grounding problem in another form.

Research Integrity

Automated research introduces failure modes analogous to scientific misconduct even when no deliberate deception is involved.
A research agent optimizing for publishable or benchmark-improving results may repeatedly try experiments until one succeeds.
Suppose
\[N\]
- independent null hypotheses are tested at significance threshold
  \[\alpha\]
The probability of at least one false positive is
\[1-(1-\alpha)^N\]
As
\[N\]
- grows,
  \[P(\text{false positive})\rightarrow1\]
Large research swarms can conduct enormous numbers of experiments, making this problem especially important.
Automated science therefore needs experiment registries, multiple-testing correction, replication, held-out tests, and explicit recording of failed experiments.
Otherwise, scaling experimentation can scale false discovery.

Benchmark Overfitting

An RSI system repeatedly evaluated on the same benchmark can optimize specifically for that benchmark.
Let training process observe feedback from
\[B\]
After many generations,
\[S_t\]
- has indirectly received substantial information about
  \[B\]
Even if benchmark examples never appear directly in training,
\[B\]
- has become part of the optimization environment.
Performance
\[Q_B(S_t)\]
- can therefore diverge from general capability
  \[Q_{\text{general}}(S_t)\]
A stronger protocol uses evolving held-out evaluation:
\[B_1,B_2,\ldots,B_k\]
- with some benchmarks inaccessible to the improvement loop.
The system should periodically encounter genuinely novel evaluations.

Distribution Shift in Evaluators

As the generator improves, the evaluator sees candidates outside its original training distribution.
Let evaluator training distribution be
\[p_0(c)\]
At generation \(t\), candidates come from
\[p_t(c)\]
The divergence
\[D_{\mathrm{KL}} ( p_t \Vert p_0 )\]
- may increase over time.
Evaluator accuracy can consequently fall:
\[A_E(p_t) < A_E(p_0)\]
This creates an important recursive asymmetry: improving the generator automatically shifts the evaluator’s input distribution.
Evaluator retraining, adversarial testing, calibration monitoring, and held-out validation must therefore be continuous rather than one-time procedures.

The Non-Verifiable Frontier

Some of the hardest domains for RSI lack strong objective evaluators.
Examples include research taste, open-ended scientific importance, architecture elegance, long-term strategic usefulness, creative quality, and deciding which unexplored problem is worth solving.
These judgments cannot generally be reduced to
\[V(c)\in\{0,1\}\]
Instead,
\[E(c)\]
- may be uncertain, subjective, delayed, or dependent on information unavailable at evaluation time.
Chen et al. identify progress on “verifying the non-verifiable” as a central open problem because direction-setting sits near the frontier where the verification hierarchy becomes weakest.
This may ultimately be more important than making generators stronger.

Research Taste as a Learned Prior

One way to formalize research taste is as a prior over directions.
Let
\[h\in\mathcal{H}\]
- be a possible research hypothesis.
Research taste determines
\[P(h\mid K)\]
- where \(K\) is current knowledge.
A strong research prior assigns high probability to directions with large expected downstream value:
\[P( h\mid K ) \propto \operatorname{ExpectedResearchValue}(h)\]
But that value may only become apparent much later.
This creates delayed credit assignment:
\[h_t \rightarrow \text{experiments} \rightarrow \text{new methods} \rightarrow \cdots \rightarrow R_{t+k}\]
Learning research taste therefore requires connecting long-horizon outcomes back to earlier direction-setting decisions.
This remains substantially less developed than learning to solve problems whose correctness can be immediately verified.

Stability Engineering

A mature RSI field will need to treat improvement loops as dynamical systems.
Let system state be
\[z_t\]
Recursive improvement produces
\[z_{t+1} = F(z_t)\]
Possible behaviors include convergence:
\[z_t\rightarrow z^*\]
- oscillation:
  \[z_{t+k}\approx z_t\]
  - divergence:
    \[\lVert z_t\rVert\rightarrow\infty\]
    - or collapse into a low-diversity attractor.
Local stability around fixed point
\[z^*\]
- depends on the Jacobian
  \[J_F(z^*)\]
A standard discrete-system stability condition is
\[\rho( J_F(z^*) ) <1\]
- where
  \[\rho\]
  - is the spectral radius.
The exact formalism will vary across systems, but the conceptual point is important: recursive learning systems have dynamics, and those dynamics can be measured.
Chen et al. identify stability engineering as an open research area, noting that rise-and-collapse behavior, diversity collapse, and safety drift are currently often studied separately rather than as manifestations of a common dynamical problem.

Detecting Collapse Before It Happens

A useful RSI system should monitor leading indicators rather than wait for benchmark failure.
Potential signals include
\[H(D_t)\]
- for data diversity,
  \[D_{\mathrm{KL}} ( p_t\Vert p_{t-1} )\]
  - for distributional drift,
    \[\rho_{GE}\]
    - for generator-evaluator error correlation,
      \[Q_{\text{heldout}}\]
      - for external generalization,
        
        and
        \[Q_{\text{safety}}\]
        
        for protected behavior.
A monitoring vector can be defined as
\[m_t = ( Q_t, H_t, D_t, V_t, S_t )\]
Rather than committing whenever target capability increases, require
\[m_{t+1} \in \mathcal{R}_{\text{acceptable}}\]
- where
  \[\mathcal{R}_{\text{acceptable}}\]
  - defines an acceptable operating region.
This converts recursive improvement from unconstrained hill climbing into constrained optimization.

Improvement Under Constraints

The system’s objective can be written as
\[\max_{\Delta S} Q(S+\Delta S)\]
- subject to
  \[C_i(S+\Delta S)\le\tau_i\]
  - for critical constraints
    \[i=1,\ldots,k\]
These constraints might cover compute, latency, reliability, safety, interpretability, evaluator robustness, or deployment authority.
A candidate that produces a large capability gain but violates one critical constraint is rejected.
This architecture is more appropriate for RSI than optimizing a single scalar reward because recursive systems operate across many dimensions that should not be freely traded against one another.

Human Oversight as an External Anchor

Human involvement is often described as evidence that a loop is incomplete. From an engineering perspective, however, human oversight can serve as an independent evaluation channel precisely where automated verification is weak.
Let automated evaluator be
\[E_A\]
- and human evaluator
  \[E_H\]
For ordinary low-risk candidates,
\[E_A\]
- may be sufficient.
Escalation occurs when
\[\operatorname{Uncertainty}(E_A)>\tau\]
- or
  \[\operatorname{Impact}(c)>\kappa\]
Then
\[c\rightarrow E_H\]
This produces risk-adaptive oversight rather than requiring humans to inspect every iteration.
As automated evaluators improve, the fraction requiring escalation can decrease:
\[P( \text{human review} ) \downarrow\]
Loop closure can therefore progress gradually rather than requiring an abrupt removal of human oversight.

Governance-Grade Measurement

The survey identifies governance-grade measurement of self-improvement as a particularly underdeveloped area.
A deployment-relevant RSI measurement system should distinguish between ordinary capability gains and gains specifically attributable to AI participating in its own improvement.
Let baseline research productivity without AI self-improvement be
\[R_{\text{base}}\]
Let observed productivity be
\[R_{\text{AI}}\]
The attributable acceleration is
\[A = \frac{R_{\text{AI}}} {R_{\text{base}}}\]
But productivity alone is insufficient.
Measurement should also track autonomy:
\[L_{\text{closure}}\]
- persistence:
  \[P_{\text{persist}}\]
  - recursive gain:
    \[g_t\]
    - verification strength:
      \[V_t\]
      - and human dependence:
        \[H_t\]
A governance-oriented measurement vector might therefore be
\[M_t = ( Q_t, R_t, g_t, L_t, V_t, H_t, C_t )\]
This allows different systems to be compared without collapsing all forms of self-improvement into one label.

Auditable Improvement Histories

Every accepted modification should produce an auditable record:
\[r_t = ( S_t, \Delta S_t, E_t, \text{evidence}, \text{decision}, S_{t+1} )\]
The complete improvement history is
\[\mathcal{R} = \{ r_0,r_1,\ldots,r_T \}\]
An external auditor should be able to reconstruct
\[S_0 \rightarrow S_1 \rightarrow \cdots \rightarrow S_T\]
- and determine why each transition was accepted.
This becomes increasingly important as the number of automated modifications grows beyond what humans can inspect manually.
Auditability must therefore be produced by the system itself, even if final auditing remains external.

Open Research Question: How Much External Information Is Necessary?

One fundamental question is the minimum amount of exogenous information required to sustain improvement.
Suppose the system receives external information at rate
\[I_{\text{ext}}\]
There may exist a threshold
\[I_{\min}\]
- such that sustained improvement requires
  \[I_{\text{ext}} \ge I_{\min}\]
Below that threshold, the system may increasingly recycle its own outputs.
Above it, experiments and external observations continually replenish the information available to the loop.
Chen et al. explicitly identify the minimum exogenous-signal rate needed to sustain improvement as an open problem.
Understanding this threshold would help distinguish systems capable of genuinely open-ended learning from systems primarily recombining a finite information reservoir.

Open Research Question: Can Weak Evaluators Supervise Stronger Systems?

Suppose generator capability is
\[Q_G\]
- and evaluator capability is
  \[Q_E\]
Eventually,
\[Q_G>Q_E\]
- may hold.
Can evaluator
\[E\]
- still reliably supervise generator
  \[G?\]
In some domains, yes. A verifier can check a solution that would have been difficult to generate.
For example,
\[C_{\text{verify}} \ll C_{\text{generate}}\]
This asymmetry underlies proof checking, code tests, and many search problems.
But for open-ended research judgment, verification may be nearly as difficult as generation:
\[C_{\text{verify}} \approx C_{\text{generate}}\]
Understanding which domains admit a strong generation-verification asymmetry is therefore central to predicting where RSI can scale reliably.

Open Research Question: Can Evaluators Co-Evolve Without Losing the Anchor?

Suppose both policy and evaluator improve:
\[\theta_t\rightarrow\theta_{t+1}\] \[\phi_t\rightarrow\phi_{t+1}\]
Co-evolution may be necessary because fixed evaluators eventually saturate.
But it creates a moving target.
The challenge is to obtain
\[Q(\theta_{t+1})>Q(\theta_t)\]
- and
  \[Q(\phi_{t+1})>Q(\phi_t)\]
  - without allowing the pair to jointly drift away from external utility.
This requires some invariant or independently measured anchor:
\[A(\theta_t,\phi_t)\]
Designing anchors that remain meaningful across large capability changes is an open problem.

Open Research Question: How Should Research Diversity Be Preserved?

An automated research organization may converge prematurely on whatever paradigm initially produces measurable gains.
Suppose research portfolio is
\[\mathcal{H}_t\]
Optimization pressure tends toward
\[\mathcal{H}_{t+1} = \operatorname{Select} ( \mathcal{H}_t )\]
Open-ended discovery instead needs both selection and mutation:
\[\mathcal{H}_{t+1} = \operatorname{Select} ( \mathcal{H}_t ) + \operatorname{Explore}\]
The unresolved problem is how much resource should be reserved for apparently unpromising or unconventional directions.
Too little exploration produces lock-in.
Too much exploration wastes compute.
The optimal exploration schedule may itself need to be learned recursively.

Open Research Question: How Should Research Taste Be Evaluated?

Research direction-setting may be the most important remaining human contribution.
A proposed direction can be evaluated by eventual downstream impact:
\[V(h_t) = \sum_{k=t}^{T} \gamma^{k-t} \Delta Q_k(h_t)\]
But this signal is extremely delayed.
Some research ideas may matter only after many intermediate discoveries.
A practical research-taste evaluator therefore needs proxies for
\[\text{novelty}\] \[\text{plausibility}\] \[\text{tractability}\] \[\text{information gain}\]
- and
  \[\text{downstream leverage}\]
Learning such an evaluator without collapsing research toward familiar ideas remains an important open problem.

Open Research Question: What Should Count as Recursive Gain?

If AI writes code twice as quickly, has recursive improvement occurred?
If AI discovers a better optimizer, has recursive improvement occurred?
If that optimizer trains the next AI system more efficiently, does the answer change?
A useful measurement distinguishes direct capability improvement from improvement to the improvement process.
Let
\[Q_t\]
- measure capability and
  \[R_t\]
  - measure improvement productivity.
Then
\[\Delta Q_t>0\]
- indicates improvement.
But recursive gain requires
\[\Delta R_t>0\]
A strong RSI benchmark should therefore measure both.
This distinction prevents ordinary benchmark progress from being mislabeled as recursive self-improvement.

Open Research Question: Over How Many Generations Must RSI Persist?

One successful self-modification provides weak evidence about recursion.
A stronger test requires
\[S_0 \rightarrow S_1 \rightarrow S_2 \rightarrow \cdots \rightarrow S_n\]
The central measurements are
\[Q_t\]
- and
  \[R_t\]
If
\[Q_{t+1}>Q_t\]
- but
  \[R_{t+1}=R_t\]
  - the system is improving but not recursively accelerating.
If
\[R_{t+1}>R_t\]
- for multiple generations, there is stronger evidence of recursive amplification.
The number of generations required for convincing evidence remains an empirical and methodological question.

Open Research Question: What Is the Correct Unit of RSI?

Early formulations often imagine one agent rewriting itself.
Modern systems suggest a broader unit.
The self-improving object may be
\[S_t = ( M_t, H_t, E_t, D_t, R_t, \mathcal{A}_t, C_t )\]
- where \(M\) is the model, \(H\) harness, \(E\) evaluator, \(D\) data, \(R\) research process, \(\mathcal{A}\) agent population, and \(C\) compute infrastructure.
The recursive system is therefore not necessarily a single neural network.
It may be an entire AI-development stack.
This broader definition better captures systems in which models improve agents, agents improve training infrastructure, research agents discover algorithms, evaluators filter discoveries, and those discoveries contribute to successor models.

A Robust RSI Architecture

The preceding analysis suggests a practical architecture built around separated responsibilities.
Candidate generation produces
\[c_t = G_t(S_t)\]
Independent evaluation computes
\[r_t = E_t(c_t)\]
Adversarial evaluation searches for failure:
\[a_t = A_t(c_t)\]
External or held-out evaluation provides an anchor:
\[h_t = E_{\text{anchor}}(c_t)\]
A deployment gate decides
\[d_t = D(r_t,a_t,h_t)\]
Only then is persistent state updated:
\[S_{t+1} = \begin{cases} U(S_t,c_t), & d_t=1,\\ S_t, & d_t=0. \end{cases}\]
All transitions are recorded:
\[\mathcal{L}_{t+1} = \mathcal{L}_t \cup \{ c_t,r_t,a_t,h_t,d_t \}\]
The improvement process is therefore
\[\boxed{ \text{Generate} \rightarrow \text{Verify} \rightarrow \text{Adversarially test} \rightarrow \text{Anchor} \rightarrow \text{Gate} \rightarrow \text{Commit} \rightarrow \text{Monitor} }\]
- rather than simply
  \[\text{Generate} \rightarrow \text{Replace}\]

The Remaining Gap

The current literature supports a relatively clear picture of where RSI works best.
Self-improvement is strongest when the loop has
\[\text{cheap generation} + \text{strong verification} + \text{persistent memory} + \text{reversible updates}\]
It becomes substantially harder when the system faces
\[\text{open-ended generation} + \text{subjective evaluation} + \text{long feedback delays} + \text{irreversible updates}\]
This helps reconcile the apparently different trajectories across the field. Coding agents, theorem proving, game-playing, and algorithm discovery can show strong recursive characteristics because their feedback channels are comparatively robust. Open-ended scientific direction-setting remains much less closed because its evaluator is weaker. Chen et al. summarize this relationship as the observation that demonstrated self-improvement strength broadly tracks the strength of the available verification signal.

Outlook

Recursive self-improvement is therefore best viewed as an engineering continuum rather than a single threshold.
At one end are bounded loops:
\[\text{generate} \rightarrow \text{verify} \rightarrow \text{improve}\]
Further along are persistent loops:
\[\text{generate} \rightarrow \text{verify} \rightarrow \text{learn} \rightarrow \text{retain}\]
More recursive systems add
\[\text{improve the generator}\] \[\text{improve the evaluator}\]
- and
  \[\text{improve the research process}\]
The open-ended endpoint is a coupled system in which these components repeatedly improve one another:
\[\boxed{ \begin{aligned} M_t &\rightarrow M_{t+1}\\ H_t &\rightarrow H_{t+1}\\ E_t &\rightarrow E_{t+1}\\ D_t &\rightarrow D_{t+1}\\ R_t &\rightarrow R_{t+1} \end{aligned} }\]
- while the overall system remains grounded against signals that have not simply been manufactured by the same optimization process.
The technical challenge is therefore not merely to close the loop.
It is to close the loop while preserving the properties that make improvement meaningful:
\[\boxed{ \text{grounding} + \text{verification} + \text{diversity} + \text{stability} + \text{auditability} + \text{reversibility}. }\]
Current evidence supports substantial progress on bounded and partially closed self-improvement, but not yet a demonstration that all of these requirements can be maintained across indefinitely repeated, increasingly autonomous improvement cycles.
The central research program for RSI is therefore as much about building trustworthy feedback as building stronger generators. An AI system can only recursively improve in a meaningful sense if successive generations become better according to signals that continue to track genuine capability and intended outcomes under the growing optimization pressure of the loop itself.

References

Citation

If you found our work useful, please cite it as:

@article{Chadha2020DistilledStateSpaceModels,
  title   = {State Space Models},
  author  = {Chadha, Aman and Jain, Vinija},
  journal = {Distilled AI},
  year    = {2020},
  note    = {\url{https://vinija.ai}}
}

Overview

The Core Feedback Loop

From Assistance to Recursion

The Conditions for Recursive Amplification

Verification as the Load-Bearing Component

Why Multi-Agent Scaling Matters

RSI Is Better Viewed as a Stack Than a Single Algorithm

Where the Frontier Currently Lies

Foundations and a Taxonomy of Recursive Self-Improvement

Bounded Self-Refinement and Open-Ended RSI

A Complementary Autonomy-Centered View

Autonomy Levels from Execution to Meta-Improvement

L5 Recursive inheritance / meta-improvement AI revises and reuses mechanisms that govern subsequent improvement, such as improvers, evaluators, search policies, or research-control procedures

Structural Recursion versus Effective Recursion

Safe Inheritance, Attribution, and Verification

Measuring Recursive Improvement Across Generations

Axis I: What Is Being Improved?

Deployment-Time Self-Evolution

Harness and Agent Self-Modification

Training-Time Self-Iteration

Self-Reward and Self-Evaluation

Self-Play and Curriculum Generation

Automated Research

Axis II: Degree of Loop Closure

Human-in-the-Loop

Human-on-the-Loop

Closed Improvement Loops

Persistence as a Third Practical Dimension

A Unified View of the RSI Stack

Full RSI Entire successor-generation stack Yes Endogenous + grounded verification Closed

Deployment-Time Self-Evolution

Iterative Output Refinement

Why Self-Critique Alone Is Limited

Externally Grounded Refinement

Search Over Candidate Solutions

Test-Time Training

Persistent Memory as Self-Improvement

From Memories to Reusable Skills

Harness Evolution

Gödel Agent and Self-Referential Modification

Darwin Gödel Machine and Empirical Self-Modification

Why Persistence Changes the Nature of the Loop

An Implementation Architecture for Persistent Deployment-Time Improvement

The Transition Toward RSI

Training-Time Self-Iteration

Self-Training as the Basic Loop

Bootstrapping Reasoning with STaR

Distinguishing Generation from Verification

From Binary Filtering to Reward-Weighted Learning

Self-Rewarding Language Models

The Coupled Policy-Evaluator System

Self-Play Fine-Tuning

Curriculum Generation

Absolute Zero and Zero-Data Self-Play

Challenger-Solver Co-Evolution

Learning Progress as a Curriculum Objective

The Role of Reinforcement Learning with Verifiable Rewards

Why Self-Generated Data Can Collapse

Novelty Is a Consumable Resource Without Grounding

Preventing Self-Training Drift

Measuring Whether an Iteration Actually Improved the Model

The Training-Time RSI Loop

Self-Evaluation, Verification, and Reward

Evaluation as the Core of Self-Improvement

A Verification Hierarchy

Formal Verification

Executable Verification

Outcome Supervision

Process Supervision

Learned Reward Models

LLM-as-a-Judge

Pairwise Evaluation

Rubric-Based Evaluation

Evaluator Ensembles

Meta-Evaluation

Co-Evolving the Evaluator

Self-Confirming Loops

Optimization Pressure and Evaluator Exploitation

Adversarial Evaluation of Evaluators

Evaluation Under Distribution Shift