HyperAgents: How Meta Built AI Agents That Improve the Way They Improve

Self-improving AI agents are not new. Systems like Sakana AI’s Darwin Godel Machine (DGM) already showed that agents could rewrite their own code to get better at coding tasks. But they all hit the same wall: the meta-agent — the part that decides how to improve — was fixed. Hand-crafted by researchers. Frozen in place.

Meta’s new open-source framework, HyperAgents, breaks through that wall. It merges the task-solving agent and the self-improvement agent into a single editable program, where the improvement mechanism itself can be rewritten. The result is an AI system that doesn’t just get better at tasks — it gets better at getting better.

The paper landed on Hacker News with 220 points and 77 comments, the GitHub repo has already pulled in 1.6K stars, and the research was accepted at ICLR 2026. Here’s what makes it interesting, and where the limits are.

The Infinite Regress Problem

Every self-improving AI system faces a fundamental question: who improves the improver?

If you have an agent that solves coding tasks, you can add a meta-agent that analyzes the coder’s failures and suggests modifications. But then you need something to improve the meta-agent. And something to improve that. This is the infinite regress problem, and it has blocked meaningful progress in recursive self-improvement for years.

Previous systems dodged this by keeping the meta-level fixed. The original DGM framework, for example, used a hand-written outer loop: researchers manually designed how the system would select, mutate, and evaluate agent variants. The task agent could evolve, but the evolution rules couldn’t.

HyperAgents takes a different approach. Instead of separating the task agent and meta-agent into distinct components, it collapses them into one self-referential program. The meta-level modification procedure is itself part of the editable code. When HyperAgents improves an agent, it can simultaneously improve the process it uses to generate those improvements.

The team calls this “metacognitive self-modification” — the system can reason about and modify its own reasoning process.

How DGM-Hyperagents Actually Works

The practical implementation, called DGM-Hyperagents (DGM-H), extends the existing Darwin Godel Machine framework. Here’s the loop:

Parent selection: The system picks promising agent variants from an archive, using both performance scores and diversity incentives to avoid getting stuck in local optima.
Variant generation: Using an LLM (the framework supports OpenAI, Anthropic, and Google Gemini APIs), the system generates modified versions of the selected agent’s code — including modifications to its own improvement logic.
Empirical evaluation: Each variant is tested on the target domain. No theoretical proofs required — just measurable performance.
Archive retention: Successful variants are stored for future reference, building a library of stepping stones.

The key difference from vanilla DGM: in HyperAgents, step 2 doesn’t just modify task-solving code. It can rewrite the parent selection strategy, the mutation approach, the evaluation pipeline — anything in the program.

One important caveat flagged by researchers on Hacker News: this modifies agent scaffolding and prompts, not model weights. The underlying foundation model stays frozen. As one commenter (yurimo, who works in the field) pointed out, the improvements are to “how the LLM is directed,” not to the LLM itself.

Benchmark Results Across Four Domains

The most compelling part of HyperAgents is that it works across radically different domains without domain-specific customization. The team tested DGM-H on four tasks:

Coding (Polyglot benchmark)
Pass@1 accuracy improved from 0.140 to 0.340 on the training split, and from 0.084 to 0.267 on the test set. This matched the performance of the original DGM, which required manual domain-specific tuning — HyperAgents achieved it with a domain-agnostic approach.

Peer Review
This is where DGM-H really stood out. Starting from a baseline of 0.0 accuracy, the system climbed to 0.71 on the test set. That beat AI-Scientist-v2’s score of 0.63. The system autonomously developed multi-stage evaluation pipelines with explicit checklists and decision rules — none of which were programmed in.

Robotics Reward Design
DGM-H discovered sophisticated reward functions for robot locomotion that exceeded both default and human-designed reward schemes. The agents figured out how to incentivize behaviors like jumping rather than just standing still.

Cross-Domain Transfer (Olympiad Math Grading)
This is the headline result for the framework’s generality. Meta-agents that had been optimized on paper review and robotics tasks were transferred — without any retraining — to grade Olympiad-level math solutions. The transferred HyperAgents achieved an imp@50 score of 0.63. By comparison, static systems and manually-customized DGM agents scored exactly 0.0 on the same task. They couldn’t transfer at all.

What the System Taught Itself

Beyond raw benchmark numbers, some of the most interesting findings are about what HyperAgents independently invented during its self-improvement runs:

Persistent memory systems — the agent created its own mechanisms for remembering past performance across iterations
Performance tracking utilities — it built internal dashboards to monitor which strategies were working
Label bias detection — in the peer review domain, it developed tools to check for systematic biases in its evaluations
Prompt templating — it abstracted its prompting strategies into reusable templates
Compute-aware planning — it learned to allocate its token budget strategically based on task difficulty

