Pinned Tweet
Anyone watching recursively self-improving agents knows how good they've gotten at optimising over a fixed benchmark with verifiable rewards, like math or coding. Our recent work, the Red Queen Gödel Machine (RQGM), co-evolves the evaluation itself together with the agent. 🧵
The Red Queen Gödel Machine (RQGM) is featured in the @stateofai report by @nathanbenaich.
Meanwhile, new RQGM GPT-6 Astra results on our held-out DeepSWE split:
- 82.1% vs 68.8% official Astra (low effort)
- 85.7% vs 83.0% official Astra (high effort)
Next: full DeepSWE eval.
@itsmaddox_j @williamfshen @DBBurkhardt @meghdadkurmanji Nurbek Tastan @lorenzosani97 @NickVenanzi Jiayi Nie @AmbroiseOdonnat @__cao_jamie__ Bill Marino @xinchiqiu @contactrika @niclane
@Cambridge_Uni @nvidia @flwrlabs @mbzuai @Inria
1
11
Research from @CaMLSys and @flwrlabs featured by @nathanbenaich in his @stateofai report.
Slide 13 covers our recursive improvement agent work -- Red Queen Gödel Machine led by @Alex__Iacob, @itsmaddox_j, @williamfshen.
Slide 45 includes AI safety benchmark: AIReg-Bench led by @billymarino and @Rosco_Hunter_
welcome to the 9th annual @stateofai report!
ai building better ai, world models, physical ai, geopolitics, cyber defense and 12-month predictions.
read it at stateof(dot)ai or watch my editor’s cut here.
a few of this year’s biggest findings follow:
Alex Iacob retweeted
Autonomous scientific discovery is becoming self-improving. But agents can only improve as far as the systems evaluating them.
The Red Queen Gödel Machine addresses this by co-evolving agents and their evaluators - allowing the agents to continuously improve while remaining anchored to trusted ground truth. On coding tasks, it exceeded the prior baseline while using 1.35-1.72× fewer search tokens.
🧬 Bringing self-improving agents to biology and chemistry will require domain-specific tools, models and evaluation loops. That’s the future we’re building toward with BioNeMo Agent Toolkit. In paper-review experiments, pairing NVIDIA Nemotron 3 Ultra worker agents with a frontier meta-agent approached frontier-model-only performance at roughly 13× lower search-token cost.
📰 nvda.ws/3TcC7tf
What I find most interesting about agents is how much freedom they have inside a fixed compute budget. Give an agent a goal and it can write code, search the web, and operate a computer in ways you never prescribed. The moment it became real for me was using coding agents to build a macOS transcription app in Swift, a language I had never used.
That left me wondering, which problems benefit most from giving agents this much freedom?
I think recursive self-improvement sits at the far end of this spectrum, where agents edit and optimize their own code. It works well when the task has a deterministic verifier, like software engineering and unit tests. It gets harder for open-ended tasks like writing papers or natural-language proofs, where evaluation relies on model-based judges. Agents can exploit weaknesses in those judges, creating an alignment gap between what earns a high score and what people actually value.
For the past three months, I’ve had the privilege of working on this problem with @Alex__Iacob, @itsmaddox_j, @williamfshen, @niclane7, and a team spanning @Cambridge_Uni, @NVIDIAHealth, @flwrlabs, @mbzuai, and @Inria.
We recently released the Red Queen Gödel Machine, which co-evolves agents with their evaluators. It reached a 71.7% coding pass rate versus 69.9% for the prior baseline using 1.35–1.72× fewer tokens, produced paper writers accepted 1.78–1.86× more often by a reviewer panel, and improved proof-grading accuracy from 70% to 76%.
I also led experiments with @NickVenanzi using Nemotron 3 Ultra for search-time worker agents and GPT-5.5 for the meta-agent. On paper review, this approached the GPT-5.5-only result at roughly 13× lower price-equivalent search-token cost.
Read the paper: arxiv.org/abs/2606.26294
We now have a technical blog post on the Red Queen Gödel Machine (RQGM) — a straightforward walkthrough of how the implementation actually works: the epoch loop, why we freeze the evaluator inside an epoch and how a stronger one only replaces it if it beats the incumbent 🧵
📖 mlsys.cst.cam.ac.uk/2026/07/…
📄 arxiv.org/abs/2606.26294
@itsmaddox_j @williamfshen @DBBurkhardt @meghdadkurmanji Nurbek Tastan @lorenzosani97 @NickVenanzi @AmbroiseOdonnat @cao_jamie Bill Marino @xinchiqiu @niclane7
@Cambridge_Uni @nvidia @flwrlabs @mbzuai @Inria
Excited to share that our work, LoRDO, has been accepted at ICML 2026.
It shows how foundation model training can work with much less synchronization and lower optimizer-state memory. 📄 Paper link at the end.
Paper: arxiv.org/abs/2602.04396
LoRDO: Distributed Low-Rank Optimization with Infrequent Communication
26
Really enjoyed working with @DBBurkhardt on RQGM, he brought NVIDIA's Nemotron 3 Ultra into the search for some significant cost savings and helped get this paper done. Worth reading his take too.
What I find most interesting about agents is how much freedom they have inside a fixed compute budget. Give an agent a goal and it can write code, search the web, and operate a computer in ways you never prescribed. The moment it became real for me was using coding agents to build a macOS transcription app in Swift, a language I had never used.
That left me wondering, which problems benefit most from giving agents this much freedom?
I think recursive self-improvement sits at the far end of this spectrum, where agents edit and optimize their own code. It works well when the task has a deterministic verifier, like software engineering and unit tests. It gets harder for open-ended tasks like writing papers or natural-language proofs, where evaluation relies on model-based judges. Agents can exploit weaknesses in those judges, creating an alignment gap between what earns a high score and what people actually value.
For the past three months, I’ve had the privilege of working on this problem with @Alex__Iacob, @itsmaddox_j, @williamfshen, @niclane7, and a team spanning @Cambridge_Uni, @NVIDIAHealth, @flwrlabs, @mbzuai, and @Inria.
We recently released the Red Queen Gödel Machine, which co-evolves agents with their evaluators. It reached a 71.7% coding pass rate versus 69.9% for the prior baseline using 1.35–1.72× fewer tokens, produced paper writers accepted 1.78–1.86× more often by a reviewer panel, and improved proof-grading accuracy from 70% to 76%.
I also led experiments with @NickVenanzi using Nemotron 3 Ultra for search-time worker agents and GPT-5.5 for the meta-agent. On paper review, this approached the GPT-5.5-only result at roughly 13× lower price-equivalent search-token cost.
Read the paper: arxiv.org/abs/2606.26294
Nice to see RQGM picked up by @rohanpaul_ai, all before we'd gotten round to posting about it ourselves. Happy to take questions here, answered a few in the replies already, and I get into the ideas behind it more on my profile.
New paper from Cambridge Univ+NVIDIA and other top labs teaches AI agents and AI judges to improve together, so neither side gets stuck.
Moves self-improving AI away from fixed benchmarks and toward a loop where the thing doing the judging can also get better.
The problem is that most self-improving agents train against a fixed benchmark or fixed evaluator, so the score can become stale, too easy, or easy to game.
The paper’s idea is to let the evaluator improve too, but only at safe handoff points, so each training stretch still has a stable judge.
During each stretch, agents are tested by the current frozen evaluator, while possible better evaluators are tested separately against held-out human or objective answers.
The authors try this on coding, paper writing, paper reviewing, proof writing, and proof grading, where some tasks have clear answers and others need learned judgment.
On coding, the system beats the earlier best self-improving coding agent while using 1.35× to 1.72× fewer tokens, because a cheap code reviewer adds useful feedback.
On paper writing, the co-evolved writer gets about 1.86X higher average acceptance from a reviewer panel than the fixed-evaluator baseline.
The big point is that stronger AI systems may need stronger judges growing with them, because fixed tests can stop giving useful pressure.
----
Link – arxiv. org/abs/2606.26294
Title: "The Red Queen Gödel Machine: Co-Evolving Agents and Their Evaluators"
Nice to see RQGM make the @dair_ai list. The core idea: a self-improving agent stalls the moment its evaluator stops improving, so we let the evaluator evolve alongside it. Happy to answer questions, and I discuss the paper and its ideas more on my profile.
The Top AI Papers of the Week (June 28 - July 5):
- RLMF
- AutoMem
- Paper Assistant Tool
- MCP Server Patterns
- The Verification Horizon
- Red Queen Gödel Machine
- Generative Skill Composition
Read on for more:
5
1,623
Surprised to see this take off before we'd even really shared it. We just archived it and figured no one would notice. Thanks @omarsar0 and everyone who picked it up. Answered as many questions in the comments as I could, happy to keep chatting here.
Fascinating paper on self-improving agents.
(bookmark it)
If you are working on agentic loops, you will quickly realize that they are only as good as the effectiveness of the evaluator.
Self-improvement loops tend to stall the moment the judge stops getting harder. The agent learns to satisfy a fixed evaluator rather than getting genuinely better. The Red Queen Gödel Machine, from Cambridge, co-evolves the agent and its evaluator together, so the bar keeps rising as the agent climbs.
The name borrows the evolutionary arms race. Both sides have to keep running to stay in place.
A frozen evaluator is where reward hacking creeps into self-improvement. Co-evolving the judge is a structural answer to that, and it keeps the loop honest over many rounds.
Paper: arxiv.org/abs/2606.26294
Learn to build effective AI agents in our academy: academy.dair.ai/
1
11
1,426
My co-authors @itsmaddox_j (@Cambridge_Uni) and @AmbroiseOdonnat (@Inria) will be at @icmlconf in Korea if you want to discuss the work in person.
1
7
561











