Recursive self-improvement (RSI) refers to an AI system's ability to boost its own performance by redesigning itself. Originally, RSI was concerned with an “intelligence explosion” (I. J. Good, 1965) that would leave humans behind. Recently, both OpenAI (2026) and Anthropic (2026) have reported substantially increased AI contributions to accelerate their internal research. While not yet fully autonomous, the progress is undeniable, and further advances are likely soon, creating large opportunities and risks on the horizon. To help navigate this vital discussion, we’ve put together a reading list that traces where the idea comes from and how it has evolved to its current state.
Today, multiple systems claim different degrees of RSI success using different approaches, for example, by revising an answer before returning it, storing lessons for the next attempt, or evolving executable programs against a score. Stronger claims involve systems that edit agent code, update model weights, revise the research policy used by a later round, or change the evaluator between selection periods. Each result requires different evidence and has different implications.
Current experiments support real progress: agents can persistently modify memory, code, research policies, harnesses, and weights. Some of these changes produce downstream performance gains. Recent experiments also change the procedure that produces later improvements. However, public evidence has yet to establish a fully autonomous self-accelerating successor process.
A fully autonomous successor process would control proposal, evaluation, selection, persistence, and modification of the machinery that produces its next successor. It would test final capability on evidence withheld from every adaptive step and report the compute, samples, tools, and human input used along the way. Self-acceleration requires one more result. Inherited changes must increase the rate of later improvement under comparable external inputs. No paper below demonstrates this entire process.
For quantitative researchers, the evaluation problem is already immediate. An agent can generate more factor expressions, model configurations, and backtests than a human team can inspect. Repeated access to a score can reward research progress, additional search, leakage, or adaptation to the evaluator. Persistent memory can preserve the error as easily as the insight.
The reading path therefore follows four questions: what changed, what persisted, what stayed fixed, and which evidence remained unavailable during selection?
On Thursday, October 1 at 11:00 AM ET, I am teaching a free 30-minute lightning lesson: Can AI agents improve themselves?. We will map current systems by what they change, what they keep fixed, and what their experiments establish.
The Agent Engineering workshop follows on Saturday, October 3. Participants build and evaluate an auditable multi-agent forecasting system with traces, ablations, probabilistic scores, and calibration checks.
How self-improvement became more recursive
The first dividing line is persistence. Revising one answer can improve the current output while leaving the next attempt unchanged. Memory, code, or weights can carry an improvement into later work. The stronger recursive cases also change part of the procedure that proposes, tests, or selects the next change.
Selection and final evaluation need separate labels. A search metric directly selects candidates. An external metric becomes part of the adaptive loop when later rounds respond to it. The strongest test remains unavailable until the system and its learned state have been frozen.
From intelligence explosion to formal self-rewrite
The modern argument traces back to I. J. Good’s 1965 intelligence-explosion argument. If designing intelligent machines is an intellectual activity, Good reasoned, a sufficiently capable machine could help design a more capable successor. The argument did not specify how a system should decide that a proposed self-modification is an improvement.
Jürgen Schmidhuber’s Goedel Machine (2003) supplied a formal answer. A utility-maximizing program searches for a self-rewrite and executes it only after proving that the rewrite has higher expected utility than continuing the search. The permitted rewrite can include the proof searcher itself.
Modern systems replace proof with experiment. They propose changes, run an evaluator, retain promising results, and repeat. This makes self-improvement practical, but places much of the epistemic burden on evaluation. A system can become better at optimizing a benchmark without improving the broader capability the benchmark is meant to measure.
From revision to persistent experience
Self-Refine (2023) provides a useful lower bound. The same language model generates an answer, critiques it, and revises it. The paper reports an average absolute improvement of about 20 percentage points across seven tasks, but nothing needs to persist after a task ends.
Reflexion (2023) crosses that boundary. It stores natural-language reflections from earlier attempts and retrieves them in later trials while model weights remain fixed. Useful lessons can compound across trials, and misleading reflections can trap later behavior in a local optimum.
RSIAgent (2026) also adapts the experience used to construct persistent memory. Its final evaluation freezes that memory, resets the environment, and disables curriculum decisions and writeback. The system therefore adapts future context without adapting the fixed mechanisms that select practice, verify outcomes, and update memory. The survey The Last AI Built by Humans (2026) offers a useful taxonomy for such degrees of autonomy, but does not independently validate the systems it classifies.
From better artifacts to better improvers
Self-Taught Optimizer (2023) starts with an “improver” program that uses a language model to improve other programs, then asks that improver to improve itself. The model stays fixed, but the program that proposes later improvements becomes mutable. Promptbreeder (2023) explores a related mechanism by evolving both task prompts and the mutation prompts that generate them.
FunSearch (2024) and AlphaEvolve (2025) follow a different route. Models propose executable programs, automated evaluators score them, and successful programs become material for later generations. FunSearch pairs a frozen model with a fixed evaluator and program database. AlphaEvolve extends that pattern across mathematics, algorithm design, and production systems. In both cases, the models, evaluators, and outer evolutionary procedure remain externally specified. Andrej Karpathy’s autoresearch (2026) makes a compact version of this workflow inspectable, but it is not a controlled study.
The Darwin Goedel Machine (2025) moves the mutable boundary from a task program to agent code. Selected descendants enter an archive and can help produce later descendants. The paper reports gains from 20.0 to 50.0 percent on its SWE-bench evaluation and from 14.2 to 30.7 percent on Polyglot. Foundation models, archive operations, parent selection, and benchmark validation remain outside the recursive relation.
Hyperagents (2026) places the task agent and meta-agent inside one editable program. Its transfer experiment freezes an evolved meta-agent and tests whether it can produce better task agents in a different domain under a fixed iteration budget. The result tests whether a changed improvement procedure transfers, while tasks, budgets, validation, and outer selection remain fixed.
Figure 1. Selected systems differ in the artifact they retain and in the distance between selection and final evaluation. Freezing learned state, transferring an improver, and withholding the final test support progressively stronger claims.
Autonomous research exposes the evaluation path
Automating a research cycle does not establish that the research process is improving itself. The AI Scientist (2024), for example, automates idea generation, experiments, paper writing, and simulated review under a fixed workflow. Evidence for recursive improvement requires a later research round to inherit a changed research procedure.
A-Evolve-Training (2026) reports four autonomous post-training rounds on a 30B model with eight workers per round. A collector aggregates results, and a meta-agent revises the research policy for the next round. The final model scored 0.86 on the public leaderboard against 0.87 for the top human submission and ranked eighth among roughly 4,000 entries at the reported snapshot.
The collector fetched that leaderboard between rounds, and the meta-agent used the development-to-leaderboard gap to redirect later search. The leaderboard was therefore an adaptive selection signal, not an untouched final test. The campaign shows inherited policy revision under a fixed substrate, constitution, objective, worker structure, and evaluation harness.
SIA: Self-Improving AI with Harness & Weight Updates (2026) alternates changes to the task harness and model weights, but its inspected LawBench test grader also optimizes. Red Queen Goedel Machine (2026) changes the evaluator between epochs while holding it fixed within an epoch. Both expose the same requirement: an independent criterion is needed to show that optimizing or changing an evaluator improved the intended objective.
Research comparisons also depend on budget and evaluator access. RE-Bench (2024) shows that relative human-agent performance changes with the time horizon. Anthropic’s Automated Weak-to-Strong Researcher (2026) used nine agents for 800 cumulative hours and allowed repeated queries to the remote score. Its headline result demonstrates productive automated search, but part of the nominal test signal became validation.
OpenAI’s internal report (2026) records 3.1 agent workdays per human workday by mid-August. Researchers wrote more code and ran more experiments while available compute also increased. High-level planning remained a small fraction of agent activity, and more than half of successful four-to-eight-hour tasks involved at least one human intervention. These measurements establish greater automation of research execution without isolating its effect on model progress.
Finance turns evaluation into a statistical problem
AQuA (2026) contains separate systems for symbolic-factor search and model-configuration search. Each retains validated evidence and uses it to guide later proposals. The sandboxes fix data splits, features, labels, evaluator logic, and allowed actions. Because the experiments do not include a compute-matched condition without persistent memory, later gains can reflect retained evidence, additional search, or both.
Agentic Empirical Asset Pricing (2026) makes a valuable methodological distinction. An output backtest evaluates one factor or strategy selected after a search. A system backtest reruns the full discovery process at historical decision dates and asks whether that process could repeatedly produce usable outputs.
Its SEADS implementation retains attempt logs, reflector lessons, and an admitted-factor library. Component ablations show that these mechanisms affect performance, but the rolling comparison does not isolate persistence from other system differences. Mutation retries add unmatched compute, historical runs use a current model, headline Sharpe is gross of costs, and most cross-system differences are not reliably distinguishable at the reported sample size.
The Self-Driving Portfolio (2026) describes a meta-agent that compares forecasts with realized returns and can revise prompts, skills, and Python code. The authors report insufficient out-of-sample evidence to determine whether those revisions improve later allocation. The paper specifies an update mechanism without establishing its downstream effect.
Markets add non-stationarity, multiple testing, revised-data leakage, and transaction costs to every evaluation path. An adaptive research system needs an independent final test and a record of failed trials. Otherwise, it can become a more efficient optimizer of the historical score it repeatedly sees.
Economic acceleration is a separate claim
The Economics of Recursive Self-Improvement (2026) models feedback between research capability and later improvement. Its calibration depends on assumptions about research production, compute, substitution, transfer, and diminishing returns. The model identifies conditions that could support sustained acceleration, but does not measure a universal empirical growth law.
Numerical takeoff probabilities require a separate analysis. They depend on which research tasks become automatable, how human judgment and compute enter the production function, and whether improvement procedures transfer to the systems that create later models.
What current evidence establishes
Current systems can:
retain changes in memory, code, research policies, and weights beyond a single attempt;
improve executable artifacts under automated evaluation;
modify parts of the machinery that produces later improvements and transfer a modified procedure in bounded experiments; and
automate bounded research loops on human-selected, outcome-gradable problems.
Public evidence does not yet establish:
repeated construction and independent validation of more capable foundation model successors;
improvement of the full outer loop, including agenda selection, objectives, and final evaluation;
sustained transfer beyond the optimization environment; or
acceleration caused by inherited system changes after accounting for human labor, compute, data, and task selection.
The next issue will turn these distinctions into an audit for self-improvement claims.
A compact reading path
Eight sources provide the shortest route through the technical progression:
I. J. Good, “Speculations Concerning the First Ultraintelligent Machine” (1965) for the intelligence-explosion argument.
Goedel Machines (2003) for the formal self-rewrite problem.
Reflexion (2023) for persistent linguistic memory without weight updates.
Self-Taught Optimizer (2023) for a program that improves its own improvement procedure while the model stays fixed.
AlphaEvolve (2025) for evaluator-driven evolution of executable programs.
Darwin Goedel Machine (2025) for inherited changes to agent code.
Hyperagents (2026) for an editable meta-agent and transfer test.
A-Evolve-Training (2026) for inherited research-policy revision across post-training rounds.
For quantitative research, add AQuA (2026) for persistent experimental evidence and Agentic Empirical Asset Pricing (2026) for rolling evaluation of the discovery system itself.
Learn how to inspect the system
On Thursday, October 1 at 11:00 AM ET, I am teaching a free 30-minute lightning lesson: Can AI agents improve themselves?. We will map current systems by what they change, what they keep fixed, and what their experiments establish.
The Agent Engineering workshop follows on Saturday, October 3. Participants build and evaluate an auditable multi-agent forecasting system with traces, ablations, probabilistic scores, and calibration checks.
I like the idea of rerunning the whole search at each historical date. Testing only the final strategy leaves out a lot.