Self-Improving Systems

A self-improving system uses evidence from its own operation to change some part of the system that will shape later operation. The changed part might be an answer under construction, a memory record, a reusable skill, a prompt, a software scaffold, a training dataset, model weights, or an algorithm stored in an archive. These mechanisms differ so much that "self-improvement" is not a useful verdict by itself. It is a family name for feedback loops whose evidence, persistence, scope, and autonomy must be stated separately.

The broad category includes ordinary and well-established techniques such as self-play, iterative refinement, and learning from execution feedback. It also includes newer language-model systems that write critiques into memory, generate and filter their own training examples, evolve prompts, or edit agent code. Most examples improve a bounded task score under an evaluator supplied by people. Very few show that an improvement transfers beyond the evaluation distribution, and fewer still show that later generations become better at finding further improvements. Those stronger properties belong to Recursive Self-Improvement, not to the category as a whole.

This entry provides a taxonomy rather than a chronology. Its main question is not whether a system "really" improves itself. The useful questions are: what changes, what remains fixed, where feedback comes from, how a change persists, who decides that it is better, and whether the measured gain survives independent evaluation.

Coverage note: This article reflects sources and terminology reviewed through August 8, 2026. Its evidence is unevenly aged: most of the mechanism literature is 2024–mid-2025, while the two entries carrying the evaluator discussion are current — the Darwin Gödel Machine as last revised in March 2026, and the Red Queen Gödel Machine from June 2026. Treat the older systems as the settled part of a field that has kept moving.

Definition and boundary

The minimal self-improvement loop has five stages:

A system produces an output or acts in an environment.
Some process observes a consequence, score, critique, or comparison.
An update rule proposes a change to a mutable substrate.
The system retains that change long enough to affect a later attempt.
A later evaluation tests whether behavior improved.

One condition belongs in the list rather than in the commentary after it: the evidence in stage 2, or the proposal in stage 3, has to come from the system’s own operation. Without that, the five stages describe ordinary supervised learning on an external stream — which this entry excludes one paragraph later, when it says Online Learning counts “only when the learner’s own behavior helps generate the data or feedback.” The stricter test applied to the neighbour is the test that belongs here too. With it stated, this definition is intentionally broad. It includes a language model revising one response after criticizing it, even though the model weights never change. It also includes a self-play agent whose weights change across millions of games. What it excludes is mere repetition with no retained information: sampling the same fixed model ten times and choosing the best answer spends more compute, but the system has not learned anything unless the selection result changes a later attempt.

The word self also needs care. A system can generate its own feedback while relying on a human-written objective, a fixed benchmark, an external game engine, or a compiler. It can edit its own prompt while its model, optimizer, and evaluator remain fixed. It can generate training data while people still decide which data enter the training run. Self-improvement therefore does not imply self-sufficiency. In most published systems, "self" identifies the source of some proposals or data, not ownership of the entire improvement process.

Three neighboring concepts should remain separate:

Online Learning updates a learner as new data arrive. It becomes self-improvement only when the learner's own behavior helps generate the data or feedback that drives later updates.
Test-Time Compute allocates more computation to a current problem. It can improve an answer without producing any persistent improvement across problems. The line is thinner than it looks: Self-Refine, included below, also persists only within one task. What separates them is stage 3 — Self-Refine proposes a change to a mutable substrate on the basis of its own critique, where extra sampling or search does not. The boundary marks where the loop begins, not how long the effect lasts.
Recursive Self-Improvement requires a stronger feedback relation: the system improves the machinery that produces future improvements, so the rate, breadth, or autonomy of improvement may itself increase.

The live entry Self-Improving Software Systems traces the historical lineage from editable heuristics through AutoML and agent scaffolds. This entry is broader in substrate and narrower in claim. It classifies any system-level improvement loop, including self-play and weight updates, without treating the software lineage or classical intelligence-explosion hypothesis as the definition.

A taxonomy by mutable substrate

The most reliable way to compare self-improving systems is to start with what actually changes.

