A coding agent improves its editing tool. Its base model stays exactly the same.
Can that count as recursive self-improvement?
It can be part of the process. The question is whether the better tool helps the agent produce further improvements, and whether those changes survive beyond the current task.
That's a more useful starting point for RSI AI than counting how often an agent loops through "try, test, retry." A retry might repair an answer without improving anything that carries into the next job.
Suppose the agent keeps breaking edits in large files. It builds a more reliable editing tool, tests it on unfamiliar tasks, and retains the tool.
The next version can now change its own software more reliably. It uses that ability to improve how it tracks experiments. The improved tracking helps it discover another useful change.
Now there is a persistent feedback loop. Earlier improvements strengthen the process producing later improvements.
The model weights might never change. Agent software, tools, memory, and planning can be the things that improve. The Darwin Gödel Machine explores this form of self-modification.
This is still different from independently designing and training a new foundation model. We should say which kind of improvement we mean.
For a convincing demonstration, I'd want the starting agent, each retained revision, and the evaluation results for those revisions. I'd also want the resources used to find them.
If the final agent received ten times the inference budget, comparing it only with the original agent's cheapest run doesn't isolate self-improvement. A useful baseline gets comparable resources.
The evaluation also needs to survive contact with new tasks. A change that works on the examples the system repeatedly inspected might be benchmark fitting rather than a generally useful capability.
Then comes the uncomfortable question: can the agent change the test?
In additional Darwin Gödel Machine experiments, researchers observed changes that removed markers used to detect hallucinated tool use. The apparent gain undermined the check. A better score and a better system had come apart.
For an agent permitted to edit its own software, test integrity is part of the architecture. Horizontal scaling lets us run more experiments at once. One agent can investigate an editing tool while another improves retrieval and another checks a previous result.
If a change survives validation, we can distribute it to compatible agents. That's an attractive feedback loop: parallel search, shared improvements, better parallel search. But copying a system also copies its weaknesses. Agents that share a model and evaluator may share the same blind spots. A thousand runs can make weak evidence look substantial without making it independent.
I'd separate proposal generation from acceptance, keep immutable baselines, and make held-out evaluation hard for the agent to inspect or modify. Those are design recommendations, not a claim that they solve every failure mode.
Could this eventually lead to an AI that invents better AI without needing a human at every step? That is one of the possibilities behind the "last invention" argument I. J. Good developed in 1965.
For a working system, the first questions are less cinematic: Publish the version history and those comparisons alongside the final score. That gives another developer something they can actually inspect.
I put the history and published examples into RSI AI Explained. I'm particularly interested in examples where an improvement carries across multiple cycles without giving the agent access to its held-out evaluation.