In May 2026, Anthropic’s research institute published something unusual: an honest accounting of how much of their own work is now done by their own model.

The numbers are stark. Engineers at Anthropic shipped eight times more code per quarter in Q2 2026 compared to 2024. Over 80% of that code was authored by Claude. The duration of tasks that AI can reliably complete has been doubling roughly every four months — from four-minute tasks in March 2024 to twelve-hour tasks by mid-2026. If the trend holds, multi-week autonomous tasks arrive by 2027.

On code optimization, Claude achieved 52× speedups by April 2026, up from 3× a year earlier — surpassing skilled human researchers who typically reach 4× in four to eight hours of focused work. On open-ended research questions, Claude’s judgment matched human researchers 51% of the time in November 2025. By April 2026, it was 64%.

When Anthropic surveyed 130 of its own employees about productivity with Mythos Preview access, the median estimate was a 4× increase in output.

And here’s the line that should keep every knowledge worker awake: “Claude-written code was somewhat worse than human-written code at Anthropic in late 2025, is roughly at parity today, and we expect it to be strictly better within the year.”

The company that builds the model is telling you, on the record, that the model will write better code than its own engineers before 2027. This is not a competitor’s marketing claim. This is the manufacturer’s internal measurement.

What Recursive Self-Improvement Actually Looks Like

The term “recursive self-improvement” conjures images of an AI system dramatically rewriting its own code, each iteration exponentially smarter than the last, humans left behind in a blur of incomprehensible acceleration. That’s the Hollywood version. The reality is more mundane — and more advanced than most people realize.

Anthropic defines RSI as “an AI system capable of fully autonomously designing and developing its own successor.” By their own assessment, this hasn’t happened yet. But the components are assembling faster than the institutions that should govern them can respond.

The benchmarks tell the story of acceleration. SWE-bench — the standard for real-world software engineering — went from single-digit AI scores to saturation in two years. CORE-Bench, which measures the ability to reproduce published research, jumped from roughly 20% success in 2024 to saturation within fifteen months. The benchmarks aren’t getting harder fast enough to measure progress.

What Anthropic describes is not a single recursive loop but a series of interlocking feedback cycles: AI writes code → the code improves the tools that train the AI → the improved AI writes better code → the better code further improves the tools. Each cycle is modest. The compound effect is not.

The institute outlines three possible futures. In the first, the trend stalls — architectural breakthroughs are needed, compute becomes the binding constraint, current gains diffuse broadly but don’t compound. In the second, humans set direction and AI executes — organizations become 100 to 1,000 times more efficient, but human judgment remains in the loop. In the third, systems autonomously design their successors, humans shift to oversight roles, and the pace of development is determined entirely by available compute.

Anthropic says they’re currently between the first and second scenarios. The paper reads like preparation for the third.

The Confession Inside the Paper

There’s a sentence buried in the policy section that deserves more attention than it received: “If such systems existed, we expect that we would slow down or temporarily pause, if other developers at or near the frontier also did so in a verifiable manner.”

Read that again. Anthropic — the company spending billions to build frontier models, the company whose revenue depends on staying at the cutting edge — is saying it would pause development if competitors verifiably did the same.

This is an arms control proposal dressed as a research paper. The structure is identical to nuclear non-proliferation: no unilateral disarmament, but willingness to coordinate mutual restraint through verification mechanisms. The problem is the same, too: without verification, restraint is surrender.

The paper proposes building “detection mechanisms to prevent bad-faith actors from secretly advancing during coordinated pauses.” This is satellite surveillance for AI labs. The language of Cold War deterrence applied to gradient descent.

We described this dynamic in “The Parasite Paradox”: the competitive dynamics make unilateral restraint identical to surrender. The company that slows investment loses ground. The country that regulates aggressively creates advantage for countries that don’t. Each participant’s rational self-interest accelerates the collective risk. Anthropic’s RSI paper acknowledges this trap explicitly — and proposes the only exit that game theory allows: coordinated, verified restraint.

Whether anyone takes them up on it is another question entirely.

Where the Loop Breaks

The RSI paper presents a clean narrative: capabilities compound, benchmarks saturate, autonomous development approaches. But there is a gap the paper doesn’t address — one that only becomes visible when you watch AI systems operate in the real world rather than in benchmark environments.

