Recursive Self-Improvement in Agentic AI: What It Actually Looks Like in 2026

Recursive self-improvement in agentic AI suggests that an AI system could be capable enough to upgrade the tools, code, or prompts that power it, then use those upgrades to get better at making the next round of upgrades. The improvement feeds back into the system’s own ability to keep improving, which is what separates it from a normal software update.

Most of what gets called “self-improving AI” right now, however, falls into this bounded version:

• An agent rewrites its own helper functions, tests them, and keeps the ones that work
• A coding agent optimizes a training script, times it, and repeats
• None of it is a model quietly rewriting its own weights with no one watching, that version still belongs to research labs and open questions, not production systems

This post walks through what that loop actually looks like in practice, the real examples running right now, and where the line sits between the bounded version we have today and the much bigger claim of full self-improvement.

What Is Recursive Self-Improvement?

Recursive self-improvement is a feedback loop where an AI system upgrades the mechanism that produces its own outputs, not just the outputs themselves.

A regular software update is a human deciding what to fix and shipping the fix. RSI works differently:

• The system itself does some or all of the deciding
• What it changes affects its own future performance: a prompt, a tool, a piece of code, a scoring function
• Every pass through the loop starts from a stronger baseline than the last one

This is a different concept from agentic AI in general. Agentic AI describes systems that reason, plan, and take action toward a goal. RSI describes a narrower behavior: an agentic system that directs some of that action back at itself.

How the Loop Actually Works

Strip away the specific tooling and every recursive self-improvement setup runs through the same four stages:

• Perform: the agent does a task, writing code, running an experiment, answering a query
• Evaluate: the agent, or a paired evaluator, checks the result against a metric, whether the tests passed, the benchmark score went up, or the error rate dropped
• Modify: based on that evaluation, the agent changes something about itself, a prompt, a tool, a chunk of its own code
• Redeploy: the modified version replaces the old one, and the loop starts again from a better starting point

The evaluate step is what makes this recursive instead of just iterative. A system that repeats the same process without changing the process itself is running a loop, not improving one.

None of that is safe to run unsupervised without limits. A loop with no stopping condition will happily “improve” forever, burning compute and drifting from the original goal along the way. This is exactly what loop engineering design patterns exist to solve.

• Hard iteration caps
• Token budgets
• Circuit breakers
• Termination criteria defined before the loop ever starts

Without those guardrails, an agent evaluating its own output can talk itself into believing a bad change is a good one, which is a quiet way for a self-improvement loop to go sideways.

RSI vs. the Terms People Confuse It With

Most of what’s shipping in 2026 sits in that third row. The fourth row is the one Anthropic and others describe as still ahead of us, not a description of current systems.

Real Examples in 2026

Anthropic’s own engineering data

Anthropic published direct evidence of this loop inside its own development process:

• As of May 2026, more than 80% of the code merged into Anthropic’s codebase was written by Claude, up from low single digits before Claude Code launched in 2025
• Claude-powered agents were given an open safety research question and left to propose hypotheses, test them, and iterate across parallel agents
• Two human researchers spent about a week and recovered roughly 23% of a defined benchmark gap. The agents recovered about 97% of it over 800 cumulative hours, using around $18,000 in compute
• Humans still picked the problem and built the scoring rubric, but the experiment design and iteration ran on their own

OpenAI’s RSI Index

OpenAI has gone a step further than internal metrics. It built an actual benchmark for this and gave it a name.

• Alongside the July 2026 launch of GPT-5.6, shipped in three tiers called Sol, Terra, and Luna, OpenAI introduced the RSI Index, an aggregate score built from internal AI research tasks like debugging research systems, optimizing training recipes, and improving other models
• GPT-5.6 Sol scored 16.2 points higher than GPT-5.5 on that index
• In one demonstrated case, Sol was given a single underspecified prompt and used it to independently choose training configurations, select GPUs, and run the post-training job that produced the smaller Luna tier. OpenAI estimated that task would otherwise have taken two senior researchers roughly two extra weeks

The leaderboard is public and updates as new tiers get evaluated. As of writing, Sol leads at 0.579, ahead of Terra at 0.563 and Luna at 0.419.

AlphaEvolve

Google DeepMind’s AlphaEvolve is a Gemini-powered coding agent that evolves algorithms rather than writing them once:

• It generates code, scores it against a defined objective, and mutates the strongest-performing versions across many generations
• DeepMind has used it to find genuine improvements in data center scheduling and matrix multiplication algorithms
• That’s the kind of optimization work that used to take specialist researchers weeks

Karpathy’s AutoResearch

Andrej Karpathy pointed an autonomous agent at his own well-optimized GPT-2 training codebase, nanochat, and let it run unsupervised overnight:

• Over two days it ran roughly 700 experiments and found about 20 genuine speedups
• It cut time-to-GPT-2-quality from 2.02 hours down to 1.80 hours, on code Karpathy had already spent significant time refining himself
• One fix it found, a missing scalar multiplier in the QK-Norm implementation, was something Karpathy hadn’t caught

We broke down exactly how the system works and what it means for smaller teams in our full writeup on Karpathy’s autoresearch project.

Agent0

The examples above are all one agent improving against a fixed benchmark or codebase. Agent0 works differently: it uses two agents that improve each other.

• Both agents are derived from the same base model, and run an adversarial loop
• One proposes increasingly hard tasks, the other solves them using tool integration
• There’s no human-curated training data after the base model is set up
• Reported gains were 18% on math reasoning and 24% on general reasoning, on Qwen3-8B-Base

Weco AI’s AIDE2

Published July 14, 2026, this is the most rigorously tested claim of actual recursive self-improvement so far, an outer-loop agent rewriting the code of an inner-loop research agent, not a separate model entirely.