These emerged without any human instruction to build them. The agent decided these tools would improve its performance and wrote the code for them.

HyperAgents vs. Other Self-Improving Frameworks

The landscape of self-improving AI is growing fast. Here’s how HyperAgents compares to the main alternatives:

Darwin Godel Machine (DGM) — The direct predecessor. DGM showed impressive results (20% to 50% on SWE-bench) but required manual domain-specific customization of its meta-level. HyperAgents makes the meta-level editable, enabling cross-domain transfer that DGM couldn’t achieve.

Reflexion and similar prompt-based self-improvement — Systems like Reflexion improve through verbal self-reflection within a conversation. HyperAgents goes deeper: it modifies actual code, not just conversation-level reasoning. The improvements persist across sessions rather than disappearing when the context window resets.

AutoGPT / MetaGPT / multi-agent frameworks — These systems use multiple agents for different roles but don’t fundamentally modify their own architecture. HyperAgents is a single self-referential program that can restructure itself.

AI-Scientist-v2 — Focused specifically on automating scientific research. HyperAgents outperformed it on peer review (0.71 vs 0.63) while being domain-agnostic rather than science-specific.

The biggest limitation, as several Hacker News commenters noted: HyperAgents consumes roughly 88 million tokens per full run. That’s not cheap. And because it modifies scaffolding rather than weights, there’s a ceiling on how much improvement is possible through prompt and code changes alone.

The Research Team

HyperAgents is a collaboration across multiple institutions. First author Jenny Zhang completed the work during her Meta internship (she’s a PhD student at the University of British Columbia under Jeff Clune). Co-authors Bingchen Zhao (University of Edinburgh) and Wannan Yang (NYU, interning at Meta’s Superintelligence Laboratory) are equal contributors. The broader team includes Jakob Foerster, Jeff Clune, Minqi Jiang, Sam Devlin, and Tatiana Shavrina, spanning FAIR at Meta, Meta Superintelligence Labs, the Vector Institute, and Canada CIFAR AI Chair.

The code is available under a CC BY-NC-SA 4.0 license — open for research and non-commercial use. The repo requires Python 3.12 and API keys for the foundation model providers (OpenAI, Anthropic, or Google Gemini).

What This Means Going Forward

HyperAgents is a research framework, not a product. Running it costs serious compute, the safety implications of self-modifying AI are non-trivial (the team used sandboxing and human oversight throughout), and the improvements — while real — are still incremental rather than explosive.

But the cross-domain transfer result is genuinely significant. An improvement strategy developed for reviewing research papers turned out to help with grading math solutions, without any human intervention to bridge the domains. If that kind of transfer scales, it could mean that advances in one AI application area automatically propagate to others.

As one Hacker News commenter put it: “gains in coding ability can translate into gains in self-improvement ability” — because both evaluation and self-modification are, at their core, coding tasks. That’s the recursive insight HyperAgents is built on, and it’s what makes this framework worth watching.

FAQ

Is HyperAgents free to use?
The code is open-source under CC BY-NC-SA 4.0, meaning it’s free for research and non-commercial use. However, running it requires API access to foundation models (OpenAI, Anthropic, or Google Gemini), which have their own costs. A full run consumes around 88 million tokens, so API bills can add up quickly.

How does HyperAgents differ from the original Darwin Godel Machine?
The original DGM kept its meta-level improvement process fixed and hand-designed by researchers. HyperAgents makes the meta-level itself editable, so the system can improve how it improves. This enables cross-domain transfer — improvements discovered in one task domain can benefit completely different domains — which DGM couldn’t do.

Does HyperAgents modify the underlying AI model?
No. HyperAgents modifies the agent scaffolding, prompts, and code that direct the foundation model, but the model weights stay frozen. This is an important distinction — the ceiling for improvement is limited by what can be achieved through better prompting and code organization rather than fundamental model changes.

What domains has HyperAgents been tested on?
Four domains: coding (Polyglot benchmark), academic paper peer review, robotics reward design, and Olympiad-level math grading. The peer review domain showed the most dramatic improvement (from 0.0 to 0.71 accuracy), and the math grading domain demonstrated successful cross-domain transfer.

Can I use HyperAgents for my own projects?
The framework is designed for research. It requires Python 3.12, Docker for sandboxing, and significant compute resources. If you’re exploring self-improving agents for research purposes, it’s a solid starting point. For production applications, the compute costs and non-commercial license would be limiting factors.

Top AI Product

Leave a comment Cancel reply