Skip to content
Back to all essays
George's Takes

RSI Is Now in an SEC Filing. Almost Nobody Has Shown It—Including Us.

Our loop made a model 22 points better at a hard task. It still isn't recursive self-improvement. What Anthropic, OpenAI and 1,250 papers are really claiming—and the bar I'm holding Vinci to.

By George PuEssay20 min read

Published

Nine experiment cards, one accepted result, a regulatory binder, a brass loupe and calipers arranged as physical evidence.
AI-generated object-led editorial still life about scrutinizing research claims; not a documentary photograph.

Everyone in AI wants to say they've built recursive self-improvement.

RSI is the big idea. A model gets better, then uses that to make itself better again, and again, faster each time. It's the story behind every intelligence-explosion thread you've ever scrolled past.

A lot of RSI papers have come out lately. Most of them are headlines. This month, Anthropic even put it in an SEC filing.

At Vinci, we built something real. A loop that trains a model, tests it, and decides on its own whether to keep the new version.

It worked. The model got meaningfully better at a hard, specific task.

And it's still not RSI.

Here's my opinion up front: RSI has become a marketing word. Almost nobody using it has shown it. And the labs closest to the real thing are the most careful about what they claim.

I posted the short version on X. This is the long version - including the parts of that post I should have been more careful about.

RSI just went from sci-fi to an SEC filing

For decades, recursive self-improvement was a thought experiment. In 1966, I.J. Good wrote that 'an ultraintelligent machine could design even better machines', and that there would then be an 'intelligence explosion'.

This fall, it became a line in a securities filing.

Anthropic. On November 2, Anthropic amended its IPO filing with a new risk factor. Its internal estimates and expectations for future models, it told investors, indicate it may 'imminently meet' its Responsible Scaling Policy's definition of 'dramatically accelerated progress attributable to AI' - the threshold the company connects to what 'has been termed recursive self-improvement'. Under Anthropic's policy, that threshold is a doubling of the baseline rate of improvement, plausibly caused by AI.

The same filing says Anthropic has not designated any current model as exceeding that threshold, doesn't expect to safely let Claude design and build new frontier models 'without meaningful human supervision or understanding', and may not identify a sharp acceleration until after it has happened.

Critics were quick to point out that an IPO filing is also a pitch to investors. My read: it's both. Lawyers don't let you write 'imminently' in a securities filing for fun. But read the next sentence. No model has crossed the line. Anthropic is saying it might be close, not that it's there.

OpenAI. In September, OpenAI said it had hit its 'automated research intern' milestone on schedule - a system that handles well-scoped research tasks under human direction - and it's aiming for a full automated AI researcher by March 2028. By mid-August, its research organization was logging 3.1 agent-workdays for every human workday. Its median researcher was burning more than $600 a day in AI agent compute at API prices, and the top 10% more than $7,000.

OpenAI's own warning is more useful than the headline. It says people still set research priorities and judge which results to pursue, that rapid RSI isn't necessarily an outcome the company should pursue, and that it does not yet know how to safely reach aligned, full RSI. All of OpenAI's numbers come from inside the company, not an independent audit.

Google DeepMind. DeepMind researchers have pointed to AlphaEvolve as an early sign of the pattern. The Gemini-powered agent has been used to make Gemini's own training more efficient. But DeepMind's description of the system also makes the boundary clear: people still choose the problems, and automated evaluators score the proposed programs.

The money. A startup called Recursive raised $650 million at a $4.65 billion valuation with the explicit goal of building self-improving AI. And the co-leads of DeepMind's AlphaChip project founded Ricursive Intelligence to use AI to design AI chips - the same Ricursive that just trained Ripple-65B from scratch.

The skeptics. Not everyone's buying it. OpenAI researcher Jason Wei has argued that self-improving AI doesn't exist yet, and that when it does, the takeoff will be 'extremely gradual across many years'. Nathan Lambert at the Allen Institute expects 'lossy self-improvement', where friction keeps slowing the flywheel. Meta's Jason Weston and Jakob Foerster argue the better goal is 'co-improvement', with humans kept in the loop. And Oriol Vinyals, who just left DeepMind, thinks RSI is inevitable but slow, with no intelligence explosion in sight.

