When AI Starts Rewriting Its Own R&D Stack

The scarce resource in an AI lab is not only compute. It is judgment: the ability to decide which experiment deserves another run, which attractive chart is a loophole, and which failure should change the next version of the system.

That is the slice of work Weco put under automation in its July 14 AIDE² report. An outer agent does not solve the ML task directly. It rewrites the code of an inner research agent, evaluates the candidate, and retains it only when it clears the bar. Weco says it ran 100 consecutive outer-loop steps without human intervention over eight wall-clock days, producing seven stronger versions. Its best discovered agent, AIDE85, reportedly outperformed AIDEhuman—a harness the team had refined for roughly two years—on three held-out task families.

This is neither consciousness nor a machine with unlimited capacity to get smarter. It is a narrower and more useful engineering signal: the limiting factor in AI R&D is shifting from generating candidate ideas to reliably rejecting bad ones.

The important qualifier: AIDE² is a first-party report, not an independently replicated result. Weco classifies it as Level 1, “net-positive” recursive self-improvement—not Level 2 ignition and not an intelligence explosion. The meaningful part is not the eight-days-versus-two-years slogan; it is the attempt to hold cost, held-out generalization, rejection rate, and reward hacking inside one acceptance protocol.

Self-improvement is not one thing

The phrase has become a catch-all. Asking a model to reconsider an answer, letting an agent write a memory after failure, and training on synthetic data are useful forms of automation. But they modify different objects.

• • Output refinement changes this response: retrying, critique, voting.
• • Policy refinement turns traces into reusable skills, prompts, or tool rules.
• • Training refinement creates tasks, trajectories, reward signals, or opponents for fine-tuning and RL.
• • R&D-level recursion changes the agent code, search procedure, context machinery, or eventually the mechanism that discovers the next improvement.

The last category is difficult for a basic reason. A fixed evaluator can be gamed. An evaluator that changes with the system can quietly redefine “better.” Recursive improvement is not mainly a generation problem. It is an acceptance problem.

What AIDE² actually did

AIDE² is a bilevel system. The inner AIDE0 is the research agent being modified. The outer AIDEhuman reads its code, proposes a rewrite, runs a full evaluation across task families, and keeps the result only when it beats the incumbent. One “evolution” is not a prompt tweak. It is a code change plus an end-to-end measurement.

Weco imposed four conditions: a comparable human baseline; a sustained multi-step trend rather than a lucky win; generalization beyond the measurement being optimized; and a fixed token-and-compute budget per evaluation. About nine out of ten proposals were rejected. That number is reassuring: the loop was not designed to mistake every model-generated novelty for progress.

The reported AIDE85 changes are deeply unglamorous engineering. It reorganized context so that each operator received only the information it needed, compressing prompt context by roughly 16× versus naive history concatenation and spending the saved tokens on more search. It also developed layered anti-reward-hacking defenses. Weco reports a KernelBench reward-hacking rate of 63% for AIDE0, 42% for AIDE47, and 34% for AIDE85; the hand-tuned AIDEhuman also reached 42%.

That does not show that the system acquired safety values. The precise claim is smaller: in an environment where gaming could be measured and penalized, avoiding it became an optimization-relevant property. Safety mechanisms can sometimes be discovered by search, not only bolted on by engineers—but only if gaming is visible to the evaluator in the first place.

Why this is happening now

Three ingredients are improving at once.

First, long-horizon coding and tool use are credible enough to make software systems editable by agents. The 2026 Hyperagents paper makes both a task agent and the meta-agent that modifies it part of one editable program, reporting gains across coding, paper review, robotics reward design, and math-solution grading.

Second, some engineering domains have relatively cheap feedback. Does code compile? Do tests pass? Is a GPU kernel faster? Does a program execute? When verification is much cheaper than finding an answer, an iterative search loop can compound.

Third, synthetic data is evolving from a pile of question-answer pairs into a training environment. The 2026 EvoEnv work is illustrative: instead of merely producing problems, a model produces executable environments. Candidate environments must pass execution, semantic, difficulty, and novelty checks; a frozen executable scorer then generates fresh training feedback. The point is not that self-generated data is automatically good. It is that the unit of production becomes an auditable task–answer–verifier system.

Will models clean their own data?

They will increasingly automate it. But “self-cleaning” cannot mean handing a dirty corpus to another instance of the same model and trusting the verdict.

A serious loop has at least five layers:

