⏱️ Lectura: 10 min
In 1965, British mathematician I.J. Good wrote that a machine capable of designing machines better than itself would unleash an unstoppable “intelligence explosion.” Sixty years later, an analysis published by MIT Technology Review on August 18, 2026 concludes that this explosion still hasn’t arrived.
📑 En este artículo
The report examines why recursive self-improvement (RSI), the idea that an AI system trains its own successor without human intervention, is advancing much more slowly than those betting on a fast takeoff toward superintelligence anticipated.
TL;DR
- On August 18, 2026, MIT Technology Review published an analysis questioning the speed of recursive self-improvement in AI systems.
- The idea of an “intelligence explosion” comes from a 1965 text by mathematician I.J. Good.
- Current systems like Sakana AI’s Darwin Gödel Machine already edit their own code, but in a limited and supervised way.
- The bottlenecks identified include rising compute costs, a scarcity of new high-quality data, and the lack of objective external evaluation.
- AutoML-Zero (Google, 2020) demonstrated that searching for architectures from scratch works, but at a computational cost that scales with the search space.
- The core technical risk is overfitting to self-generated benchmarks when the same system both generates and evaluates its own improvements.
- The debate splits the AI community between those who see a performance plateau and those who argue the fast takeoff has merely been delayed.
What happened
The MIT Technology Review article, published on August 18, 2026, raises a direct question: if AI labs have spent years promising systems capable of improving themselves without human help, why hasn’t recursive self-improvement yet translated into the exponential takeoff that singularity theorists predicted?
The piece places the debate in 2026. This is the year several labs, including those funded by the US Genesis Mission initiative’s $5 billion for AI applied to science, are betting that AI itself will accelerate its own future research. The National Science Foundation is also building compute infrastructure specifically for AI research, as Government Executive reported the same month. The analysis’s central argument is different: recursive self-improvement in the strict sense, a system that trains, evaluates, and deploys its successor without human intervention, still isn’t observed at the scale that fast-takeoff theory predicted.
Background and history
From 1965 to the singularity
The concept isn’t new. I.J. Good, a cryptographer who worked alongside Alan Turing at Bletchley Park, wrote in 1965 that an “ultraintelligent machine” could design even better machines, triggering an intelligence explosion that would outpace any human capacity for control. In 1993, mathematician and writer Vernor Vinge popularized the idea under the name “technological singularity.” Nick Bostrom revisited the debate in his book Superintelligence, distinguishing between a “fast takeoff” (a matter of days or months) and a “slow takeoff” (a matter of years or decades).
The question the 2026 analysis raises is where along that spectrum today’s technology actually sits. Recursive self-improvement, in its purest form, requires a system not only to generate candidate improvements but also to evaluate and adopt them without a human reviewing the outcome.
Real attempts, generation by generation
Several projects already explore limited versions of this idea. AutoML-Zero, published by Google researchers in 2020, showed that an evolutionary search system can discover competitive machine learning algorithms from scratch, without starting from human-designed architectures. AlphaZero and its successors demonstrated that self-play lets a system surpass human level in perfect-information games without seeing a single game played by humans. More recently, Sakana AI introduced the Darwin Gödel Machine, an agent that rewrites its own source code to improve its performance on programming tasks, evaluating each version against a set of benchmarks before adopting it.
Technical details and performance of recursive self-improvement
Technically, a recursive self-improvement cycle needs three pieces: a variant generator, an evaluator, and a selection mechanism. The generator proposes changes to the model, the code, or the architecture. The evaluator measures whether the variant is better. The selection mechanism decides whether that variant replaces the previous version. The diagram below summarizes this cycle:
flowchart TD
A["Base model"] --> B["Generates a candidate improvement"]
B --> C["Evaluates the improvement on a fixed benchmark"]
C --> D{"Does the score improve?"}
D -->|"Yes"| E["Adopts the new version"]
D -->|"No"| F["Discards it and adjusts the search"]
E --> A
F --> BThe following table compares the approaches used today as partial approximations of recursive self-improvement, each with a different practical limitation:
| Approach | What it improves | Known example | Practical limitation |
|---|---|---|---|
| Architecture search (AutoML/NAS) | The model’s architecture | AutoML-Zero (Google, 2020) | Compute cost grows with the size of the search space |
| Self-play | The decision policy | AlphaZero and its successors | Works well only in environments with a clear reward signal |
| Self-editing code | The agent’s own code | Darwin Gödel Machine (Sakana AI) | Risk of overfitting to its own evaluation benchmarks |
| Generational distillation | The successor model’s weights | Teacher-student schemes | Student quality is bounded by the teacher’s signal |
⚠️ Heads up: when the same system that proposes an improvement also decides whether that improvement is good, the result tends to overfit to its own criteria rather than actually improve in the real world. That’s why any serious recursive self-improvement system needs a fixed external benchmark that the generator can never modify.
A simplified cycle, with no real AI component, helps illustrate the underlying mechanics. The following example simulates a “hill climbing” search that keeps the best variant found:
def generar_variante(programa):
return programa + ' # generated variant'
def evaluar(programa, benchmark):
return benchmark(programa)
mejor_programa = programa_inicial
mejor_puntaje = evaluar(mejor_programa, benchmark_tareas)
for iteracion in range(20):
candidato = generar_variante(mejor_programa)
puntaje = evaluar(candidato, benchmark_tareas)
if puntaje > mejor_puntaje:
mejor_programa, mejor_puntaje = candidato, puntaje
print('Best score after 20 iterations:', mejor_puntaje)This loop only keeps a variant if it beats the previous one on the same benchmark. With 20 iterations and a simple benchmark, the final score should be equal to or higher than the initial one. If nothing improves, it’s a sign that the variant generator isn’t exploring useful changes: the same underlying problem the MIT Technology Review analysis describes at a larger scale.
How to try it
To experiment with a self-improvement cycle applied to real code, the simplest pattern is to combine a test suite with calls to a language model that proposes fixes when tests fail:
import subprocess
def pedir_mejora_al_modelo(codigo_actual, resultados_tests):
contexto = 'Current code and failing tests:'
prompt = contexto + ' ' + codigo_actual + ' ' + resultados_tests + ' Propose a corrected version that passes the tests.'
return llamar_llm(prompt)
def correr_tests():
resultado = subprocess.run(['pytest', '-q'], capture_output=True, text=True)
return resultado.returncode == 0, resultado.stdout
codigo = leer_archivo('agente.py')
for ronda in range(5):
ok, salida = correr_tests()
if ok:
break
codigo = pedir_mejora_al_modelo(codigo, salida)
escribir_archivo('agente.py', codigo)The llamar_llm function represents any language model API client. The key point isn’t which provider is used, but that correr_tests() always runs against the same fixed suite, without the model being able to edit it. That’s what prevents the generator from cheating by also rewriting the evaluation criteria.
To verify whether a round actually improved performance, not just the score the model itself reports, it’s worth saving the result against a separate (“held out”) test set that’s never shown to the generating model, and comparing both scores with a simple command, for example python benchmark.py --version v3 --set held_out. If the score on the reserved set doesn’t rise at the same rate as the training score, there’s overfitting.
Impact and analysis
If recursive self-improvement is advancing more slowly than expected, the consequences aren’t purely academic. Much of the AI capex announced in 2026 assumes that AI itself will accelerate its own research. That includes programs like the United States’ Genesis Mission and the NSF’s infrastructure buildout. If that compounding effect takes longer to arrive, the timelines behind those bets should also be adjusted.
💭 Key point: there’s an important difference between “AI makes human researchers more productive” (which is already happening, with agent-assisted coding tools) and “AI trains its successor with no humans in the loop” (the strict definition of recursive self-improvement). The first is real today; the second remains, for the most part, a projection.
The analysis also touches on a sensitive point: the difficulty of measuring progress when the very system being evaluated helps design its own metric. It’s the same underlying problem that separately motivated a different piece of academic work. In August 2026, Seoul National University of Science and Technology presented a framework for testing the robustness of computer vision systems against variations the model itself didn’t generate.
What’s next
The report itself leaves the door open for recursive self-improvement to eventually arrive, but via a more gradual path: compounding improvements, where a slightly better model trains the next generation with slightly better data, rather than a discontinuous leap. Meanwhile, interest is growing in research focused on human-AI collaboration rather than full replacement. A Carnegie Mellon University team published a study in August 2026 that frames humans and AI as “teammates” in research tasks, an approach that doesn’t depend on the system improving itself alone.
In the short term, the debate will most likely be settled by more empirical papers that directly measure how much a system improves when trained by its predecessor without human intervention, rather than by theoretical extrapolations of scaling curves.
📖 Summary on Telegram: View summary
Try it yourself: clone a small project with an automated test suite, build a five-round loop like the one in the example above, and compare the score against a reserved test set that you never show to the generating model.
Frequently Asked Questions
What is recursive self-improvement?
It’s the idea that an artificial intelligence system can design, train, and deploy an improved version of itself without human intervention in that cycle, generation after generation.
Where does the idea of an “intelligence explosion” come from?
Mathematician I.J. Good proposed it in 1965: an “ultraintelligent” machine could design even better machines, in a chain that would accelerate on its own.
What did the MIT Technology Review analysis find?
That recursive self-improvement, in its strict form, is advancing much more slowly than fast-takeoff advocates predicted, due to concrete technical bottlenecks like compute costs and the lack of objective external evaluation.
Are there systems that already self-improve today?
There are partial, supervised approximations, like AutoML-Zero, AlphaZero, and Sakana AI’s Darwin Gödel Machine, but none operate without some kind of benchmark or supervision set by humans.
What’s the main technical risk of these systems?
That the same system generating an improvement also evaluates it, which favors overfitting to its own criteria rather than a real, generalizable improvement.
Does this mean superintelligence isn’t coming?
Not necessarily. The analysis suggests the path would be more gradual and compounding, with incremental improvements between generations, rather than the exponential, discontinuous takeoff the original theory proposed.
References
- MIT Technology Review: the original analysis on why AI’s recursive self-improvement is advancing slower than expected.
- Wikipedia: definition and historical background of the concept of recursive self-improvement.
- Wikipedia: origin of the intelligence explosion concept from I.J. Good’s 1965 text.
- Sakana AI: the lab behind the Darwin Gödel Machine, an agent that edits its own source code.
📱 Like this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.
0 Comments