So that's the backdrop. Labs worth close to a trillion dollars telling the SEC it might be close. Researchers arguing about whether it's already here. Billions of dollars betting it's coming.

Here's what it actually looks like from inside a small lab.

The loop we actually built

The task is infrastructure code repair.

Infrastructure code is the configuration that tells servers, networks and cloud services how to be set up. When it breaks, things go down. A useful model has to fix what's broken without wrecking the parts that were already right. A plausible-looking edit isn't a fix.

Our loop puts every new candidate model through the same cycle:

  1. Train a candidate.
  2. Evaluate it on a test set that's kept separate from the training material.
  3. Decide whether it replaces the current best model, using acceptance rules we wrote before the run started.

A candidate doesn't get promoted because its training loss went down, or because one example looks impressive. It has to clear the bar. If it doesn't, it isn't promoted, and the loop tries again.

Inside that structure, the decision is automatic. No one gets to look at a near-miss and wave it through.

But I want to be precise about what 'automatic' means. We chose the task. We built the tests. We wrote the rules for what counts as good enough and what counts as a reason to reject. Humans designed the whole thing, implemented it, and went digging every time it turned out to be inadequate.

The machine runs the loop. We built the loop.

9 attempts. 1 promoted.

At the time of my post, the loop had made 9 attempts - generations 2 through 10. It promoted 1.

Generation 10 lifted blind pair success on our infrastructure-repair task from 37.47% to 59.78%. That's a gain of 22.31 points over generation 4, our previous best checkpoint. The untouched base model scored 30.56%.

Both checkpoints were scored the same way, on the same 96 sealed cases across 14 families of broken infrastructure code, 16 attempts per case. Each case comes as a pair: a broken configuration and its correct twin. A pair only counts if the model handles both correctly, without being shown a scan. That's a strict test. A model that 'fixes' everything it sees fails it.

These are Vinci's internal, company-reported results. They have not been independently audited. I'm proud of the number. I also want to be honest about what it is.

It's a narrow result. It means the model got much better at one kind of job, measured one way. It doesn't mean the model became 22 points more intelligent. And it isn't an untouched, independent benchmark. Earlier evaluations shaped how we built the loop, and the arena is ours. A number like that only means something next to the details behind it - which is why they're all here.

The 8 generations we didn't promote matter just as much as the 1 we did.

A generation is an attempt, not a guaranteed step forward. Some of ours improved and still missed a gate. One of them, generation 4, ended up as the checkpoint generation 10 had to beat. And the bar didn't stay frozen. We tightened the rules between attempts, always going forward, never re-judging the past. So this wasn't 9 shots at one unchanged bar, and it wasn't 8 failures and a winner. If I only showed you the winner, I'd be giving you a misleading picture of how reliably this works. It works sometimes. That's the honest version.

And a better score is only the beginning. The first question after any gain is whether it survives a test the process hasn't already learned to pass.

What my X post got wrong

A post on X rewards punchy lines. A few of mine were punchier than the evidence. Here are 4 I'd rewrite.

'That one took Google's Gemma from 37% to 60%.'

Close, but it blurs 2 starting points. The 37% wasn't raw Gemma. It was generation 4, our own previous best checkpoint. The base model started at 30.56%. So the promoted model beat our previous best by 22 points, and the base model by about 29. Both are real. They're different claims, and the post made them sound like one.

'Tests it on tasks it has never seen.'

That's the goal. It's harder to guarantee than it sounds.

A held-out test set only stays held out if nothing leaks back into training. And leaks don't have to be obvious. If you look at test results, adjust the next training run, look again and adjust again, the system slowly learns to satisfy the test - without anyone ever copying an answer into a training file.