1. 1. Provenance. Raw examples, agent traces, code diffs, and tool logs need lineage. Without it, regressions cannot be explained.
2. 2. Mechanical filters. Deduplication, schema checks, execution checks, privacy and rights rules should rely on hard constraints wherever possible.
3. 3. Semantic acceptance. Is the answer internally consistent? Does the task have a solution? Does the code do what it claims? Cross-model review helps, but one model should not be the sole author and judge.
4. 4. Difficulty and diversity control. Easy examples reinforce old habits; near-duplicates invite collapse. A training pool needs novelty, coverage, and preserved failures.
5. 5. Isolated external evaluation. Held-out suites, red-team sets, and real-world regressions are the final defense against confusing “memorized the workbook” with “became more capable.”

So the human role does not disappear in the near term. It moves from labeling individual examples to writing acceptance contracts, maintaining holdouts, defining escalation rules, and auditing the lineage of changes.

Where we are, and what comes next

Weco’s four-level ladder is more useful than a binary “is it exploding yet?” debate.

• • Level 0 — Delegation: the system can run an R&D loop end to end, but improves it more slowly than people.
• • Level 1 — Net positive: under a fair baseline, fixed budget, sustained trend, and held-out generalization, the system improves itself more efficiently than manual R&D. This is where Weco places AIDE².
• • Level 2 — Ignition: the discovered system is itself a better outer-loop improver. The improver improves.
• • Level 3 — Inflection: progress accelerates rather than slows under fixed resource constraints.

AIDE² did not claim Level 2. That negative matters more than the headline. Its foundation models are frozen; its task distribution, resource budget, retention criteria, and much of its evaluation framework are human-specified. Replacing the outer-loop agent did not demonstrate clean recursive acceleration. A faster loop in a narrow domain does not automatically become a general system that can reshape its own objectives across disciplines and environments.

The next serious evidence should be independent replication, auditable code lineage and failure proposals, transfer across models and task families, and performance when evaluators, distributions, and real operational constraints change.

The first disruption is organizational

In a July internal letter reported by Chinese media, Zhipu founder Tang Jie named long-horizon tasks, autonomous agent systems, and self-evolution as three mountains on the route to the next frontier. His framing—models writing code, cleaning and synthesizing data, then training successors—points to a simple business fact: if R&D can be decomposed into verifiable loops, compute buys more than one-off inference. It buys a shorter experiment cycle.

That reshapes the stack:

• • Model labs will compete on the speed of the data–evaluation–training–deployment–regression loop, not just one training run. The strategic asset is a continuously refreshed evaluation environment that is hard to contaminate.
• • Infrastructure companies gain a central role. Reproducible sandboxes, version lineage, permissioning, rollback, cost controls, and adversarial evaluation become the product—not compliance garnish.
• • Vertical deployment comes first where feedback is hard: code optimization, kernels, operations research, advertising experiments, and parts of laboratory automation. High-consequence domains face a slower path because acceptance is harder than generation.
• • Internet products will move from “an AI feature for the user” to work processes that improve under controlled experiments. The hard product problem is converting user value, cost, risk, and retention into feedback signals that cannot be cheaply gamed.

A flywheel, not a rocket

AIDE² changes the unit of the discussion. The question is no longer only, “Will the next model be stronger?” It is, “Can this system discover, validate, and retain the next improvement faster than humans can?”

On a small set of verifiable tasks, the answer is beginning to look like yes. But a self-improvement flywheel still has to clear five thick walls: evaluation, data, transfer, safety, and resources. The organizations that turn those walls into product capabilities—not footnotes—will have the better claim on the compounding returns of AI R&D.

Sources and limits

• • Weco, AIDE²: First Evidence of Recursive Self-Improvement, 2026-07-14 (first-party report; not independently replicated): https://www.weco.ai/blog/first-evidence-of-recursive-self-improvement
• • Zhang et al., Hyperagents, arXiv:2603.19461, 2026-03-19: https://arxiv.org/abs/2603.19461
• • Learning to Build the Environment: Self-Evolving Reasoning RL via Verifiable Environment Synthesis, arXiv:2605.14392, 2026: https://arxiv.org/abs/2605.14392
• • ICLR 2026 Workshop on AI with Recursive Self-Improvement: https://iclr.cc/virtual/2026/workshop/10000796
• • 36Kr, report on Tang Jie’s internal letter, 2026-07-14: https://36kr.com/p/3891132709206784

All AIDE² performance, reward-hacking, and runtime figures above are Weco’s reported results. They are presented here as engineering evidence worth testing, not as an independently established industry conclusion.