Recursive self-improvement already happens. It is not a threshold the field will cross on some future Tuesday; it is a present, dull, load-bearing part of how frontier models get built. Models generate the synthetic data that trains their successors, write the infrastructure code that runs the training, propose and grade the evaluations that decide what "better" even means, and hunt for faster kernels underneath all of it. Those are feedback loops in which the output of one AI makes the next AI better. They are also nothing like the intelligence explosion the phrase "recursive self-improvement" is meant to summon — and the gap between the mundane thing that is real and the sci-fi thing that is imagined is the most useful place to stand if you want to reason clearly about where this goes.
The discourse conflates the two, and the conflation is the whole error. When someone says AI is starting to improve AI, one camp hears "the Good-Bostrom takeoff is beginning" and reaches for the alarm, and the other camp hears the same alarm, finds it silly, and dismisses the underlying observation along with it. Both are wrong in the same way. There is a real loop, it is compounding, and it is worth watching closely. It is also weak, bounded, and gated by the same things that gate everything else. Holding both facts at once is not fence-sitting. It is the only accurate reading.
The loop, catalogued honestly
Start with what is actually happening, because the demos matter less than the plumbing. "AI improving AI" today is not one dramatic capability. It is a handful of unglamorous places where model outputs feed back into building the next model.
Synthetic data, generated and filtered. Models produce training examples for their successors — instruction-following data in the style of Self-Instruct, preference labels in the style of RLAIF and Constitutional AI, distilled traces from a stronger teacher into a smaller student. This is genuinely a case of a model shaping what the next model learns.
Code that builds models. The people writing training loops, data pipelines, and eval harnesses now write them with model assistance — drafting, refactoring, debugging the infrastructure that produces the next system. The tool that helps build the artifact is itself a version of the artifact.
Systems and kernel optimization. DeepMind's AlphaTensor found faster matrix-multiplication algorithms; AlphaDev found faster sorting routines that were merged into a standard library. Both run underneath model training. An AI that discovers a cheaper primitive makes every future training run cheaper.
Evals, generated and graded. LLM-as-judge is now standard for scoring open-ended outputs, and models help author the eval sets themselves. The system that decides whether the next model is better is partly the current model.
Design assistance. Models help write and refine prompts, sketch architecture variants, and shape data-curation policies — the diffuse judgment work around a training run.
Every item is real. Together they form a loop: better models make the tooling that makes better models. Call it what it is. This is recursive improvement. The question is what kind.
Why it is weak recursion, mechanically
The self-hosting compiler is the honest analogy, and it is worth sitting with because it is a real, decades-old case of a system improving itself. A compiler written in its own language compiles itself; you use it to build a better compiler, which compiles itself again. Genuine recursion, genuine improvement — and it does not explode. It bottoms out. You get a good compiler, not an unbounded ascent of compiler quality, because each turn of the crank yields a smaller gain and the hard constraints (the target hardware, the language semantics, what "correct code" means) do not move just because your tool got sharper.
The current AI loop has the same shape, for three concrete reasons.
It is human-in-the-loop. A person holds the objective and approves each step. Nobody deployed today lets a model set its own training target, rewrite its own weights toward that target, and ship the result unreviewed. The loop improves the tools; it does not hand over the steering.
It is bounded per step. Each contribution is an increment a human then integrates and checks — a filtered dataset, a merged pull request, a faster kernel, a passing eval. The increment is real and the cost of realizing it is real, and the second does not vanish because the first exists.
It is gated by the same constraints as everything else: compute, data, real-world feedback, and above all verification. An AI-proposed improvement is a candidate. It becomes an improvement only after something confirms it is one, and confirmation is not free.
That third gate is where the explosion story quietly dies, so it is worth doing the arithmetic.
The arithmetic of explosion versus damping
I.J. Good's 1965 argument — from "Speculations Concerning the First Ultraintelligent Machine" — is the origin of the intelligence-explosion idea: a machine good enough to design better machines sets off a chain in which "the intelligence of man would be left far behind." Bostrom later formalized the dynamics in terms of optimization power pushing against recalcitrance — how hard the next increment is to get. Fast takeoff is the regime where recalcitrance stays low or falls even as optimization power climbs, so the system accelerates. That is a specific quantitative claim, and it is testable in principle against the loop we actually have.
Let the gain per generation be the fractional improvement in AI's ability to improve AI: rn = Cn+1/Cn − 1, where Cn is that capability at step n. An explosion in Good's sense requires rn to stay bounded away from zero — each generation buys at least a proportional ability to produce the next one — and a hard takeoff requires rn to rise. That is the whole ballgame. If instead rn decays — because each successive improvement is harder to find and more expensive to verify — the cumulative gain is a convergent series. It can be large. It is still finite, and it self-damps.
Which regime are we in? Look at the cost side, which the explosion story routinely omits. Each increment demands compute (rising per frontier generation), data (the cheap public reserves are largely spent), and verification (getting more expensive, because you are now checking harder claims against a world that does not get faster). When the marginal cost of the (n+1)th real improvement grows while the marginal gain shrinks, rn → 0 by construction. That is not a rebuttal of Good; it is the empirical question Good's argument turns on, and the current evidence points at the damped branch. This arithmetic is illustrative, not measured — but it tells you exactly what to measure: the trajectory of gain per step and the cost of realizing it. Watch those two numbers and you can tell which story you are in without arguing about it.
Verification is the cap
Here is the mechanism that forces the damping, and it is the same one that limits every ambitious claim about autonomy. Every AI-generated improvement has to be verified to count, and verification, not generation, is the bottleneck. Generation is cheap and getting cheaper; adjudication against reality is expensive and stubbornly so. I have argued elsewhere that verification, not generation, is the constraint the whole stack now runs into, and the self-improvement loop is the sharpest case of it.
Walk the catalogue back through this filter. Synthetic data helps only if it is filtered against something the model does not already contain; feed a model its own unfiltered output and you get the model-collapse degradation Shumailov and colleagues documented, not compounding gains. AI-written training code helps only after it passes tests and review — and a subtle bug in a loss function can silently poison a run in ways no unit test catches. AI-graded evals help only insofar as the grader tracks reality rather than a shared blind spot between the model being judged and the model judging it. In every case the loop closes not at generation but at the verification step, and that step imports a cost the generation step does not have.
AlphaTensor and AlphaDev are the exception that proves the rule. They worked precisely because their domains have a cheap, exact verifier: an algorithm is provably correct or it is not, checkable at near-zero cost. Where verification is free, weak recursion runs fast and produces real results. That is the whole reason those two projects succeeded and "have a model autonomously judge which research direction is good" has not — because "is this a good idea" has no cheap oracle. The verification requirement is the thing that separates the loops that compound from the loops that drift, and I have made the fuller case for why self-improvement is capped by the ability to self-verify — an unverified improvement is not an improvement, it is a guess with good production values.
Why the caps do not obviously dissolve
The strongest counterargument deserves its best form. A fast-takeoff proponent will say: every bottleneck you listed is itself a task, and tasks are what AI automates. AI can verify AI — proof checkers and test suites already do. AI can get real-world feedback through self-driving labs, the autonomous robotic chemistry systems that already run design-make-test cycles with minimal human touch. AI can design its own compute; learned methods already assist chip floorplanning. World-model research — LeCun's JEPA program, model-based RL — is an explicit bet on giving models a learned simulator of reality so they can get feedback without paying reality's price every time. Grant all of that, the argument goes, and the caps are temporary scaffolding, not permanent walls.
Take it seriously, because parts of it are correct, and then notice what it does not get you. Verification that reduces to another model's judgment has not escaped the loop; it has relocated the unverified assumption to a place that is harder to see. Verification that reduces to reality — the wet-lab assay, the fab run, the deployment cohort — inherits reality's clock rate, and you cannot prompt a cell culture to divide faster or a fab to cycle in an afternoon. World models compress some of that cost, which is exactly why they are the interesting bet, but they run straight into the sim-to-real gap: a learned simulator is only as trustworthy as its agreement with the world it approximates, and confirming that agreement is, once again, a verification problem you have to pay for outside the model. Automating the verifier moves the bottleneck. It does not delete it, because the loop still has to close through a world that answers on its own schedule.
There is a second thing the current loop does not even touch. Good's explosion and Bostrom's takeoff are about an agent that modifies itself toward a goal — which surfaces the goal-stability-under-self-modification problem that Omohundro and Bostrom analyzed: a system rewriting its own weights has no guarantee of preserving the objective it started with, and no deployed system today attempts this. What ships is a loop that improves the tools while a human holds the goal. Conflating "the tools are getting better at making tools" with "an agent is rewriting itself toward superintelligence" is precisely the move that turns a mundane, trackable engineering reality into a story you can neither confirm nor act on.
What to watch, and what to discount
The reframe is simple and it cuts both ways. Do not dismiss the loop — it is real, it compounds, and it is one of the more important dynamics in the field. Do not inflate it — nothing in it is the intelligence explosion, and treating it as an early symptom of takeoff will make you both wrong and unfalsifiable. The explosion is a specific hypothesis with specific conditions: gain per step that stays bounded away from zero, verification cost that falls rather than rises, and a loop that closes without waiting on the physical world. Discount it until those conditions are met, and hold the discount lightly, because they are empirical, not impossible.
Concretely, watch three dials. Is the gain per generation holding or decaying? Is the cost of verification falling or rising as the claims get harder? And is any part of the loop starting to close without a human integrating and checking the step — the actual signature of strong recursion. Those are measurable. The intelligence-explosion narrative floats above all three, which is exactly why it is less informative than the boring loop underneath it.
This is the same lesson that governs why an "automated scientist" is a category error: generation was never the bottleneck, and a loop that gets faster at generating candidates gets you nowhere if the thing gating output is the disciplined, expensive act of checking candidates against a reality that can say no. AI improving AI is real. It is weak recursion. Weak recursion compounds slowly and honestly, and it will keep doing so right up until someone shows me the gain per step rising and the verification cost falling — at which point I will change my mind, and not one sentence sooner.