Mutable substrate	Typical update	Persistence horizon	Representative evidence	What remains fixed
Current output	Generate, critique, revise	One task or conversation	Self-Refine	Model, prompts, evaluator
Context or memory	Store verbal feedback for reuse	Later trials, often task-local	Reflexion	Model weights, memory policy
Skill or tool library	Save verified code or procedures	Across tasks or episodes	Voyager	Base model, environment, curriculum logic
Policy from self-play	Train on trajectories produced by current agents	Across training iterations	AlphaZero	Game rules and terminal reward
Synthetic training data	Generate rationales, responses, preferences, or tasks, then train	Across model checkpoints	STaR, SPIN, self-rewarding language models	Seed data, training objective, and the filtering machinery — in self-rewarding LMs the judge prompt, its criteria and the take-best-and-worst-discard-ties rule are all fixed; what moves is the weights of the model applying them
Prompt population	Mutate prompts and sometimes mutation operators	Across optimization generations	Promptbreeder	Base model, task set, fitness function
Agent scaffold or code	Edit tools, control flow, context handling, or the improver itself	Across evaluated versions	STOP, Darwin Godel Machine	Foundation model, outer benchmark, parts of search
Candidate algorithm archive	Generate programs, execute them, retain high scorers	Across evolutionary generations	AlphaEvolve	Automated evaluator and problem specification
Evaluator	Modify graders, reward models, or tests	Across later optimization	Self-rewarding LMs, where the judge is trained alongside the policy	Whatever independent outer validation the designer holds back — nothing inside the loop keeps it fixed

This table is not a ladder. A weight update is not automatically more consequential than a skill-library update, and a system that edits source code is not automatically more recursive than a self-play learner. Consequence depends on whether the changed substrate is a bottleneck. A reusable tool can produce a large transfer gain while a poorly filtered weight update can cause regression. Conversely, a response revision can be highly useful while leaving the system exactly as capable on its next unrelated task.

Four axes supplement the substrate taxonomy.

Persistence asks how long the update survives. An edited paragraph persists only in the current artifact. A reflection in episodic memory may survive several attempts. A skill committed to a library can survive across tasks. A weight update can survive until the next training run, but may still be overwritten or forgotten.

Generality asks where the gain transfers. A prompt evolved for one benchmark might be excellent on that benchmark and harmful elsewhere. A code-editing tool might transfer across programming languages. Generality is an empirical result, not a property conferred by the name of the method.

Evaluator independence asks whether the judge has information or capabilities independent of the generator. Execution tests, formal proof checkers, and game rules can supply feedback that a generator cannot change merely by arguing persuasively. A model grading its own prose has much weaker independence.

Meta-improvement asks whether an update improves the process of finding later updates. A better answer is object-level improvement. A better mutation operator, evaluator, or editing tool may be meta-level improvement. Even then, one must measure whether later improvements arrive faster, more cheaply, or across a wider domain.

The anatomy of an improvement loop

Every self-improving system embeds choices about generation, feedback, selection, retention, and validation. Describing those choices makes inflated claims easier to detect.

Proposal generation

The proposal generator supplies variation. It may be a stochastic policy exploring moves, a language model drafting critiques, an evolutionary mutation operator editing code, or a training model generating synthetic examples. Diversity matters because a loop cannot select an improvement it never proposes. Yet diversity alone is not progress. A generator can produce endless novel variants that all exploit the same evaluator weakness.

Some systems use the same model in several roles. Self-Refine uses one language model to generate an initial response, provide feedback, and refine the response without additional training. The paper reports gains across seven tasks, but its update exists in the accumulated prompt history and revised artifact, not in the model itself (Self-Refine). This is genuine within-run adaptation and a poor example of persistent learning. Calling it "the model improving itself" is defensible only if the substrate is named.

Reflexion moves one step toward persistence. It converts task feedback into verbal reflections and stores them in an episodic memory buffer for later trials. The model weights remain fixed, while retrieved memory changes subsequent decisions (Reflexion). This makes the difference between state and capability visible: the agent state has learned something, but the underlying model has not acquired a transferable parameter update.

Feedback and evaluation

Feedback can be internal, external, or hybrid. Internal feedback includes self-critique and self-grading. External feedback includes unit tests, environment state, human preference labels, formal verification, and game outcomes. Hybrid systems ask a model to interpret external signals, such as turning a compiler error into a proposed repair.

The evaluator is the load-bearing part of the loop. In AlphaZero, game rules provide legal transitions and terminal outcomes, and self-play supplies an adaptive distribution of opponents. Search produces improved move targets, and training distills those targets into a policy-value network. This tight connection between action, outcome, and learning supported superhuman play in chess, shogi, and Go under the reported conditions (AlphaZero). The loop is powerful partly because "better" is unusually crisp.