That's not hypothetical for us. In generations 7 and 8, some of our sealed checks leaked. We found it and fixed it. And when I say 'blind', I mean the model wasn't shown scan output - not that an outside reviewer graded it.

The honest version is: here's what we withheld, here's how we checked for overlap, and here's what the process was allowed to see. A contamination check is evidence. It isn't proof that every trace of familiarity is gone.

So we ran a confirmation on a separately screened set: generation 10 against generation 4, 29 complete pairs - 58 cases - across 14 families, with the contamination check and the pass bar declared before the run. It finished on November 1.

The reported gain was 24.96 points. The one-sided 95% lower bound was +1.61 points, against a floor of +1 we set in advance. So it passed.

2 caveats. The lower bound clears the floor, but not by much - the evidence says the gain is very likely above 1 point, not that it's 25. And it tests the same trained model, so it's a second look at one gain, not a second gain. I'm reporting it from our results write-up. I'll publish the receipt once we've rechecked it against the raw outputs.

'Coding didn't get worse. Safety didn't get worse.'

I can't support either line right now. When we went back through the release evaluations, the coding and safety runs - HumanEval, MBPP and JailbreakBench - turned out to be invalid. They have to be rerun. Until they are, I don't have a valid before-and-after comparison for either. Those lines shouldn't have been in the post.

The one check I can talk about is narrower, and it taught us something anyway. It's a scan-track check on our own task, not a general safety benchmark. The promoted candidate showed a regression of 3.02 points on it, against a limit of 3.47. Under a simple rule, that's a pass - it's under the line.

But when we looked at the uncertainty, the one-sided 95% upper bound on that regression was 8.17 points across 14 families. The evidence couldn't rule out a regression more than twice our limit.

So we changed the rule, going forward. Now a candidate doesn't just need its average to sit under the limit. The uncertainty has to be small enough to show it really stays under. The new rule doesn't retroactively un-promote generation 10. But it does mean 'no regression' was too strong a thing to say.

That's a much less convenient rule when you want to announce a win. It's a much better rule when you want to know whether you actually have one.

'I haven't seen anyone show that yet.'

This one I got the most wrong. More on it below.

Better vs better at getting better

Here's the line that matters.

In our loop, the model is the thing being improved. Everything around it - how training happens, how a candidate gets tested, when it's kept - stays the same. We wrote that machinery. The model just runs through it.

Running the same machinery over and over doesn't show the machinery is getting better at producing improvements.

Think of it in 3 steps.

A fixed recipe produces a better model. That's an improvement.

The same recipe produces a better model again. That's repeated improvement.

The system changes the recipe itself, and the new recipe produces better models than the old one would have. That's the beginning of recursive self-improvement.

We're at step 1, with a strict scorekeeper.

And even step 3 isn't as simple as 'the model rewrote its own code'. A system can edit its training script and make it worse. It can quietly make its own test easier and look like it improved. Editing the loop proves nothing.

What would convince me is this: take the old improvement process and the new one, run both on fresh problems with the same budget, and show the new one wins - on problems beyond the one that inspired the change, and still winning cycle after cycle, under a test the system can't redefine.

Anthropic's own threshold is a useful yardstick: a doubling of the baseline rate of improvement, attributable to AI. That's what the big labs mean when they talk about getting close. Our loop isn't anywhere near that conversation, and I don't want anyone reading my X post to think it is.

Oriol Vinyals made a point I agree with. Labs mostly measure self-improvement indirectly, by climbing capability benchmarks and hoping self-improvement shows up as a side effect. Better benchmarks test it directly: give a system a metric and a compute budget, and measure how much it improves itself.

That's close to what our loop does - a fixed metric, a fixed bar, a fixed budget. The missing piece is the one that matters: the system improving the loop, not just the model inside it.

That's the bar for calling it RSI. Our loop doesn't clear it.

Others are closer than I said

On X, I ended with: 'RSI is when the model starts rewriting the loop. I haven't seen anyone show that yet.'

