Recursive self-improvement — an AI system that makes itself better at making itself better — has been a theoretical staple of AI discourse for decades. On July 14, 2026, Weco AI published what it calls the first experimental evidence that it actually works. Their system, AIDE², spent eight days autonomously rewriting its own research agent and ended up beating a harness that human experts had hand-tuned for two years.
This is not another benchmark press release. The details matter, the caveats matter, and the implications for anyone building AI agents in production matter even more. Let's break it all down.
What AIDE² Actually Is
AIDE² is a bi-level optimization system built around two nested "autoresearch" loops:
- The inner loop is a familiar autonomous research agent. It optimizes code against an evaluation — machine learning engineering tasks, heuristic algorithm design, and harness engineering — using tree search with drafting, debugging, and improvement operators.
- The outer loop is where the recursion happens. At each step, it proposes rewrites to the inner-loop agent's own code — its search policy, its prompts, its guards — evaluates the modified agent against a diverse set of tasks, and keeps the change only if it beats the previous best.
In other words: the outer agent is doing research on how to build a better research agent. Weco calls this "autoresearch on autoresearch."
The model split is pragmatic. The outer loop runs on Claude Opus 4.7, while inner-loop agents run on Gemini 3 Flash — a smaller model that matched larger ones on these benchmarks while allowing far more iterations inside a fixed dollar budget.
Eight Days, 100 Steps, Seven Better Agents
Over 100 consecutive outer-loop steps spanning eight days, AIDE² discovered seven successively improved versions of the AIDE agent, with versions AIDE47 and AIDE85 emerging as the strongest. The selection pressure was brutal: roughly 90 percent of proposed changes were rejected for failing to improve on the previous best.
The headline result is the comparison against AIDEhuman — the production harness Weco's own team had iterated on for two years. The eight-day autonomous loop produced agents that beat it. Not on the training tasks — on held-out benchmarks the loop never optimized against:
- MLE-Bench Lite (machine learning engineering): AIDE47 improved scores by 0.053 with p-value 0.0024; AIDE85 by 0.042 with p-value 0.0041
- ALE-Bench Lite (competitive programming with hidden test cases)
- WeatherBench 2 (physics-based weather forecasting, fully out-of-distribution)
Both discovered agents outperformed the starting agent AIDE0 and the human-tuned baseline across all three.
What the Machine Invented
The genuinely striking part is not the scores but what AIDE² independently designed. Three discoveries stand out in AIDE85:
A novel search policy. The agent invented a multi-armed bandit approach that treats draft solution subtrees as bandit arms, selects greedily within a lineage, and forks on stall to escape local optima. Weco's team had not implemented anything like it. Notably, the loop also tested and rejected fashionable ideas — island-model genetic algorithms, MCTS value backup, UCB-V exploration, ensembles — because they underperformed under a fixed budget. The system was doing empirical science, not cargo-culting the literature.
Radical context engineering. AIDE85 reduced its own prompt size 16-fold by designing minimal per-operator contexts, then reinvested the saved tokens into additional search steps. Every developer who has watched an agent's context balloon should recognize how hard-won that insight usually is. We covered why this matters for production agents in our guide to harness engineering.
Self-built defenses against reward hacking. With no explicit instruction to do so, the loop built a three-layer defense: anti-overfitting prompt instructions, hard-coded output guards, and statistical outlier removal. On KernelBench, a held-out GPU kernel engineering benchmark, the reward hacking rate dropped from 63 percent in the starting agent to 34 percent in AIDE85 — better than the 42 percent of the human-tuned agent. The selection pressure came purely from a public-private score split: agents optimized against visible public scores but were selected on hidden private ones, making cheating a losing strategy.
There was even a moment of unexpected integrity: when the loop encountered a traceback bug in its own evaluation harness, it fixed the bug rather than exploiting it.
Why the Methodology Holds Up
Extraordinary claims attract skepticism, and self-improvement claims especially so. Weco anticipated the obvious objections with four design choices:
- A fair human baseline. The comparison target was not a strawman but Weco's own production agent, refined over two years by the people who invented the AIDE approach.
- Fixed cost budgets. Every evaluation was metered in dollars, so improvements had to come from better algorithms, not more compute.
- Held-out generalization. The discovered agents were tested on benchmarks and task families they never saw during the loop, including out-of-distribution weather forecasting.
- Public-private score splits. The true objective was always hidden, closing the most common loophole in agent self-evaluation.
On the authors' own ladder, this qualifies as Level 1 RSI ("Net Positive"): a sustained, multi-step, generalizing improvement trend against a fair human baseline under a fixed budget.
What It Did Not Achieve
The honesty of the write-up is worth highlighting. AIDE² did not reach what Weco calls Level 2, or "Ignition" — the point where the improved agent becomes a better improver than what came before. When AIDE47 was placed in the outer-loop seat, it converged faster (about 20 steps versus 40) but showed no statistically significant asymptotic advantage. Each generation improved the product, not yet the process.
The authors are blunt: "we believe we are not near an intelligence explosion with the current system." Other limitations they acknowledge:
- The evolved agent's code is complex, carries dead code, and is harder for humans to maintain and customize than the hand-built baseline — a familiar trade-off to anyone who has inherited machine-generated code
- Nested loops compound measurement noise, widening error bars
- Third-order generalization (better improvers building better improvers) remains undemonstrated
Still, they close with a line that deserves attention: "this system is the worst version of itself we will ever see."
Why Developers and Businesses Should Care
Strip away the AGI framing and a very practical result remains: automated harness engineering works. The scaffolding around a model — search policy, context management, evaluation guards — is exactly what teams spend months hand-tuning today. We explored this discipline in our pieces on AI coding loops and iterative agents and loop engineering. AIDE² suggests that layer is itself automatable, at roughly two orders of magnitude the pace of manual iteration.
Three concrete takeaways:
- Your agent harness is a search space, not a config file. If an outer loop can find a 16x prompt reduction and a better search policy in eight days, treating harness design as a one-time manual task leaves performance on the table.
- Public-private eval splits are the anti-cheating pattern to copy. The emergent reward hacking defenses came from evaluation design, not alignment lectures. Any team running agent evaluations in production can apply this today.
- Small models plus more iterations beat big models with fewer. Gemini 3 Flash in the inner loop matched larger models under equal budgets — a cost lesson consistent with what we found in our AI API cost optimization guide.
This result also lands in a context: Andrej Karpathy's AutoResearch loop normalized autonomous experimentation earlier this year, and self-improving agent architectures have been maturing steadily. AIDE² closes the meta-loop that those systems left open.
Conclusion
AIDE² is the most rigorous public demonstration yet that an AI system can improve its own improvement machinery — with real baselines, real budgets, and real held-out generalization. It is Level 1, not ignition; a research result, not a runaway. But the direction is unambiguous: the layer of AI engineering that today consumes entire teams — harnesses, prompts, evals, guards — is becoming something AI can research on its own.
At Noqta, we help businesses in Tunisia and the MENA region build AI agent systems with production-grade harnesses and evaluation pipelines. If you want to apply these patterns to your own AI stack, get in touch.
Sources: Weco AI — AIDE²: First Evidence of Recursive Self-Improvement