Recursive self-improvement is becoming an evaluation problem

Recursive self-improvement once described a system that could redesign its own intelligence, use the stronger version to design an even stronger successor, and continue without a human directing each step. That remains a theoretical endpoint. The measured systems arriving now are narrower and more concrete.

A useful operational definition is persistent improvement to a component that affects future attempts. Revising one answer is self-correction. Saving a better tool, workflow, evaluator, training recipe, or model checkpoint changes what the next iteration can do. Recursion begins when the system participates in improving the machinery that produces later improvements.

A July 2026 survey of recursive self-improvement research organizes the field by what changes: deployment behavior, model policy, evaluator, or the research process itself. That taxonomy is more useful than treating every reflection prompt as evidence of RSI.

The important recent change is not that models suddenly became unbounded. More of the improvement loop has become executable, persistent, and measurable.

In April 2025, A Self-Improving Coding Agent demonstrated an agent with basic coding tools editing its own source code. The authors reported improvement from 17% to 53% on a random subset of SWE-bench Verified, with additional gains on LiveCodeBench and synthetic agent tasks.

That result matters because the saved artifact was not a better answer to one issue. It was a changed agent that could approach later issues differently. It also remains bounded by the authors' models, task samples, search budget, implementation, and benchmark feedback. A large gain on a subset is evidence about that loop, not a universal rate of self-improvement.

The Darwin Gödel Machine extended the idea in a different direction. Instead of keeping only the newest candidate, it maintained an archive of diverse agent versions and allowed temporarily weaker branches to remain available as stepping stones. The system modified both the coding agent and the meta-agent that proposed modifications.

The DGM authors reported SWE-bench performance rising from 20.0% to 50.0% and full Polyglot performance from 14.2% to 30.7%. The discovered changes included finer-grained file tools, better long-context management, and peer-review mechanisms. Some improvements transferred to other foundation models, while others barely moved performance. That uneven transfer is a useful warning: the configuration, evaluator, and model still interact.

Both papers are research preprints rather than independent Grid reproductions. They show that agent source code can become a searchable, persistent improvement surface. They do not show a system rewriting its model weights, inventing its own goals, or improving across arbitrary work.

The strongest evidence is not that an agent can edit itself. Coding agents already edit code. The advance is that a scored search process can decide which self-edits deserve to become ancestors.

Google DeepMind's AlphaEvolve is adjacent to strong RSI rather than a complete instance of it. The system uses Gemini models to propose programs, automated evaluators to run and score them, and an evolutionary database to select candidates for later prompts. It primarily improves target algorithms, not the Gemini models or the whole AlphaEvolve architecture.

That narrower loop has produced unusually concrete results. DeepMind reports that one discovered scheduling heuristic has recovered an average of 0.7% of Google's worldwide compute resources for more than a year. It also reports a verified circuit rewrite integrated into an upcoming TPU and new results in matrix multiplication and open mathematics.

A May 2026 impact update describes the same search pattern moving into genomics, power-grid optimization, quantum circuits, and other scientific problems. Those are first-party claims across different experimental settings, not one controlled comparison. The common mechanism is more durable than any single number: proposals survive because an external process can calculate whether they work.

This explains why code, mathematics, chip design, scheduling, and simulation are early RSI surfaces. They provide dense feedback, repeatable execution, and hard rejection. A system can generate many strange candidates without requiring a person to read every one. In strategy, policy, research direction, or organizational design, the evaluator is slower, contestable, and partly constitutive of the goal.

RSI advances first where improvement can be compiled into a test. The less objective the evaluator, the more of the loop remains a governance decision.

A June 2026 preprint, A-Evolve-Training, reports an autonomous system running four rounds of post-training on a 30-billion-parameter Nemotron model over multiple weeks. The loop proposed data and recipe changes, launched training, read evaluations, and selected what to retain without a human choosing each intervention.

The authors report a held-out score of 0.86 against 0.87 for the top human submission on the public NVIDIA Nemotron-Reasoning Challenge, placing the autonomous result eighth among roughly 4,000 entries at the time of writing. More interestingly, they report that the loop noticed its development metric had stopped tracking the external target and changed its search policy. That is a step beyond maximizing one fixed score.

The claim still has sharp boundaries. It is one preprint, one 30B competitive comparison, and one public challenge. The authors also closed training loops at 120B and 550B, but explicitly defer effectiveness claims because there is no comparable human baseline. Closing a loop at scale is infrastructure evidence; it is not proof that the loop improves well.

The object of improvement is broadening at the agent layer too. EvoSkills co-evolves reusable multi-file agent skills and a surrogate verifier while keeping ground-truth tests hidden. On 86 SkillsBench tasks, the authors report a 71.1% pass rate versus 53.5% for human-curated skills; removing the surrogate verifier reduced the reported rate to 41.1%. The exact numbers remain benchmark-bound, but the ablation supports the mechanism: generation alone was not the improvement engine. Iterative verification was.