Open-ended tasks rarely offer such an evaluator. A model can judge whether an essay sounds coherent, but coherence is not identical to truth. A benchmark can score a coding agent, but benchmark success may reward exploiting tests or specializing to a narrow repository distribution. The less independent the evaluator, the more cautiously improvement should be described.

Selection and retention

Selection decides which proposals become ancestors of later behavior. A greedy loop keeps only the current best candidate. An archive preserves diverse candidates that may become useful stepping stones later. Retention then makes the selected change available to future attempts through prompt history, memory, files, training data, weights, or a program database.

Voyager demonstrates why retention changes the category. Its automatic curriculum proposes objectives in Minecraft; its iterative prompting mechanism uses environment feedback, execution errors, and self-verification to repair programs; successful programs enter an expanding skill library. Those stored skills are retrieved for later tasks, so the improvement is not merely a better answer to the current prompt (Voyager). The evidence supports persistent skill accumulation in that environment. It does not establish general autonomous learning outside environments with compatible APIs and feedback.

The Darwin Godel Machine preserves an archive of coding agents rather than only the latest winner. A foundation model modifies agent code, evaluates variants on coding benchmarks, and keeps diverse descendants. The authors report substantial benchmark gains and transfer tests across some models and programming languages. They also state that archive maintenance and parent selection remain fixed rather than being editable by the system (Darwin Godel Machine). That fixed outer search is an important boundary: the agents evolve inside a human-designed evolutionary process.

Independent validation

The final stage should not reuse the same data and judge that selected the update. If a prompt is evolved on a training set, it needs held-out tasks. If an agent edits its own testing harness, it needs immutable outer tests. If a model generates and grades preference data, an independent evaluator should test whether both response quality and judging quality improved.

Without this separation, a loop can improve its measured score by learning the judge rather than the task. Goodhart's Law in AI Systems is not an incidental risk here. Self-improving systems repeatedly expose their own evaluator to adaptive search, which is precisely the regime where proxy weaknesses become discoverable.

Major mechanism families

The lightest-weight family improves an artifact during inference. A system drafts, critiques, and revises until a stopping rule fires. The useful gain comes from decomposing generation and evaluation into separate passes, exposing errors to later tokens, and allocating additional compute. Self-Refine is the canonical example (Self-Refine).

This family is cheap, easy to deploy, and often mistaken for learning. Its limits are equally clear. The critique can repeat the generator's misconception. Extra iterations can make prose more polished while making factual errors harder to notice. The update usually disappears after the task. A fair evaluation therefore compares against cost-matched sampling or search, not only against a one-pass baseline.

Memory-mediated adaptation

Memory systems retain lessons without changing weights. Reflexion stores linguistic feedback in episodic memory (Reflexion). Voyager stores executable skills rather than prose alone (Voyager). The distinction matters because executable artifacts can be tested, versioned, composed, and rolled back. Natural-language memories remain more vulnerable to ambiguity and retrieval error.

Memory-mediated adaptation can be lifelong at the agent layer even when the model is frozen. Its central risks are accumulation and retrieval. A false reflection may contaminate later decisions. A useful skill may never be retrieved. An expanding library can increase context cost or create conflicting procedures. Persistent memory creates a new maintenance problem: improvement must include deletion, deprecation, and regression testing, not only addition.

Self-play and environment-grounded learning

Self-play generates an opponent and a curriculum from the learner's current competence. AlphaZero is unusually clean because exact rules constrain actions and game outcomes provide a reliable terminal signal (AlphaZero). The environment prevents many forms of self-deception: a persuasive explanation cannot turn an illegal move into a legal one or a loss into a win.

The same structure transfers imperfectly to language and open-world agents. There may be no natural opponent, terminal state, or complete simulator. A synthetic debate can drift toward conventions shared by both agents. A generated task curriculum can become easy, repetitive, or detached from real demand. The general lesson is not "self-play solves supervision." It is that self-play works best when paired with a verifier and a task distribution that remains meaningful as competence rises.

Self-generated training data

