On May 14, 2025, Google DeepMind introduced AlphaEvolve, an evolutionary coding agent built on Gemini models that writes, tests, and rewrites algorithms in a loop — then feeds the improved versions back into its own search process. Among its results: a new way to multiply two 4x4 complex-valued matrices using 48 scalar multiplications, edging out the 49-multiplication bound set by Strassen's algorithm in 1969, plus optimizations DeepMind rolled directly into its own data-center scheduling and parts of the Gemini training pipeline.

A few weeks later, Sakana AI and academic collaborators published the Darwin Gödel Machine — a coding agent that literally rewrites its own source code, benchmarks each new version against coding tasks, and keeps every variant in an archive it can branch from later instead of discarding anything that didn't immediately win. Named after Jürgen Schmidhuber's 2003 theoretical “Gödel Machine,” it's the closest thing yet to a working system that improves its own ability to improve itself. According to Speka, that combination — systems that measurably get better at making themselves better — is what reopens the decades-old question of whether recursive self-improvement is a genuine path to AGI, rather than a thought experiment.

The idea itself predates deep learning by half a century: mathematician I.J. Good described an “intelligence explosion” back in 1965, where a machine smart enough to improve its own design would trigger a runaway feedback loop. What changed in 2025 is that labs now have systems running a narrow version of this loop in production, not on a whiteboard — which is exactly why frontier labs treat the concept as a safety threshold, not just a research curiosity.

What recursive self-improvement actually means

Recursive self-improvement (RSI) describes a system modifying its own weights, code, or training process in ways that make it better at further modifying itself — a compounding loop, not a one-off upgrade. It's worth separating two things people lump together under the term:

• Narrow RSI: an agent gets better at a bounded task — faster matrix-multiplication code, a self-patching bug-fixing pipeline — inside a fixed, human-defined evaluation harness.
• General RSI: an agent improves its own general reasoning and learning ability across arbitrary domains, with no human-designed scorer telling it what “better” means.

Everything shipped so far — AlphaEvolve, the Darwin Gödel Machine, and earlier work like Self-Taught Optimizer — falls into the first category. It compounds, but it's bounded by a fitness function a human wrote and a benchmark a human picked.

Why labs treat it as a threshold, not a feature

None of this looks like AGI arriving through the back door yet, but it's close enough that safety teams have stopped calling it speculative. Google DeepMind's Frontier Safety Framework tracks “ML R&D uplift” as a monitored capability — how much a system accelerates AI research itself. Anthropic's Responsible Scaling Policy and OpenAI's Preparedness Framework both flag autonomous self-improvement and AI-driven AI R&D as categories that trigger stricter deployment safeguards once a model crosses certain capability tests. The shared logic: a model that meaningfully speeds up the next model's development is a different kind of risk than one that just answers questions well, because the loop starts compounding faster than humans can review each step.

The practical catch for builders

For teams building agents today, the lesson isn't “AGI is near” — it's that verifier-bound self-improvement is already a usable pattern, with constraints worth copying directly:

• Every working system depends on a cheap, reliable evaluator — unit tests, benchmark scores, a fitness function — not a human vibe-check on every iteration.
• Keeping an archive of past variants, as the Darwin Gödel Machine does, beats greedy “always take the best version” search, since early dead ends sometimes unlock later breakthroughs.
• None of these systems self-improve unsupervised in the wild — they run inside sandboxed, resource-capped loops with a hard stopping condition, which is the actual safety property doing the work right now.

That's a template any team can borrow for coding agents or optimization pipelines, well before it says anything about AGI.

AiiN's takeaway

Recursive self-improvement went from theory to shipped product in about a year, and that's the real news — not a countdown to AGI. AlphaEvolve and the Darwin Gödel Machine prove AI systems can meaningfully improve their own code, and in AlphaEvolve's case, pieces of the infrastructure that trains the next model. What none of them have shown is a system improving its own general reasoning without a human-authored scorer standing between each generation — and that gap is what separates a useful engineering pattern from an intelligence explosion. In our estimation, the more interesting near-term story for builders isn't whether this leads to AGI, but how fast verifier-bound self-improvement loops get adopted as a standard tool for optimization work that used to need a human engineer in the loop at every step.