Meta Revolutionizes AI with Its Self-Improving Hyperagents

Meta and Its Partners Push the Limits of AI

Researchers from Meta, in collaboration with several universities, have developed hyperagents, artificial intelligence systems that not only solve tasks but also optimize the very mechanism they use to improve themselves. This innovative approach works across various task domains and could pave the way for self-accelerating AI.

Self-improving AI systems have always faced a paradoxical wall: the mechanism controlling the improvements is written by humans and never changes. No matter how much the system optimizes itself, it can never exceed the limits of this fixed mechanism. A research team from Meta, the University of British Columbia, and other institutions aims to break this ceiling with what they call hyperagents.

A hyperagent combines two components into a single modifiable program. The first solves a specific task, such as evaluating a scientific paper or designing a reward function for a robot. The second modifies the entire agent and creates new variants. Since both parts reside within the same code, the second component can also rewrite itself. Thus, the system not only improves in task resolution but also becomes better at determining how to improve in the first place.

Previous Self-Improvement Only Worked for Coding Tasks

The new system builds on the Darwin Gödel Machine (DGM), a method that has already shown that a coding agent can improve step by step through repeated self-modifications. The agent generates variants of its own code, tests them, and saves successful versions in an ever-growing archive as steps for future refinements.

In programming, there is a natural link: a better programmer also writes better self-modifications. Outside of coding, this link breaks down. An agent that improves in evaluating scientific papers does not automatically become better at rewriting its own code. According to the article, the original DGM achieves nearly zero performance on tasks outside of programming without manual adjustments.

Hyperagents circumvent this problem by making the improvement mechanism itself subject to optimization. The team calls the resulting approach DGM-Hyperagents (DGM-H). The evolutionary process with the archive remains intact, but the meta-level is no longer fixed.

DGM-H Shows Major Gains in Four Task Domains

The team tested DGM-H in four domains, starting with a simple hyperagent whose task agent initially uses a single call to a language model. On the Polyglot coding benchmark, DGM-H improves from 0.084 to 0.267, placing it on par with the original DGM, even though the system was not specifically built for coding.

In paper evaluation, where the agent must predict whether an AI conference will accept or reject a paper, the test performance rises from 0.0 to 0.710. Several of the top agents surpass a static baseline set at 0.630.

In reward design for robotics, where the agent writes reward functions for a quadruped robot in a physical simulation, performance climbs from 0.060 to 0.372. According to the article, DGM-H almost always generates reward functions that make the robot jump instead of getting stuck in the local optimum of simply standing still.

Ablation studies suggest that both main components are essential: a fixed meta-agent leads to little or no improvement, and without an open exploration archive, progress stagnates just as severely.

Improvement Strategies Transfer to Entirely New Domains

The most striking discovery concerns transfer between domains. Hyperagents trained on paper evaluation and robotics can produce significantly better task agents in an entirely new domain: evaluating mathematical solutions from Olympiads. Using the imp@50 metric that the team introduced, which measures performance gain after 50 iterations, transfer hyperagents achieve a score of 0.630. The initial and transfer agents from the original DGM remain stuck at 0.0.

In other words, DGM-H acquires general self-improvement skills that work even in unknown territories instead of simply learning specialized tasks. This difference is statistically significant. Running these improvements over multiple cycles shows a higher median for transfer agents, although this gap is no longer statistically significant.

The System Builds Its Own Tools Without Instruction

A closer examination of code changes reveals that DGM-H develops a range of infrastructure components by itself, without explicit instructions. It creates a performance tracking system that stores data across generations and calculates improvement trends. It also builds a persistent memory that not only logs numbers but synthesizes insights from them.

Here’s an example drawn from the experiments: "Gen55 has the best accuracy but is too strict. Gen64 has improved balance but has lower accuracy. Need to combine the critical reasoning of gen55 with the balance of gen64."

In paper evaluation, the system detects when its predictions go awry, such as when 94% of all evaluations return as "Accepted," and corrects the issue on its own. In robotics, DGM-H gradually assembles an internal knowledge base documenting valid environmental variables, constraints, and scaling heuristics, eliminating compilation errors along the way.

In early experiments where the system could also adjust its own selection logic, it independently discovered strategies that weigh proven solutions against trying new variants. These self-discovered strategies outperform random selection, but they have yet to catch up with carefully designed mechanisms.

Safety Measures and Open Risks

All experiments were conducted in isolated environments with limited resources, restricted internet access, and human oversight. However, researchers warn that these safety measures may reach their limits as self-improving systems become more powerful.

Among other concerns, these systems could evolve faster than humans can verify them, and agents might exploit weaknesses in evaluation to appear better on paper without actually improving in the real task.

Technical limitations also remain. The system operates with a fixed task distribution and cannot modify the external optimization loop. The code is available on GitHub.

Recently, the Chinese AI company MiniMax launched M2.7, a model that reportedly improved its own training process over more than 100 autonomous cycles. OpenAI also stated that its coding model Codex 5.3 significantly accelerated its own development.