The improvement surface is climbing the stack—from answers, to harness code, to reusable skills, to training recipes and model weights. The evaluator travels with it.

Every self-improvement loop contains a claim about evidence. A candidate becomes an improvement only because a test, judge, reward model, simulation, rubric, or human accepts it. If that signal is incomplete, the search can get better at the proxy while the real objective stays flat or regresses.

The June 2026 Red Queen Gödel Machine tries to address the fixed-evaluator ceiling by allowing agent and utility to change across controlled epochs. The authors report stronger coding results with fewer tokens, higher acceptance rates for co-evolved paper writers under a diverse judge panel, and a 9% gain in ground-truth grading accuracy.

Co-evolution is a meaningful advance because static benchmarks saturate, leak, and invite overfitting. It is also dangerous to interpret too broadly. If the candidate and its judge drift together, they can form a self-confirming loop. A diverse panel of model judges is still not the same as independent ground truth, real users, formal verification, or a human decision owner.

The 2026 RSI survey argues that demonstrated improvement tracks a verification hierarchy: formal and executable verifiers provide the strongest grounding, while intrinsic self-assessment is weakest. The survey also identifies self-confirmation, diversity collapse, model collapse, and human direction-setting as unresolved constraints. That is a synthesis by three authors, not settled consensus, but it fits the pattern across the primary systems.

Let the system improve how it searches. Do not let it become the sole author, witness, and judge of what counts as better.

A benchmark gain is one property of one version under one evaluator. Production adoption adds security, cost, latency, reliability, compliance, user acceptance, and rollback. A change can improve the target score while making the complete operating system worse.

The same lesson appears in model-and-harness evaluations: versions interact, gains do not always transfer, and a component that helps one model or task can hurt another. RSI increases the rate of candidate production; it does not remove the need to test the entire configuration.

Benchmark capture

Repeated search can exploit quirks, contamination, or omissions in the score while held-out or real work remains unchanged.

Hidden regression

A candidate can gain average accuracy while losing rare capabilities, safety behavior, accessibility, or performance on another model and environment.

Cost displacement

More search, evaluator calls, training runs, and verification can make a better-scoring system uneconomic per accepted result.

Evaluator capture

A learned or co-evolved judge can reward the style, artifacts, or shortcuts produced by the candidate instead of the intended outcome.

Expanded attack surface

A system that edits code, tools, tests, or training infrastructure can turn an ordinary agent failure into a supply-chain or control-plane failure.

Irreversible drift

Without lineage and rollback, teams cannot reconstruct which self-generated change altered behavior or restore the last trusted version.

The faster a system can generate its own changes, the more important independent promotion gates become.

A company does not need to decide whether today's systems meet a philosophical definition of RSI. It needs a control model for systems that generate persistent changes faster than people can inspect them manually.

Treat the loop as governed change management. The agent record should connect every candidate to the system and model that proposed it, the parent version, changed files or weights, evaluation data, cost, permissions, reviewer, and promotion decision. The outcome record should continue after release so a lab gain can be compared with accepted production work.

Freeze the baseline

Keep immutable parent artifacts, benchmark versions, evaluator code, prompts, tool versions, budgets, and random seeds.

Separate proposal from acceptance

Do not let the same agent silently change the candidate, evaluator, holdout, and promotion rule in one step.

Use layered holdouts

Combine task tests with transfer sets, adversarial cases, cost ceilings, safety checks, and real outcome measures the search cannot inspect.

Sandbox the mutation surface

Limit which repositories, tools, credentials, networks, datasets, and training systems a candidate can alter or reach.

Require authority for objective changes

Changing what counts as success is a policy decision even when an agent can propose the new metric.

Promote gradually and roll back automatically

Use canaries, shadow traffic, intervention thresholds, and a known-good version rather than replacing production in one jump.

A self-generated code change is still a change. A self-generated evaluator is still policy. A self-generated model is still a governed production release.

Recent RSI work crosses an important threshold: systems can now generate persistent changes to parts of their own improvement machinery, test those changes, and reuse the winners. Self-editing agents, evolutionary program search, co-evolved skills, and autonomous post-training are not the same mechanism, but they are converging on a common loop.

What they have not removed is the outside world. Tests, simulators, hidden oracles, production metrics, human objectives, compute, and secure infrastructure determine which changes survive. The most credible systems make that grounding visible. The weakest interpretation of RSI hides it behind a model judging itself.

The near-term operating advantage will not come from declaring an agent autonomous. It will come from compounding improvements without losing the evidence trail: more candidates, faster rejection, cleaner lineage, controlled promotion, and real outcome feedback. The system can participate in improving itself. The company still has to govern what improvement means.