# AI’s Infinite Recursion Loop

> How AI is compressing and accelerating the cycle between software and silicon innovation.

Published: Nov 7, 2026
Canonical: https://www.mindtheory.ai/writing/ai-infinite-recursion-loop
Author: Christian Camacho


## One system, not two tracks

Draw an infinity symbol: ∞. Two loops meet at one crossing point, with no beginning and no end.

For most of computing history, hardware and software looked like parallel tracks. Chipmakers made processors faster, and programmers found ways to use the extra speed. The two influenced each other, but slowly, on cycles measured in years.

That picture no longer fits. Each generation of silicon makes a new generation of algorithms possible. Those algorithms run into the next hardware bottleneck and create demand for more specialized chips. And at the crossing point there’s something new: AI systems that write, test and optimize algorithms, including the ones used to train AI and design chips.

> **Important:** “Recursive self-improvement” usually means an AI improving its own intelligence directly, in a runaway cycle. That has not been demonstrated. Today’s systems improve other algorithms, training pipelines, infrastructure and chip layouts, with people choosing the problems, building the evaluators and deciding what ships.

> Software efficiency drives hardware demand. Hardware constraints drive software innovation. The loop doesn’t close. It speeds up.

## Phase 1: Hardware unlocks software

Modern AI started as a hardware story. Deep learning only became practical once GPUs, chips originally built for video games, offered enough parallel power to train large neural networks.

The Transformer, introduced in 2017, processes every word in a sequence at once rather than one at a time. That design pays off only on hardware built for massive parallel math. Scaling it then exposed an unexpected limit: the bottleneck often wasn’t arithmetic but memory bandwidth, how fast data moves between memory and the compute units.

Keep an eye on the pace of each half. Software can be rewritten and retested in days or weeks. A new generation of chips takes years to design, verify and manufacture. The two halves of the loop don’t turn at the same speed.

![An uneven infinity loop: a small software lobe drawn several times beside one large hardware lobe](/writing/ai-infinite-recursion-loop/loop-lopsided.svg)

*Fig. 02 — The loop is lopsided: software turns many times per hardware turn.*

## Phase 2: Software reshapes hardware

Once the bottleneck was visible, software bent around it, and hardware bent toward software.

- **Attention got cheaper.** FlashAttention (2022) reorganized the core calculation to cut slow memory traffic, running 2–4× faster with no loss of accuracy. FlashAttention-2 (ICLR 2024) roughly doubled that again.
- **Numbers got smaller.** Models tolerate far less precision than expected, pushing chips toward 8-bit and 4-bit math. BitNet b1.58 goes further, with weights of only −1, 0 or +1.
- **New architectures emerged.** State-space models like Mamba handle long inputs in linear rather than quadratic time, which changes what the ideal chip looks like.
- **Inference got smarter.** Speculative decoding (ICML 2023) lets a small model draft ahead while a large one checks the drafts in parallel: identical output, 2–3× faster in the original tests.

## Phase 3: AI starts working on the loop

Here the infinity symbol becomes literal. AlphaTensor (2022) found a way to multiply 4×4 matrices with 47 multiplications instead of Strassen’s 49, though only in modular arithmetic. FunSearch (2023) paired a language model with an automatic evaluator and found new results on the cap set problem in mathematics.

The clearest example is AlphaEvolve, announced by Google DeepMind in May 2025. It uses Gemini models in an evolutionary loop: propose code, test it, keep the best, repeat.

- **0.7%**: of Google’s worldwide compute recovered by a new Borg scheduling rule, in production for over a year (Google DeepMind · 2025)
- **23%**: speedup in a key kernel used to train Gemini, cutting total training time by about 1% (Google DeepMind · 2025)
- **32.5%**: speedup on a FlashAttention kernel implementation (Google DeepMind · 2025)

In other words, AI made the training of AI faster. Google also reports using a reinforcement-learning method, later named AlphaChip, to lay out parts of its TPU chips. That claim is contested: independent researchers dispute how it compares with commercial design tools, and *Nature* published an addendum to the original paper in 2024.

## How fast is the loop spinning?

![A widening spiral alternating software and hardware halves, beside squares showing two 2x gains making 4x](/writing/ai-infinite-recursion-loop/loop-compounding.svg)

*Fig. 03 — Each turn feeds the next. Gains on both sides multiply.*

Compute has grown enormously. GPT-3 (2020) was trained with roughly 3×10²³ operations. Epoch AI estimates GPT-4 (2023) used around 2×10²⁵, about 70 times more in three years. Algorithms have kept pace too: Epoch’s research suggests the compute needed for a given level of language-model performance has been halving roughly every eight months.

Ordinary exponential growth has a fixed doubling time: capability doubles every so many months. The loop changes that. When AI shortens the time each turn takes, the doubling time itself shrinks, so the curve climbs faster than exponential and the slope of innovation keeps getting steeper. That is the optimistic case. If friction wins, the curve levels off into an S instead.

![Capability over time: the loop-accelerated curve climbs faster than ordinary exponential growth, while a dotted S-curve levels off if friction wins](/writing/ai-infinite-recursion-loop/loop-growth.svg)

*Fig. 04 — The loop bends the curve. Illustrative shapes, not forecasts.*

That’s the lopsidedness from Fig. 02. The software half now turns in days or weeks. The hardware half still takes years, gated by chip design, verification and fabs. Claims that the whole cycle turns in “days” confuse the two halves.

## Friction in the loop

No feedback loop runs without resistance. Every turn has to pass through real-world limits: the electricity that powers the chips, the few factories that can make them, the physics of the transistors themselves, the data models learn from, and the slow work of checking that results actually hold up. Each of these drags on the loop. Together they decide whether it keeps accelerating or levels off.

![The infinity loop with friction points for energy, fabs, physics, data and verification, and a note on the Jevons paradox](/writing/ai-infinite-recursion-loop/loop-friction.svg)

*Fig. 05 — Where the loop meets friction.*

Energy is the biggest brake. The International Energy Agency estimates data centers used about 415 terawatt-hours of electricity in 2024, around 1.5% of the world’s total, and projects that could more than double to about 945 TWh by 2030.

![Bar chart: data centers used 415 terawatt-hours in 2024; the IEA projects 945 terawatt-hours by 2030](/writing/ai-infinite-recursion-loop/fig-energy.svg)

*Fig. 06 — Data center electricity, 2024 vs. 2030 projection. Source: IEA, Energy and AI (2025).*

Cheaper computing also tends to mean more total computing, not less, which is the Jevons paradox in action. Add physical limits on transistors, a handful of advanced fabs, finite high-quality training data, and headline results that still need independent replication.

## The loop might stall

Many exponential-looking trends turned out to be S-curves. If systems like AlphaEvolve only work on narrow problems with clear, automatic scoring, the loop will keep turning, just more slowly than the boldest accounts suggest.

## Riding the loop

An infinity loop has no edge to fall off. But it has a center that everything passes through, and that’s where the steering happens. The question isn’t whether the loop speeds up. It’s who guides it, what it’s pointed at, and whether we understand it well enough to notice when it drifts.

## Sources

1. Fawzi et al., Nature 610 (2022). AlphaTensor.
1. Romera-Paredes et al., Nature 625, 468–475 (2024). FunSearch.
1. Google DeepMind, AlphaEvolve (May 2025).
1. Mirhoseini et al., Nature 594 (2021), and Addendum (2024).
1. Dao, FlashAttention-2, ICLR 2024.
1. Leviathan et al., ICML 2023. Speculative decoding.
1. Epoch AI, training compute and algorithmic progress.
1. IEA, Energy and AI (2025).