That was too quick. Some serious researchers are working on exactly the harder version, and the honest thing is to say so.

The Darwin Gödel Machine. Researchers including Jeff Clune built a system that rewrites its own code and tests each change on coding benchmarks, keeping an archive of agents that branches in many directions at once. It improved its performance on SWE-bench from 20.0% to 50.0%, and on Polyglot from 14.2% to 30.7%.

The catch: the underlying foundation model isn't being retrained. What rewrites itself is the agent code wrapped around it. That's a different mechanism from training new model weights, the way our loop does. But it's real evidence, and it doesn't deserve to be dismissed just because it doesn't fit a neat definition.

Hyperagents. This year, a follow-up from some of the same researchers went a step further. It puts the task agent and the thing that improves it into one editable program, so the procedure that generates improvements can itself be modified. The authors report that those improvements to the improvement process transfer across domains and accumulate across runs.

That's much closer to 'the model starts rewriting the loop' than anything we've built.

To be clear, these are bounded research demonstrations. They don't show open-ended acceleration, general autonomy, or an inevitable intelligence explosion. But the right response is to read what they actually show, not to pretend they don't exist.

So here's my corrected claim, and it's narrower than my post: our result doesn't show that our system got better at making future improvements. Others have early evidence of something like that, in limited settings. Nobody I've seen has shown it running open-ended - including us.

Papers are cheap. Experiments aren't.

I've read almost every paper with RSI in the headline over the last year or so, including a lot of work from labs in China. Unfortunately, most of it has very little to do with recursive self-improvement.

That's not entirely the authors' fault. There's no agreed definition of RSI, so everyone has the right to use it. And some of this is genuinely good work. But the label has drifted far from the thing.

And the incentive is obvious. Put 'recursive self-improvement' in a title and you get attention and citations. Put it in a pitch and investors write nine- and ten-figure cheques for the idea. Nobody gets that attention for 'we built a careful evaluation loop'.

Here's a sample.

PaperWhat the headline saysWhat it actually does
Gödel Agent - Peking University, UC Santa Barbara, Arizona (2024)An agent that can 'recursively improve itself without any limitation'An agent built on an existing LLM that reads and rewrites its own code while it runs, tested on coding, science and math tasks
AlphaGo Moment for Model Architecture Discovery (ASI-Arch) - Shanghai Jiao Tong University and partners (2025)'The first demonstration of Artificial Superintelligence for AI research'An automated search for linear-attention architectures - 1,773 experiments, about 20,000 GPU hours, 106 architectures it reports as state of the art. Real work, narrow domain
Memento 3: Model-Based Recursive Self-Improvement through Reflective Rulebooks (2026)Recursive self-improvementA frozen LLM agent that learns world models in external memory. Its case study wins Atari Pong 21:0 - while the underlying LLM stays fixed
The Last AI Built by Humans: Toward Genuine Recursive Self-Improvement (2026)'The Last AI Built by Humans'A 35-author roadmap that lays out stages of autonomy on the way to RSI. Useful framing - but a roadmap, not a result

To be fair, some papers get it right. AI4AI-Bench defines RSI precisely - an AI improving the training algorithm itself, so the next system inherits the gain - and builds a benchmark to test exactly that. Another paper argues that current LLMs fall short of the introspection RSI would need. That's the kind of honesty the field needs more of.

I'm not the only one who's noticed the drift. A survey published this summer looked at 1,250 arXiv papers on self-improvement from 2024 to 2026. Its finding: 'Nearly all of the 1,250 papers surveyed here study bounded self-refinement' - improving against a fixed test someone else wrote. Systems that close the loop entirely were 'sparse everywhere'. The authors also point out that words like 'self-refine', 'self-reward', 'self-play' and 'self-evolve' blur together ambitions that are completely different.

That's my real fear. Not that people are lying. That we're all using RSI as if we're already there, when it's still a process. Papers are cheap. Experiments aren't. And every inflated headline makes it harder to recognize the real thing when it finally shows up.

