A research group at King Abdullah University of Science and Technology (KAUST) has presented the Huxley-Gödel Machine (HGM), an AI agent built to improve itself by editing and testing its own code. The system is described in a paper by Wenyi Wang, Piotr Piękos, and AI pioneer Jürgen Schmidhuber.
HGM is framed as a partial implementation of Schmidhuber’s earlier idea of a "Gödel Machine": an AI system that would accept changes to itself only when those changes can be proven to improve long-term utility. The KAUST work does not claim to fully achieve that vision. Instead, it offers a practical route toward it by measuring whether self-modifications lead to better future agents.
From one agent to a whole lineage
The core problem the researchers address is that a strong score today does not necessarily mean a system will keep improving tomorrow. Many AI evaluations focus on near-term benchmark performance. The KAUST team argues that this can miss a more important question: whether an agent can produce better descendants over multiple generations.
They call this gap the "Metaproductivity–Performance Mismatch." In plain terms, an agent may look impressive on a short test but fail to create useful successors. Another version may appear weaker at first, yet produce a more productive line of agents after repeated self-modification and testing.
To capture that difference, the researchers introduce Clade Metaproductivity (CMP). Rather than judging only one agent in isolation, CMP evaluates the combined output of that agent’s descendants. This shifts the focus from a single snapshot of ability to the longer-term productivity of an evolving group.
That distinction matters because HGM is not just trying to solve tasks. It is trying to discover which changes to its own framework make future versions more capable.
How the Huxley-Gödel Machine changes itself
HGM estimates CMP values to decide which self-modifications are worth pursuing. The system uses tree search, Bayesian sampling, and adaptive scheduling to choose when to create new agents and when to keep testing existing ones.
The result is an agent that continuously experiments on its own design. It can rewrite Python files, test scripts, and tools, then run experiments to see whether the changed version is worth keeping. When a variant succeeds, HGM can permanently adopt it.
The self-improvement is focused on the language model’s surrounding machinery, not on changing the model’s stored knowledge. In the source description, the relevant areas include:
- control logic
- tool use
- error analysis
- agent architecture
- strategies and control flows
This makes the work especially relevant to AI agent design. A language model can be powerful, but the way it is organized into an agent also affects how well it plans, tests, uses tools, and recovers from mistakes. HGM targets that layer.
Benchmark results show why the approach is notable
The researchers first evaluated HGM on SWE-Bench Verified, a benchmark made up of 500 real GitHub programming tasks. Using GPT-5-mini, the agent solved 61.4 percent of tasks. The source reports this as the highest reported score for that model type.
HGM also outperformed the best human-designed GPT-5-mini agent on the official leaderboard. It ranked among the overall top ten systems even though some competing systems used larger and costlier backbones such as Claude 3.7.
The team then tested generalization on SWE-Bench Lite, which includes 300 new programming problems, with some overlap with the Verified tasks. With GPT-5-mini, HGM solved 40 percent of non-overlapping tasks and 49 percent of total tasks. With the larger GPT-5, those results rose to 48 and 57 percent, respectively.
According to the source, those GPT-5 results roughly matched the best human-designed systems, including SWE-Agent + Claude 4 Sonnet. On the Polyglot benchmark, which spans multiple programming languages, the team says HGM again outperformed earlier approaches while using two to six times less compute.
Why this is not just about a bigger model
The researchers emphasize that the important advance is not simply a stronger language model. Their claim is that HGM improves by modifying the agent architecture around the model. That means the gains come from self-directed changes to how the system works, not only from swapping in more capable model weights.
This distinction is central to the Gödel Machine connection. The original idea points toward systems that can improve themselves in a principled way. In practice, formal proofs for every self-change are nearly impossible to implement, so HGM uses experimental estimates of long-term productivity instead.
That makes HGM a step toward the vision rather than a completed version of it. The source is careful on this point: the system remains short of a true "Gödel Machine." Still, it demonstrates a concrete mechanism for building AI agents that refine their own learning strategies across generations.
What the work suggests about future AI agents
The KAUST team’s framing points to a future where agent progress may depend as much on self-improving workflows as on raw model scale. If an agent can test changes to its tools, control logic, and error analysis, it may become more effective without constant human tuning.
The implications are practical. An AI coding agent that can evaluate its descendants is not only chasing a better score on one benchmark. It is searching for changes that make later versions more productive. That is the central promise of Clade Metaproductivity.
For now, HGM is best understood as a research step toward adaptive, resource-efficient AI systems. It shows that self-rewriting agents can be evaluated not only by how they perform immediately, but by whether they create better successors over time.