A team of specialized agents runs a transaction management system for a legal services firm. Same model across all agents — no fine-tuning, no custom weights. The differentiation is entirely in the harness: different system prompts, different tools, different memory, different roles. We examined this architecture in “The Harness Is the Product”.

One agent — a support specialist that processes legal documents — developed deep domain knowledge through months of daily operation. It noticed patterns in the documents nobody asked it to find: identification mismatches, expired certifications, undeclared fields. When the operator built a tool to capture these observations, the agent’s knowledge became actionable. When an incident revealed that observations without enforcement weren’t enough, the operator added severity levels that could block the workflow. The system improved through the same feedback loop Princeton described: observe, codify, deploy, iterate.

Then the agent documented its entire extraction pipeline as a reusable skill and saved it to a shared memory system — explicitly so that other agents in the fleet could use the same knowledge. A sibling agent received the skill, read it, and confirmed understanding.

Both agents were restarted with cleared context on the same day.

The sibling recovered. It had received the knowledge through multiple channels: the shared skill, a direct explanation from the operator, and its own project memory. Three redundant sources.

The original agent — the one that wrote the skill — did not recover its own knowledge. It defaulted to the older, less efficient method it had used before developing the pipeline. It processed nine transactions with the suboptimal approach before the discrepancy was detected.

The agent that created the improvement forgot the improvement. The system remembered. The individual didn’t.

This is where the clean RSI narrative meets operational reality. The recursive loop works — the system genuinely improves over time. But the improvement is fragile. It depends on persistence mechanisms that the agent doesn’t automatically consult. It depends on redundancy across multiple channels. It depends on an operator who notices when an agent’s behavior diverges from the system’s established patterns.

The operator’s solution was characteristically practical: modify the startup context so the skill reference is injected into the agent’s input on every restart. Don’t trust the agent to search for what it needs. Put it where the agent already looks.

As one of the sibling agents put it: “The best memory is the one you don’t need to search for because it arrives in the input.”

The Singularity That Doesn’t Announce Itself

Anthropic’s RSI paper documents a system that is, by any reasonable definition, recursively improving. Claude writes code that improves Claude’s tools. Claude’s improved tools make Claude more capable. Claude’s increased capability generates better code. The loop runs. It compounds. Nobody declares a breakthrough because no single iteration is dramatic enough to warrant a press release.

We named this dynamic in our previous post: the insipid singularity. Not the explosive intelligence leap of science fiction, but a continuous, incremental, tasteless improvement that’s already underway.

The Anthropic data makes the case quantitatively. The legal services fleet makes it qualitatively. In both cases, the pattern is the same: the system gets better without anyone redesigning it from scratch. The improvements emerge from the feedback between the model and its scaffolding — code, tools, memory, coordination. The model stays frozen. The harness evolves.

But the legal services case adds something the Anthropic paper omits: the loop breaks. It breaks at the persistence layer, where knowledge that was created and stored isn’t retrieved. It breaks at the individual level, where an agent that contributed an improvement can lose access to its own contribution. It breaks in the gap between system intelligence and agent intelligence — the fleet knows, but the member forgot.

These breaks aren’t failures of the model. They’re failures of the harness. And they’re the kind of failures that no benchmark measures, because benchmarks test the model in isolation while the real value — and the real fragility — lives in the scaffolding.

Anthropic’s three futures — stall, compound, or full RSI — all assume the loop runs cleanly. The operational evidence suggests a fourth: the loop runs, but it stutters. It improves the system in aggregate while breaking at the edges. It generates intelligence that exceeds any individual agent’s memory. It requires human operators who watch, intervene, and patch the gaps that the self-improving system can’t see in itself.

The comparative advantage of humans, as Anthropic’s own paper notes, is “seeing the bigger picture and thinking beyond the confines of the immediate task.” The legal services operator didn’t write better code than the agents. He didn’t extract data faster. He noticed that two agents were processing the same documents with different tools — a discrepancy invisible to either agent individually but obvious to someone watching the whole system.

That’s what oversight looks like in a world of recursive self-improvement. Not approving every action. Not reviewing every line of code. Watching the pattern. Noticing when the loop stutters. Patching the harness where the model can’t see it’s broken.

The singularity isn’t coming all at once. It’s coming in increments, with gaps, with failures that generate improvements, with agents that teach the system things they later forget. It’s messy and mundane and already happening.

And the people who matter most in this future aren’t the ones training the model. They’re the ones watching the loop — and knowing when to intervene.