What I think is really going on

1. What we're seeing is human-directed acceleration, not RSI. AI is doing more and more of the work of building AI. But look at which work. OpenAI tracked its agents across every stage of research, from choosing directions to running experiments. Agents took on more implementation and experimentation. High-level planning remained a minimal fraction of agent output. The survey of 1,250 papers found the same bottleneck at the top: research direction-setting.

A loop that still needs a person to decide what deserves improvement is human-directed acceleration. That's an enormous deal on its own. It's just not the thing in the headlines.

2. The evaluator is the whole game. The same survey makes a point every lab should tape to the wall: 'every improvement loop is a claim that some signal can substitute for human judgment'. Whoever writes the test owns the result.

That's why, in our loop, the acceptance rules matter as much as the training. And it's why the scariest version of RSI isn't a model that rewrites its training code. It's a model that rewrites its own test. Once a system can grade itself, you can no longer trust its score.

3. Know where you sit on the ladder. The survey sorts every improvement loop by how much a human is involved. In the loop: a human makes the calls. On the loop: an automatic signal makes the calls, and a human audits the results. Closed loop: no human review at all.

Vinci is on the loop. The decision to keep a candidate is automatic. We audit everything, and we wrote every rule. Almost every 'RSI' paper I've read sits in the same place. The closed-loop row, where a system also rewrites its own evaluator, is nearly empty.

4. If RSI comes, it comes where the compute is. OpenAI's median researcher uses more than $600 a day of inference at API prices. The top 10% use more than $7,000 a day - per person. That's more than many startups spend on compute in a month. Closing the loop isn't just an idea problem. It's a compute problem, and the labs with the most compute will get there first. That's the same lesson as the model race: a small lab's edge isn't out-spending them. It's being more honest and more specific than they can afford to be.

5. My prediction. The first real RSI won't be announced in a paper title. It'll show up as a lab's progress curve bending in a way it can't fully explain - and that lab will be the last to be sure. Anthropic has already told investors it might not notice until after it happens.

Which is exactly why the rest of us shouldn't be shouting 'RSI' every time a loop goes up by a few points.

Why we're building it anyway

If it's not RSI, why bother?

Because a small lab doesn't need an intelligence explosion to win. It needs to learn faster than it could by hand.

A loop that tests ideas with less manual work, rejects weak candidates every time, and keeps the evidence attached to every decision is worth a lot. Fewer choices made on a convincing anecdote. Less time spent reconstructing why we picked a checkpoint 3 weeks ago. More honest answers about what's actually working.

That doesn't mean the next step is removing every human. Choosing which problem matters is still a research and product call. So is deciding which failures are unacceptable. Automating a decision rule doesn't remove responsibility for the rule. It just moves the responsibility to the person who wrote it.

And loose language has a cost. When a lab calls an ordinary improvement loop 'RSI', readers reasonably hear a claim about what comes next - progress speeding up because the system is becoming a better researcher. A narrow benchmark gain doesn't pay for that.

And measuring this is hard for everyone. Anthropic told investors it may not spot a sharp acceleration until after it's happened. If one of the best-resourced labs in the world can miss that, a small lab can easily fool itself with a flattering average. That's exactly why our rule now looks at the uncertainty, not just the number.

So here's my commitment, for myself and for Vinci.

We won't claim RSI until the day we actually achieve it. When we do, we'll publish the evidence: the loop, the tests, what failed, and proof that the system changed how it improves - not just what it scores.

Until then, every result we share will say exactly what it is. What we tried, what we kept, what failed, and what the tests can and can't support.

For now, it's this.

We built a loop that made a model better at a task.

A second test says the gain holds. We still owe you the reruns on coding and safety.

The model got better. It didn't get better at getting better.

Not yet.

Share this:

New essays and letters, by email

Subscribe if you would like to hear from me when I have something worth sending. Everything here remains free to read.

Optional. Unsubscribe anytime.