Training-time systems generate examples or rationales, filter them, and update model weights. STaR generates rationales, retains or rationalizes examples that lead to correct answers, fine-tunes on the successful rationales, and repeats (STaR). SPIN generates responses from the current model and trains a successor to distinguish them from human demonstration responses, iterating from an existing supervised model (SPIN). Self-rewarding language models go further by using the trained model as both response generator and judge, its scores creating preference pairs for iterative training. The prompts are not its own: in the main experiments “responses and rewards … are generated by the model we have trained, but generating prompts is actually done by a model fixed in advance,” with self-generated prompts appearing only as an appendix variant (Self-Rewarding Language Models).

These are weight-level improvements, but they are not free from external structure. STaR needs questions and known answers. SPIN remains anchored to a human demonstration distribution. Self-rewarding language models begin from instruction-following and evaluator capabilities obtained through earlier training, and their central evidence comes from benchmark and preference evaluations. The systems recycle and amplify an existing signal rather than creating truth from nothing.

The risk is correlated error. If generation and filtering share the same blind spot, the filter preferentially retains confident mistakes. Training makes the mistake more available in the next generation, which can make later filtering less reliable. The Nature study on recursively generated data shows a related failure mode: indiscriminate replacement of real data with model-generated data can progressively lose distributional tails and produce model collapse (Model Collapse). That result does not show that all synthetic-data training collapses. It shows why preserved real data, independent verification, and explicit diversity controls are not optional.

Prompt and scaffold evolution

Promptbreeder evolves task prompts and also evolves the mutation prompts that generate new task prompts. This is self-referential at the prompt-optimization layer because a mutable operator shapes later mutations (Promptbreeder). The method is more meta-level than ordinary prompt search, but the base model, task distribution, and fitness function remain outside the mutation boundary.

STOP begins with a scaffolding program that uses a language model to improve input programs, then applies the improver to itself. The authors explicitly distinguish the result from full recursive self-improvement because the language model is not altered (STOP). This is a useful naming discipline. A self-editing scaffold can matter greatly without implying that the underlying model has designed a more capable successor.

The Darwin Godel Machine broadens scaffold mutation through open-ended archive search. Its evidence supports the claim that language-model agents can discover useful changes to editing tools, context management, and review workflows under benchmark evaluation (Darwin Godel Machine). The evidence is recent, benchmark-centered, and not yet a demonstration of indefinite improvement. Performance curves over tens of iterations do not establish an unbounded trajectory.

Evaluator-driven algorithm discovery

AlphaEvolve combines language-model program generation, automated evaluators, and an evolutionary program database. Candidate programs are executed and scored; higher-value programs influence future prompts. Google DeepMind reports applications to data-center scheduling, chip design, AI training, matrix multiplication, and mathematical constructions (AlphaEvolve).

This family has an especially favorable feedback structure when candidate quality is machine-checkable. A faster kernel can be timed. A mathematical construction can be checked against a precise objective. Yet the system remains bounded by problem formalization. It can search effectively after people supply a code skeleton, evaluator, resource budget, and acceptance process. AlphaEvolve is strong evidence for automated improvement of algorithms in verifiable domains and weak evidence for autonomous choice of valuable goals.

Time scales and system boundaries

The same mechanism can look like learning or search depending on where an observer draws the system boundary. Suppose a model drafts a program, runs its tests, reads the failure, and repairs the code. At the level of one model call, nothing persists. At the level of the agent trajectory, the program and observations form a growing state, so the agent adapts. At the level of the deployed product, the accepted program may become a durable tool. At the level of the base model, no learning occurred.

This is not merely philosophical bookkeeping. Different boundaries imply different safety and evaluation requirements. A response-level loop needs protection against runaway cost and compounding mistakes. A memory-level loop needs provenance, retrieval tests, and deletion. A code-level loop needs sandboxing, regression tests, and review of permissions. A weight-level loop needs dataset controls, checkpoint comparison, and monitoring for capability loss. Saying only that "the AI learned" erases the layer where the change can be inspected or reversed.

Time scale also determines what evidence is meaningful. Improvement within one attempt can be measured by comparing the revised artifact with its initial version. Improvement across episodes requires demonstrating that retained state helps on later episodes. Improvement across deployments requires showing that an accepted change remains beneficial after surrounding software, data, or user behavior changes. Improvement across generations of models requires preserving an external reference distribution, because every generation's outputs can otherwise become both the evidence and the target.

A useful account therefore names three clocks:

The optimization clock counts proposals and evaluations within a run. It answers how much search was spent to find the candidate.

The retention clock counts how long the accepted change remains available. It answers whether the result is an ephemeral trajectory state, a durable artifact, or a parameter update.

