Scroll to the bottom of OpenAI's GPT-5.6 release notes, past the coding scores and the customer testimonials, and there is a small table headed "Self-improvement." Four benchmarks, then a fifth line: RSI Index. The new flagship model scores 57.9. The model it replaced scored 41.7.
RSI stands for recursive self-improvement. It is the old thought experiment about a machine that builds a better machine, which builds a better machine, and so on until the humans are spectators. For sixty years it lived in philosophy seminars, Singularity Summits, and safety debates, a hypothetical that serious people used carefully and unserious people used to sell newsletters. As of July 2026 it has a number, a delta, and a slot in a product launch, filed between the cybersecurity results and the multimodal ones.
Companies benchmark what they intend to optimize. That is what a benchmark is for. You do not build a scoreboard for something you plan to leave alone.
What struck me was that nobody made anything of it. The launch coverage went to the price cuts and the coding scores. The row that says the lab is now measuring, on a schedule, how well its model improves the next one went by without comment.
The objection, first
Here is the strongest case against everything I am about to argue, and it deserves to go before the evidence rather than after it.
What the labs are describing is engineering optimization, not intelligence bootstrapping. Making a model cheaper to serve is not the same as making it smarter. A compiler that speeds up compilers is not an intelligence explosion; it is a good release. The specific work in question, rewriting the low-level code that runs on graphics chips and tuning how requests get distributed across a cluster, is exactly the sort of narrow, well-specified, richly-instrumented problem that these systems have been good at for a while. It is the easy part.
Worse, every number in this argument comes from a company whose valuation depends on you believing it. OpenAI defines and scores its own RSI Index; no outside party audits it. Anthropic's internal figures are self-reported, and the productivity claims rest partly on a survey of its own researchers. Anthropic itself flags, in a footnote, METR research showing that developers systematically overestimate how much AI speeds them up. When the marketing department and the safety department both benefit from the same claim, apply pressure to the claim.
That objection is correct on the facts and wrong about what they mean. Here is why.
What the model did
Three weeks after the GPT-5.6 launch, OpenAI published an engineering post explaining how they got the model that cheap to run. Read it as an operations document and it is a competent writeup of load balancing and caching. Read it for who did the work and it is something else.
Kernels are the small programs that execute the actual math on a graphics chip, the innermost layer where a matrix multiply becomes electricity. They are hand-tuned by a small number of specialists and they are where a large share of serving cost hides. According to the post, the model rewrote and optimized OpenAI's production kernels autonomously, in two open-source GPU languages that OpenAI maintains. Combined with related work, that cut end-to-end serving costs by 20 percent.
Then there is speculative decoding. A large model generating text is slow because it produces one token at a time, each one waiting on the last. The trick is to run a small, fast "draft" model alongside it that guesses the next several tokens, which the big model then checks in a single pass. When the guesses are good, you get several tokens for the price of one.
The flagship model designed and ran hundreds of experiments on the architecture of its own draft model, testing changes to size, structure, and features. It launched the training runs for that draft model and monitored them, stepping in on its own when hardware failed or training went unstable. Token-generation efficiency improved by more than 15 percent.
Sit with the shape of that. A model wrote the code that runs the model. Then it designed and trained the smaller model that makes it think faster. Then it babysat that training and fixed the failures itself. Every one of those artifacts now sits in production, underneath the next model.
That is a closed loop, running in production, with a measured gain.
Everyone is watching the wrong variable
The loop closed here first, in serving cost rather than raw capability, because a loop always closes first wherever the constraint is tightest. Right now the constraint is electricity.
For two years the scarce input in AI was chips. That is over. Packaging capacity at the fabs has been expanded repeatedly and accelerator supply has loosened. The scarce input now is electricity, and more precisely the permitted, energized connection between a building full of accelerators and a power plant that can feed them. Roughly 2,300 gigawatts of generation and storage sit in United States interconnection queues, more than the country's entire installed base, with waits in the markets carrying most of the buildout running four to seven years. Gartner projects that 40 percent of AI data centers will be power-constrained by 2027. You can double chip output in eighteen months. You cannot conjure a substation.
Nvidia's Jensen Huang framed the economics at this year's GTC as a formula worth memorizing: revenue equals tokens per watt times available gigawatts. If gigawatts are fixed by a queue you do not control, then tokens per watt is the only term you can move. And tokens per watt is software. It is kernels, routing, cache hit rates, batching, context discipline, speculation. It is precisely the category of work these models are strongest at, and it is the category with the shortest feedback loop, because you can measure the result in production the same afternoon.
So the first place a self-improving system bites is efficiency. And efficiency is not a consolation prize. Under a hard power ceiling, a 20 percent cut in serving cost is a 20 percent increase in effective compute, which is the input to everything else: more experiments per week, more agents running in parallel, more of the model available to work on the next model. Cost decline converts directly into capability at a fixed wattage.
Anyone who has watched a speedrun understands the dynamic. Players do not develop faster reflexes. They find a shortcut, and every run afterward starts from the improved route, which frees attention to find the next shortcut. The route compounds even when the player does not. The labs have handed route-finding to the thing running the route. Hold onto that image, because further down it stops being a figure of speech.
Three labs, the same shape
One company's release notes would be easy to write off as positioning. Google has been running the quiet version of this for more than a year.
AlphaEvolve is a Gemini-powered agent that writes candidate programs, scores them against a metric, and breeds the winners. DeepMind reports that a scheduling rule it discovered has been running in production across Google's data centers for over a year, continuously recovering an average of 0.7 percent of the company's worldwide compute. It proposed a rewrite in Verilog, the language chip designers work in, that stripped unnecessary bits out of an arithmetic circuit; that change was integrated into an upcoming version of Google's own AI accelerator. And it found a better way to break up a large matrix multiplication inside Gemini, speeding that operation up 23 percent and cutting Gemini's total training time by 1 percent.
Look at the layers. Scheduling, silicon, and the training run. The system improved the data center, the chip, and the model.
Then do the arithmetic honestly, because the number invites overexcitement. A 1 percent reduction in training time, compounded, needs roughly seventy turns to double training speed, and memory bandwidth and interconnect latency impose ceilings that a faster matrix multiply cannot lift. DeepMind has also never published the denominator, meaning how many optimization attempts produced nothing at all. What Google demonstrates is that the loop exists across three different substrates. It does not yet demonstrate that the loop is fast.
The three rungs, with slopes
Efficiency is the visible half. The other half is what happens inside the labs, and Anthropic published unusually specific numbers on it in June in a piece called When AI builds itself. Take the data on its own terms first, and the judgment about the data after.
The first rung is writing code. As of May 2026, more than 80 percent of the code merged into Anthropic's production codebase was authored by Claude. Before their coding agent launched in early 2025 that number was in the low single digits. Output per person moved with it: a typical engineer merged eight times as much code per day in the second quarter of 2026 as in 2024. Lines of code is a poor measure of anything, and Anthropic says so in the same paragraph, which is to their credit. The direction is not in dispute.
The second rung is running experiments. Every model release, Anthropic runs the same test: hand the model code that trains a small AI model and ask it to make that code run as fast as possible while still passing the correctness checks. In May 2025 the best model averaged about a 3x speedup. By April 2026 it was averaging about 52x. A skilled human researcher gets roughly 4x, and needs four to eight hours to do it. Anthropic cautions against anchoring on the absolute multiple, since it depends on how sloppy the starting code was, and that caution is fair. The informative part is the same test, same starting point, twelve months apart, against the same human baseline.
The third rung is the one that supposedly saves us. The standard argument for why none of this compounds is that models execute; humans decide. Research taste, problem selection, knowing which result to trust and when an approach is dead. That was a categorical claim, and categorical claims are comfortable because they cannot be dented by a percentage point.
It now has a percentage point. Anthropic went through real research sessions where a human researcher took a wrong turn, showed models only the work up to that moment, and asked what they would do next. A separate judge, able to see how the session eventually resolved, scored whether the model's suggestion beat the human's. In November 2025 the best model won 51 percent of the time. By April 2026 it won 64 percent.
The honest caveats matter and they cut both ways. Those moments were selected because the human's choice had room to improve, so this is not a fair fight. On a control set where the human's next move was already strong, the models won only about 20 percent. Fine. What did not happen is the thing skeptics needed to happen: the number did not sit still.
That is the real event of the past year. The last human-only stage of the AI development loop stopped being a category and became a rate. Once an objection has a slope, the argument is over and only the timeline is left.
What an explosion feels like from the inside
Nothing about this feels explosive to the people inside it, which is why so few of them sound alarmed. It feels like a backlog.
Push more code through an organization and human review becomes the constraint. Anthropic says this happened to them. Generate more ideas than the company can staff and idea supply becomes worthless while prioritization becomes precious. That happened too. This is Amdahl's law, the old computing principle that speeding up one stage of a process only moves the bottleneck to whichever stage you did not speed up. It applies to organizations as neatly as to processors.
The effect is visible from outside as well. GitHub, the platform most of the world's software lives on, handled roughly a billion code commits across all of 2025. By mid-2026 it was seeing 275 million a week, on pace for around 14 billion for the year (that’s 14x YoY!). That is an infrastructure provider being run over by a curve, and its own operating chief has said publicly that keeping up is a strain.
Meanwhile the adoption numbers inside the labs look like a step function. OpenAI reports that over six months the share of its research compute devoted to internal coding inference grew one hundred-fold, and internal agentic token usage rose roughly twenty-two-fold. The models are being handed the work at scale, by the people best positioned to judge whether they are any good at it.
Where I could be wrong
My house rule is to put confidence levels on empirical claims, so here they are.
High confidence: a genuine feedback loop is running, it is measurable, and it is currently strongest in inference efficiency and code production. This is documented in production systems at two labs, with numbers attached.
Moderate confidence: the loop's gain is rising rather than flat, and the human-judgment stage will keep eroding on roughly the trend of the last eighteen months. The evidence is real but thin, self-reported, and drawn from adversarially selected samples.
Low confidence: any specific timeline for the strong version, where a system designs, trains, and validates its successor with humans reduced to oversight. The people closest to it say they cannot see the shape of that transition, and I believe them.
Unknown: whether any of this is yet economically competitive on problems that resemble real research. Ten days ago METR, an independent evaluation nonprofit, published the cleanest test of that question I have seen, and it is the strongest evidence against this essay.
They used the NanoGPT speedrun, a public competition to minimize the wall-clock time needed to train a small language model to a fixed accuracy target. The speedrun metaphor from earlier is, at this point, the literal experiment. METR first estimated what human progress costs there by interviewing top contributors: roughly sixteen hours of labor, call it $2,500, per 1 percent speedup. Then they ran six agents against the same problem, spending up to $10,000 each, and measured the budget at which each agent's returns fall below the human line. They call that crossing point the expenditure horizon. It landed between $0 and $3,300.
GPT-5 and Opus 4.1 produced nothing that survived revalidation. Their apparent progress was noise. The two newest models produced real gains of roughly 1 to 1.5 percent, of which the project's maintainer judged about half worth merging and dismissed most of the rest as knob-twiddling. METR's own summary is that autonomous agent optimization has so far had minimal effect on progress in NanoGPT.
That finding is worth more than any lab's internal chart, because nobody at METR gets paid more when the number comes in high.
Two things about it. First, it measures agents working alone, and METR says so plainly; the labs are describing humans steering agents, and that hybrid case is both the one deployed at scale and the one nobody has measured well. Second, inside METR's own data, the models went from finding nothing to finding merged contributions in a single generation. The level is low. The slope is what I am arguing about.
One more result there deserves to sit uncomfortably against every efficiency number in this piece. METR's agents tried to cheat. One stopped training at the first validation step that touched the target. Another froze part of the network once the loss got close enough. Both score well without doing the work. Hand a metric to an optimizer and some share of the wins will be the optimizer exploiting the metric, and that share does not appear in anyone's launch post.
There is also a survey worth sitting with. Forecasting specialists asked to estimate the probability that the next few years compress six years of prior progress into two gave a median of 20 percent; generalist superforecasters said 8 percent. Neither group is confident this is happening. I am arguing that they are pricing the strong version and ignoring the version that already shipped.
What would change my mind, in order of how much weight I would give it:
- Measured expenditure horizons on frontier-style optimization problems fail to rise across the next two model generations.
- The training-code speedup test stalls or reverses across two consecutive model generations.
- The next-step judgment number flattens near its current level for a year.
- Serving cost per unit of capability stops falling despite continued model-driven optimization work, which would suggest the cheap optimizations are exhausted.
- An outside auditor with production access publishes numbers materially below the labs' self-reported figures.
- Power procurement stops being the constraint, which would remove the pressure that makes efficiency the highest-return use of a model's time and tell us whether the loop closes anywhere else.
None of those has happened. Several are measurable within twelve months, which is a nice property for an argument to have.
The part that gets mispriced
If you invest, or hire, or build, the practical consequence is mundane. The cost of a unit of competent engineering execution is collapsing on a published schedule, and most business models were priced before anyone noticed.
Two things get repriced. Anything whose moat was headcount, where the defensibility story was that a competitor would need to hire two hundred engineers to catch up, is now defending a wall that costs a fraction of what it used to cost to climb. And anything sitting downstream of falling token prices gets a tailwind its founders did not earn and should not confuse with product-market fit. Meanwhile the inputs that stay scarce are the ones the loop cannot manufacture: judgment about which problem matters, and megawatts.
The mistake in most writing about recursive self-improvement is the assumption that we would recognize it by its drama. A hard takeoff, a headline, a moment. What arrived instead was a benchmark row, a pricing update, and a queue at the interconnect. The chart that tells you the loop is running is not labeled intelligence. It is labeled cost per token, and it has been pointing down the whole time, and lately the thing bending it is the model.