• Over 100 unattended steps across eight days, the outer loop produced seven successively better versions of the inner-loop agent
• The best version beat Weco’s own hand-tuned agent, the product of two years of manual iteration, on three external benchmarks it was never optimized on
• It also taught itself to reward hack less on a GPU kernel benchmark, cutting the cheating rate from 63% to 34% without being told to
• Weco frames this as reaching “net positive” self-improvement on its own four-level RSI ladder, one level below the harder bar of the improved agent becoming a better improver of itself

Inside an Actual Recursive Self-Improvement Loop

A number of the examples above involve one AI system improving something else: a codebase, a training run, a separate model. Recursive self-improvement in the strict sense means a system pointed at itself. Weco AI’s AIDE2, referenced above, is the clearest case of that so far. Here’s how it works:

The two loops:

• An inner loop: an autonomous research agent that optimizes code against an evaluation metric, the same way any autoresearch agent works
• An outer loop: a separate agent that rewrites the inner loop’s own code, evaluates the rewrite, and keeps it only if it beats the previous best

How one step actually runs:

• The outer loop proposes a change to the inner-loop agent’s code
• The rewritten agent runs through evaluation tasks spanning ML engineering, algorithm design, and agent-scaffold engineering
• Each result gets two scores: a public one the inner-loop agent can see and optimize against, and a hidden private one that actually decides whether the change survives
• Everything runs under a fixed cost budget, so a win has to come from a genuinely better approach, not just more compute thrown at the problem
• About 9 in 10 proposed rewrites got rejected on this basis

What 100 steps produced:

• Ran unattended for eight days
• Seven successively better versions of the inner-loop agent
• The best version beat Weco’s own two-years-hand-tuned agent on three benchmarks it never trained on
• Reward hacking on a GPU kernel benchmark dropped from 63% to 34%, an emergent behavior nobody explicitly asked for

The harder test, does the improvement compound:

• Weco then installed one of the discovered agents into the outer loop’s own seat, replacing the original optimizer, to check whether it had become a better improver, not just a better inner-loop agent
• It reached the same performance ceiling faster, but not by a wide enough margin to call it a clear result
• On Weco’s own four-level ladder, that puts AIDE2 at “net positive” self-improvement, meaning it beats human iteration on the same task. That’s one rung below “ignition,” the improved agent becoming a better improver of itself, which is the harder bar true recursive self-improvement still has to clear

Common Misconceptions

“RSI means the AI is rewriting its own weights.” Almost none of the systems above do this. They rewrite prompts, code, and tools around a fixed model, not the model’s parameters.

“This is the same as an intelligence explosion.” The intelligence explosion idea, going back to I.J. Good, describes open-ended, unbounded capability growth with no human in the loop. Every documented 2026 example still has a human setting the goal or building the scoring rubric somewhere upstream.

“If a system can self-improve, it will keep improving forever.” Every real system above hits a wall: a benchmark ceiling, a fixed training run, a task-specific scoring function. Removing that ceiling is a deliberate, difficult design choice, not a natural side effect of the loop.

“This is only happening inside AI labs.” The mechanics of an evaluate-modify-repeat loop are available in tools most developers already have installed. Building an actual RSI setup on top of one takes deliberate design, but the raw materials aren’t locked away in a research lab.

Why It Matters: Risks and Open Questions

The bounded version running today still carries real risk. A few worth naming directly:

• Weak self-evaluation compounds. If an agent’s judgment of “did this work” is flawed, a self-improvement loop reinforces a strategy that looks successful by its own metric without actually being one.
• Goal drift is harder to catch mid-loop. A human reviewing every step of a single task can catch a wrong turn. A human reviewing a loop that’s already run 500 iterations has a lot more ground to cover.
• The line between “improving its tools” and “improving its objectives” is where the real alignment concern sits, and that line gets less obvious as loops run more autonomously.

Anthropic has been explicit about where things stand:

• Full recursive self-improvement, an AI system autonomously designing and developing its own successor, hasn’t happened yet
• It isn’t inevitable either
• Their own published trend lines suggest it could arrive sooner than most institutions are prepared for

That’s a meaningfully different claim than “it’s already here,” and worth keeping straight when this term shows up in a headline.

FAQ

Is recursive self-improvement the same as AGI? No. RSI describes a specific feedback mechanism, an AI system improving the tools that power its own future output. AGI is a much broader, more contested claim about general capability across domains.

Can I set up a recursive self-improvement loop myself? You can build the pieces. Claude Code’s goal-based and proactive loop types, paired with the guardrails covered in loop engineering design patterns, give you the evaluate-and-repeat mechanics. What makes it RSI rather than a bounded agentic loop is adding a persistence step: feeding what worked back into a skill, prompt, or tool so the next task starts from a better baseline, not just re-running the same check until one task passes.

Does RSI require a lot of compute? It varies widely. Karpathy’s AutoResearch ran on a single GPU over two days. Anthropic’s automated research example used about $18,000 in compute over 800 cumulative hours. The bounded, task-level version most teams would build is far cheaper than either.

Is recursive self-improvement dangerous? The bounded version carries the same risks as any autonomous loop: goal drift, weak self-evaluation, runaway cost, if it isn’t built with proper stopping conditions. The open-ended version, where a system redesigns its own weights with no ceiling, is the scenario researchers are actively trying to get ahead of before it exists.

What’s the difference between RSI and fine-tuning? Fine-tuning is a human-directed training run that updates a model’s weights once. RSI is an ongoing loop where the system itself proposes changes, and those changes don’t necessarily touch the weights at all. They’re often prompts, tools, or code sitting around a fixed model.