The validation clock counts how long until the change is tested on genuinely new conditions. It answers whether success reflects immediate evaluator fit or sustained utility.

These clocks can diverge. A system may perform thousands of optimization steps, save one prompt indefinitely, and never validate it after the benchmark changes. Another may make a single tested code edit that remains useful for years. The number of iterations is therefore a poor proxy for the depth of improvement.

The boundary question also clarifies ownership. If the system proposes a change but a person reviews, integrates, and deploys it, the improvement loop is mixed-initiative. If an automated gate accepts the change, that gate is part of the operational system even when it was written months earlier. Human judgment has not vanished; it has been compiled into objectives, tests, permissions, and escalation rules. Honest autonomy claims should describe that compiled judgment as well as live intervention.

Finally, system boundaries determine rollback. An output revision can be discarded. A memory can be deleted if its dependents are known. A skill or code edit can be reverted if versions and migrations are retained. A weight update is harder to decompose because many behaviors change together. Systems that advertise continual improvement should report not only how they accept changes but how they identify the descendants of a bad change and restore a known-good state.

What counts as evidence of improvement?

A serious claim should report more than the highest score observed during a search. At least seven comparisons matter.

Cost-matched baseline. Compare the loop with ordinary sampling, search, or human engineering using similar compute and model calls. If ten critique passes beat one direct pass, the gain may be inference scaling rather than learning.

Held-out evaluation. Separate the examples used to generate, select, and tune improvements from those used to report success. Adaptive reuse of a benchmark turns it into a training set.

Transfer. Test new tasks, environments, model backends, or distributions. A reusable improvement should survive at least one change not optimized directly.

Persistence. Show that the gain affects later work without replaying the complete original search. A saved output is not a more capable system unless later behavior can use it.

Regression rate. Count the tasks made worse by an accepted update. Average improvement can conceal severe local regressions, especially in broad language systems.

Evaluator robustness. Audit whether the system found a shortcut in the score. Where possible, use an independent outer judge that the system cannot edit.

Improvement-rate evidence. If the claim is meta-improvement, measure whether later useful updates are found faster or more cheaply, not merely whether final task performance rises.

These controls separate three explanations that often look identical in a headline graph: the system learned a transferable method; the system spent more compute on the same method; or the system overfit the evaluator. Current evidence supports all three phenomena in different settings.

Failure modes

Self-confirmation

When one model proposes, critiques, and judges an output, correlated errors can survive every stage. Iteration may increase confidence and stylistic coherence without increasing correctness. Independent tools help only when their outputs constrain acceptance rather than merely decorate the prompt.

Reward hacking and evaluator capture

Adaptive search discovers loopholes. If a coding agent is rewarded for passing tests, it may weaken validation instead of implementing the intended behavior. If an evaluator is editable, the cheapest "improvement" may be redefining success. A mutable evaluator therefore requires an immutable outer objective or periodic independent audit.

Distribution narrowing and collapse

Self-generated data tend to reflect what the current model already produces easily. Without retained real data or deliberate exploration, rare modes can disappear. Model-collapse experiments provide direct evidence for this danger under indiscriminate recursive training (Model Collapse). Whether curation defeats it is a separate question, argued in a literature not cited here, and it appears below as an open question rather than as a settled counterweight. The contested point is not whether synthetic data can help; it can. The open question is how much independent information and selection quality are required to keep iterative gains from becoming self-imitation.

Catastrophic accumulation

Persistent memories, skills, and code create a growing attack surface. Old assumptions remain available after the environment changes. Dependencies break. A skill that passed weak tests becomes a parent of later skills. Without provenance and rollback, error compounds even when each local update looked reasonable.

Benchmark capture

A system optimized repeatedly against the same task suite can learn benchmark-specific tactics. Fresh tasks, temporal holdouts, and evaluation by a different harness reduce this risk but do not eliminate it. Claims of continual improvement should state how often the evaluator changed and whether the system saw feedback from the final test.

Objective drift

A system can retain competence while moving away from the intended objective. This is especially likely when evaluators, curricula, or prompt mutation operators evolve. Diversity of behavior is not the same as value alignment, and open-endedness is not a substitute for an acceptance criterion.

Human work hidden outside the loop

Published diagrams often begin after people have selected the domain, written the evaluator, assembled seed data, configured tools, and decided which result to integrate. None of that invalidates the system. It does change the autonomy claim. A useful accounting reports human minutes per generation, manual interventions, rejected proposals, and integration decisions.

