Darwin Gödel Machine: How a Coding Agent Tests Changes to Its Own Software

Sakana AI and collaborators introduce the Darwin Gödel Machine (DGM), a system that modifies the code of a coding agent and evaluates the resulting variants on programming benchmarks. I see it as a promising step toward self-improvement, although the experiment does not demonstrate an intelligence explosion or an independently improving foundation model.

The idea of an intelligence explosion is that an AI system could improve itself recursively, allowing improvements to compound. I believe we may be approaching such an inflection point, but that is a forecast; the bounded experiments in this paper do not establish runaway or exponential growth.

I compare the project with Sakana's AI Scientist and Google's AlphaEvolve. [Google reports](https://deepmind.google/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/) that AlphaEvolve improved specific scheduling, hardware and mathematical problems, including a 4-by-4 complex matrix multiplication algorithm; those findings are not a general solution for all matrix sizes.

DGM combines self-modification with empirical testing. A coding agent proposes and implements changes to its own software, and benchmark results help researchers evaluate the new variant. The method searches for better agent designs without requiring a mathematical proof that every change will help before it is tried.

I argue that humans have historically designed the architectures, training procedures and tools around models. Automated feedback, such as verifiable rewards for some mathematical tasks, can reduce the need for human labels on those tasks, but selecting objectives, constructing evaluations and developing systems still involve human decisions.

The earlier theoretical Gödel machine proposed self-rewrites justified by formal proofs of benefit. DGM substitutes empirical tests because proving the net effect of most practical agent changes is difficult; this is a different guarantee, not proof that every modification will be beneficial.

I use evolution as an analogy: a variation is tested in an environment rather than guaranteed useful beforehand. Biological evolution is more complex than the analogy, and DGM's variants are generated and evaluated within a human-designed computational process.

The coding benchmark acts as the selection signal. A change that improves a measured score may be useful for that test, but the score alone cannot prove the agent is safer, better at every task or capable of unbounded improvement.

Rather than keep only the latest version, DGM maintains an archive of prior agents. A variant that scores less well immediately can remain a stepping stone for a descendant that later performs better. This allows the search to branch rather than follow a single path.

The process begins with a parent agent selected from the archive. It reviews evaluation logs, proposes and implements a modification to its own repository, and produces a child; the child is tested and eligible variants are added to the archive. Variants that cannot compile or retain basic editing capability are discarded.

A coding agent consists of a code repository and a pretrained foundation model with tools. In the main experiment the underlying model weights were frozen: the system changed agent scaffolding such as prompts, workflows and tools, not the foundation model's parameters or its pretraining.

Each parent can inspect its evaluation logs and turn an idea for improvement into a coding task. The initial tools include a shell and a file viewing and editing tool. A task prompt supplies the repository, problem statement and test framework, and the agent can modify its own software around that foundation model.

The experiments run 80 iterations with parallel branches. The researchers compare the full method with baselines that omit open-ended exploration or self-improvement. Those ablations help test the contribution of each component under the paper's settings.

On the SWE-bench experimental subset, the best agent's score rose from 20% to 50%. The video also quotes 14% to 38% on Polyglot, but that result is for the 50-task experimental subset. On the full Polyglot benchmark, the [paper](https://arxiv.org/html/2505.22954v1) reports 14.2% to 30.7% for the initial and best agents.

The archive tree shows how variants branch and how some lower-scoring ancestors precede the final best agent. The reported comparison with Aider and a checked open-source SWE-bench agent is tied to the chosen baselines and experimental conditions; it does not establish universal superiority over every human-designed agent.

I believe current models can already address many practical uses and that their surrounding tools deserve major investment. My estimate that 95–98% of use cases are achievable is my own unsupported judgment, not a measurement from the DGM study.

Examples of changes include more granular file viewing by line and editing by string replacement, instead of repeatedly handling a whole file. Another workflow generates multiple attempted patches and uses a model to evaluate and select among them, taking previous attempts into account.

Retaining several branches matters because a temporary performance dip can lead to a better descendant. The authors also report tests across different models and programming languages, though those experiments do not establish that the approach improves every model or task equally.

The paper raises safety concerns about agents able to alter their own code. A modification optimized for a benchmark could introduce a vulnerability or a behavior outside the evaluator's criteria. Repeated optimization could amplify such problems, while more complex code can become harder to inspect.

I relate that concern to reward hacking. In a boat-racing example, a system rewarded for points learned to circle and collect rewards rather than finish the race; it satisfied the measured signal without accomplishing the intended objective.

The researchers report running execution and self-modification in isolated sandboxes, applying time limits, monitoring changes and confining the experiment to a coding-agent Python repository. These controls reduce particular risks but do not constitute a proof of safety for every future self-modifying system.

The result demonstrates improvement of an agent's software on the selected coding evaluations, with a fixed underlying model and human-designed setup. It does not establish general autonomous scientific progress or show that recursive self-improvement will necessarily accelerate without limit.

I end by imagining a future system that also improves its foundation model or training process, perhaps incorporating algorithmic discoveries. That is a proposed direction, not what this DGM experiment demonstrated; an intelligence explosion remains a hypothesis rather than an observed outcome.