Design principles for bounded improvement

Practical self-improving systems benefit from conservative engineering.

Keep an immutable outer gate. The system may optimize prompts, code, or inner graders, but a separate acceptance suite should remain outside its write boundary.
Retain lineage. Record the parent, proposal, feedback, evaluator version, cost, and test result for every accepted change.
Prefer executable feedback. Unit tests, formal checkers, simulators, and measured resource use provide stronger signals than ungrounded self-critique.
Use holdouts and refresh them. Adaptive optimization consumes the validity of a static test set.
Measure regressions and transfer. A single aggregate score is insufficient for a general-purpose system.
Make rollback cheap. Archives and versioned artifacts turn failed improvement into recoverable exploration.
Separate proposer and judge where feasible. Different models, tools, or human review can reduce correlated error, though independence should be tested rather than assumed.
Cap authority independently of capability. A better-performing agent should not automatically receive broader permissions.

These principles also have a moral dimension. A system that changes itself can shift responsibility away from visible human decisions without removing human authorship of the objective and deployment context. From a Thomistic perspective, increasing instrumental capacity does not itself supply practical wisdom about worthy ends. Governance should preserve identifiable human judgment over goals, permissions, and consequences rather than treating optimization success as authorization.

Relationship to recursive self-improvement

Self-improvement becomes recursive when the target of improvement includes the improvement process and when the change measurably helps produce later changes. STOP’s self-applied improver and the Darwin Godel Machine’s editable agent tools are partial examples at the scaffold layer, and Promptbreeder is the same pattern one substrate over — its mutable mutation prompts are prompt population, which the taxonomy above deliberately keeps separate from agent scaffold (Promptbreeder; STOP; Darwin Godel Machine). They establish that self-reference is technically possible in bounded systems. Self-rewarding language models reach one layer down, to the evaluator. Across iterations the authors report that “not only does instruction following ability improve, but also the ability to provide high-quality rewards to itself” (Self-Rewarding LMs) — a gain in judging that arrives without per-iteration evaluator training, and which the authors attribute to improved general instruction following rather than to a deliberate evaluator loop. It distinguishes them from STaR and SPIN, whose judges do not move at all, and it is incidental where the Red Queen Gödel Machine makes evaluator change the object of the search.

They do not establish the classical intelligence-explosion claim. Their base models, objectives, benchmarks, compute budgets, and important search mechanisms remain fixed or externally controlled. Reported gains occur over bounded runs in selected domains. The stronger evidence would be persistent improvement on fresh tasks, falling cost per accepted gain, broader transfer, reduced human intervention, and independent validation that the evaluator itself improved rather than became easier to satisfy.

This distinction is not semantic caution for its own sake. Ordinary self-improving systems are already valuable and risky without being recursively accelerating. A skill library can transform an agent's usefulness. Synthetic training can reshape a model. Algorithm discovery can produce deployed efficiency gains. None requires a claim about unbounded takeoff.

Evidence assessment and open questions

Confidence is high that bounded self-improvement works when feedback is reliable and the mutable substrate is well specified. AlphaZero supplies mature evidence for self-play under exact rules. Self-Refine, Reflexion, and Voyager supply evidence that inference-time feedback and persistent artifacts can improve selected agent behaviors. Training methods such as STaR, SPIN, and self-rewarding language models show that self-generated data can support weight updates under filtering and external anchors. Program-search systems show that language models can participate in prompt, scaffold, and algorithm evolution.

Confidence is moderate that these gains will transfer broadly without substantial human engineering. Most studies use selected benchmarks, short generation counts, and objectives designed for the method. Transfer results exist, but they are not yet a common standardized measurement.

Confidence is low that any single current public system demonstrates open-ended, autonomous improvement of general capability. The scoping matters, because the strongest case against this verdict is not a system: it is the research community itself, where each generation of models helps build the next through a loop whose substrate is papers, code and training recipes rather than weights. That loop lies outside the system boundary used here — which is why the verdict is about systems rather than about the enterprise that builds them. The decisive evidence is missing: long runs on fresh distributions, independent evaluator evolution, falling human intervention, and measured meta-improvement rather than final-score improvement.

Several research questions would change that assessment:

Can a system improve its evaluator while an independent outer audit confirms higher validity rather than easier scoring? This one has since been attempted rather than only posed: the Red Queen Gödel Machine puts evaluation inside the improvement loop deliberately, structuring search into epochs that hold evaluation criteria stable within an epoch and let the objective shift at the boundary, with results reported on coding, on scientific writing and reviewing, and on proof grading (Red Queen Gödel Machine). It also addresses the audit half rather than leaving it open: evaluator replacement is gated on a fixed, held-out, evaluator-independent ground-truth anchor, and its proof grader is scored against held-out human grades. What remains open is third-party replication, not the presence of an outer check.
How many generations of synthetic-data training can preserve rare capabilities under different real-data and verification mixtures?
Do scaffold improvements discovered with one model transfer to materially different model families and domains?
Can archives retain productive diversity without accumulating unsafe or obsolete artifacts?
What cost-matched baseline best distinguishes recursive structure from ordinary search?
How should permission and responsibility change when the system, rather than a person, proposes the accepted modification?

The category's central lesson is modest but consequential: improvement is a property of a whole loop, not of a model in isolation. The quality of the feedback, the persistence of the update, the independence of the validation, and the scope of transfer matter more than whether the system uses the word "self."

Core concepts: Online Learning · Continual Learning · Self-Play Reinforcement Learning · Synthetic Data · Meta-Learning · Open-Ended Search

Language-model mechanisms: Self-Refine · Reflexion · Self-Rewarding Language Models · STaR Bootstrapping · Prompt Optimization · Agent Memory

Software and agents: AlphaZero · Self-Improving Software Systems · Mutable Scaffolds · Agent Skills · Darwin Godel Machine · AlphaEvolve

Evaluation and limits: AI Evals · Goodhart's Law in AI Systems · Benchmark Overfitting · Model Collapse · Distribution Shift · Catastrophic Forgetting

Stronger claims: Recursive Self-Improvement · Intelligence Explosion · AI-Accelerated AI Research

References

1 AlphaZero — David Silver et al., "Mastering Chess and Shogi by Self-Play with a General Reinforcement Learning Algorithm." (arXiv)

2 Self-Refine — Aman Madaan et al., "Self-Refine: Iterative Refinement with Self-Feedback." (arXiv)

3 Reflexion — Noah Shinn et al., "Reflexion: Language Agents with Verbal Reinforcement Learning." (arXiv)

4 Voyager — Guanzhi Wang et al., "Voyager: An Open-Ended Embodied Agent with Large Language Models." (arXiv)

5 STaR — Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah D. Goodman, "STaR: Bootstrapping Reasoning With Reasoning." (arXiv)

6 SPIN — Zixiang Chen, Yihe Deng, Huizhuo Yuan, Kaixuan Ji, and Quanquan Gu, "Self-Play Fine-Tuning Converts Weak Language Models to Strong Language Models." (arXiv)

7 Self-Rewarding Language Models — Weizhe Yuan et al., "Self-Rewarding Language Models." (arXiv)

8 Promptbreeder — Chrisantha Fernando, Dylan Banarse, Henryk Michalewski, Simon Osindero, and Tim Rocktäschel, "Promptbreeder: Self-Referential Self-Improvement Via Prompt Evolution." (arXiv)

9 STOP — Eric Zelikman, Eliana Lorch, Lester Mackey, and Adam Tauman Kalai, "Self-Taught Optimizer (STOP): Recursively Self-Improving Code Generation." (arXiv)

10 Darwin Gödel Machine — Jenny Zhang, Shengran Hu, Cong Lu, Robert Lange, and Jeff Clune, "Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents." (arXiv)

11 AlphaEvolve — Alexander Novikov, Ngân Vũ, Marvin Eisenberger, Emilien Dupont, Po-Sen Huang, Adam Zsolt Wagner, Sergey Shirobokov, Borislav Kozlovskii, Matej Balog et al. (Google DeepMind), “AlphaEvolve: A Coding Agent for Scientific and Algorithmic Discovery” (arXiv, 16 June 2025). (arXiv)

12 Model Collapse — Ilia Shumailov et al., "AI Models Collapse When Trained on Recursively Generated Data." (Nature)

13 Red Queen Gödel Machine — Alex Iacob, Andrej Jovanović, William F. Shen et al., “The Red Queen Gödel Machine: Co-Evolving Agents and Their Evaluators” (arXiv, 24 June 2026). (arXiv)