“Automated AI R&D could totally happen this year.”
— Former frontier AI lab employee, October 2026
There’s a good chance that we’re about to enter a period of AI progress where AI models will do a better job than humans at most or all AI R&D-related tasks. Smart models will build smarter models, which will build still smarter models. This is called recursive self-improvement, or RSI.
We’ve worked with researchers at Anthropic, OpenAI, and Google DeepMind to put together a working picture of what RSI will look like. Most of these researchers believe RSI will start within the next 3 to 12 months, and possibly sooner, assuming there’s no U.S. government intervention or slowdown. Some think RSI will lead to an intelligence explosion, as AI progress starts to unfold on computer clock time — faster than any human engineer can keep up with — until we usher in a utopia with intelligence on-tap. Alternatively — and in the quietly held views of many lab insiders, more likely — we’ll either lose control of the resulting AIs and die, or our on-tap intelligence will let us build new kinds of cheap, devastating weapons and we’ll also die.
“Software-only intelligence explosion is on track.”
— Senior frontier AI lab employee, July 2026
We think it’s worth better understanding how RSI will probably unfold, what kind of work it would involve, and what its implications could be for national security. We’ll cover a bit about each of these in this post.
We’ll be sharing more about this on our YouTube channel soon. You can subscribe there, or to our Substack below, to stay in the loop.
RSI: the standard story
You may have already heard the standard story of recursive self-improvement. It goes like this:
An AI (version 1) gets smart enough to improve itself. That new improved AI, version 2, is smarter, so it can improve itself faster. That AI, version 3, is smarter still. This process goes on, faster and faster, until the intelligence graph goes vertical. And somewhere on the way up, the AI stops being a research tool and starts being a new kind of entity.
This is a compelling story, and it has some truth to it. But it also glosses over several things.
One problem is that at every step in that loop, somebody has to make sure the next improved AI version actually is an improvement. And finding that out costs compute, which there’s a limited supply of.
We’ve spent the last six months talking to people who do this work at the frontier AI labs, and we’ve ended up with a general picture of how AI research gets done. Once you see it, you’ll find that a lot of the arguments about how fast, and how violently, AI will change the world reduce to a handful of concrete questions.
Let’s build up to those questions one ingredient at a time.
Ingredient 1: A pool of compute
A frontier lab has a certain number of computer chips that it can run for a certain number of hours. The total amount of computation (or “compute”) it can do with those chips in that time is C.
The frontier lab needs to use most of that compute to either train their next AI model, or to serve their existing models to their customers. But they also have to set aside a slice of their compute for pure research — that is, for running the experiments that will tell them what kind of AI models they should be building in the future.
That research slice is the subject of this post.
Ingredient 2: A pile of ideas
At the same time, the lab has ideas: a new way of designing their next model, a different ordering of their training dataset, a change to their optimizer algorithm – anything they think might help them make their next AI smarter or cheaper to serve. Call the number of those ideas N.
At first, all of the lab’s N ideas look about equally promising. If the lab knew which of them were good, they’d just implement the good ones and forget the rest. But the lab doesn’t know which of its ideas are good and which ones aren’t; that’s what makes it a lab.
The only way to find out is to spend compute
You can’t usually tell if a research idea will work just by thinking hard about it. You can have an opinion, and more experienced researchers do tend to have more accurate opinions about ideas. But the only true test of a research idea is to run an experiment with it.
How do you run an experiment with an AI research idea? You use your idea to train a series of bigger and bigger AI models, using greater and greater amounts of compute. If your idea is some new way of mixing your training data, then you train each of those bigger and bigger models on that new data mixture. And finally you look at your results: you plot how well each model performs, against how much compute you spent to train it.
The result is a scaling curve for the idea you’re testing.
The catch: you can’t run them all
Now suppose you have fifty ideas, but you only have enough compute to test one of them at serious scale.
One thing you could do is just pick your favorite idea and spend all your compute on testing it. If you’re right you’ve learned a lot. But if you’re wrong, you’ve spent your entire research budget learning that one idea doesn’t work.
Nobody does this. What labs normally do instead is run all fifty, but run them at small scale.
Here’s how that works:
Take some fraction of your experiment budget, call it C₁.
Split it more-or-less evenly across N ideas.
At first, you give each idea C₁/N compute to prove itself. This isn’t enough to know if it works at the scale of a full frontier training run, but it’s enough to draw a very short scaling curve.
The x-axis of each curve shows the amount of compute you’re spending on each point of the curve. The y-axis is some measure of your model’s performance.
Now you look at your fifty short scaling curves and use them to decide which ideas you should drop and which you should keep. Most of the ideas get dropped. A handful — the ones with curves that rise fastest, or the ones with curves that cross some performance threshold — get to move to the next round.
Let’s say that some number, N₁, of these ideas survive this first round of selection, Round 1.
In the Round 2, you — the AI lab — dedicate an additional slice of compute, C₂ to test those N₁ surviving ideas by pushing them further. C₂ can be quite a bit bigger than C1 was, and crucially, it gets split up among only N₁ ideas (rather than all the original N ideas). So each surviving idea gets dramatically more compute than it got in Round 1.
With that extra compute, you can now take your N₁ surviving ideas and extend their scaling curves farther out than before. By doing this, you can find out whether an idea that looked good at small scale keeps looking good when you give it 10X or 100X as much compute.
Then you do a Round 3 of scaling and selection. And a then a Round 4.
After a few rounds of this, you end up with a small number of ideas that have survived many rounds of scaling and selection, and that you have performance data for across a wide range of compute scales.
Pretraining and post-training
The process of training a frontier AI model is (somewhat imprecisely) divided into two phases: pretraining and post-training.
During pretraining, you show the model text from the internet, and ask it to predict the token that comes next — basically, this is text autocomplete. In order to get really good at this, the model has to learn all kinds of facts about language, and ultimately about the world. That’s because being really good at text autocomplete requires being good at completing sentences like, “Had Japan raised interest rates in the mid-1990s, the effects on Toshiba would have been…”, which you can only do well if you know what Japan is, what Toshiba is, what was going on in the 1990s around the world, and so on.
For pretraining experiments,1 the y-axis is usually something called compute efficiency: how quickly models learn to reach a given level of performance on certain benchmarks and evals. If Model 2 can match the performance of Model 1 on some key evals after spending just 50% of Model 1’s training compute, Model 2 is twice as compute-efficient as Model 1.
According to the frontier AI researchers we’ve spoken to, you can find a decent number of ideas that scale well and survive all the way to the end of the idea selection funnel.2 But the very best ideas — the ideas that deliver the greatest improvements in model quality, and define model generations — are often ones that not only continue to work at scale, but that work better and better at bigger scales.
The second phase of training a frontier model is called post-training. Here, the model is trained on the same autocomplete task as before, but using more specialized and carefully curated text in a process called supervised fine-tuning (SFT). A coding model might be trained on high-quality coding data, for example. But agentic models are also trained on reinforcement learning (RL) problems — tasks where they receive a reward for achieving a set of quantified objectives (or don’t receive a reward if they fail). RL environments are notoriously hard to design well, because AI models are really good at finding clever hacks their designers didn’t anticipate that allow them to get their reward in unintended ways. For that reason, RL environment design is currently one of the most manual bottlenecks in the AI training process.
You can build an idea selection funnel for RL environment design, RL reward design, and so on. But unlike for pretraining, where small experiments often don’t scale as you’d expect them to, post-training RL experiments that look promising at small scale often do just work when you raise the compute budget.
As one researcher put it to us:
“Pretraining is really where you care about this holding across many orders of magnitude. […] [With] RL, you can just do smaller runs with a few GPUs and it just generalizes.”
You still need to build a funnel for these ideas, but you might not need to go through as many rounds of experiments before you incorporate a new RL idea into your full-scale training pipeline.
So that’s more or less the picture. You run the scaling and selection funnel for enough rounds, and a small number of ideas — sometimes just a handful of them — survive all the way. Those scalable ideas are the ones that get reconciled, combined, and folded into the next generation of frontier AI models.
And then the whole thing starts over, with a better model, and a bigger compute budget.3
In practice, this is a messier process than the picture above suggests, especially in later rounds that can involve meaningful fractions of a lab’s research compute budget. If a researcher thinks they have a promising idea based on their small-scale experiments, then they may have to argue to get compute allocation for larger-scale tests, or to get their idea incorporated into the lab’s next big training run. In other words, the scaling and selection algorithm today can include office politics.
But if you zoom out and look at what the lab is doing as a whole — and the process that lawmakers might soon have to regulate — that’s roughly the picture.
Where does the AI go?
To make RSI work, the labs will need to get AI to do all the jobs humans currently do to move ideas through the scaling and selection funnel. That is, generating the ideas, writing the code, running the experiments, and interpreting the scaling curves. They are actively working on this.
As far as we can tell, there are two ways the scaling and selection funnel could produce a radical acceleration in AI capabilities:
First, the AI-generated ideas that the labs feed into it could become extremely good — good enough to compete economically with humans at research taste. Current models are arguably close to this threshold already. If AI can propose excellent ideas, then the funnel as a whole should produce better AI models than it does today. And if AI gets good at generating ideas that consistently work well at scale, you might get confident enough in those ideas that you can skip through most (or even all) of the scaling-and-selection funnel, and just directly build those ideas into the big training runs!
On the other hand, your idea-generating AI might not have to be especially good if you have a huge amount of compute available to run your experiments on. If you do, then you can afford to burn a lot of compute to test and scale crappy ideas, and count on the funnel to select the few good ones.
In other words: compute buys you the right to try lots of bad ideas; and good ideas buy you the right to spend less compute on experiments.4 Every frontier lab today is limited on each of these.
How labs trade off between compute and good ideas
Today, AI labs still rely on human-generated ideas to a significant degree. They have to create and test lots of candidate ideas, some of which are good and some of which are bad. But they have a limited pool of compute to test those ideas with. And that means they can only test a limited number of ideas.
The first problem this creates is noise. Recall that in the first step of idea selection, each idea got C₁/N compute. N, the total number of ideas being tested, is in the denominator. If automated idea generation lets you go from fifty initial ideas to ten thousand initial ideas, and the Round 1 compute budget is still C₁, then each idea now gets only 1/200th as much compute to prove itself as it would have before. That means the scaling curve you can draw for each idea, that you’re basing your decision in the next round on, is 200 times shorter than it was before!
The problem is that extremely short scaling curves tell you very little. So if you’re overwhelmed with early stage ideas, you may start finding it hard to tell the good from the bad.
But there’s another factor at play: the quality distribution of AI-generated ideas.
Here’s what that means. There are many ways AI-generated ideas could be distributed:
AI-generated ideas might have a long tail. The vast majority of them could be awful, but the occasional AI idea might be far better than the best ideas human researchers can come up with.
If that’s the case, then a lab has a shot at RSI uplift as soon as it has enough compute to sift through the bad ideas to find the excellent ones. A lab that has enough compute to do this will be on the path to RSI sooner.
To achieve RSI starting from this kind of idea distribution, you need to filter out many bad ideas, with less compute dedicated to each. That means shorter, noisier scaling curves, which means worse selection, which also means you’re less likely to actually catch the tail of excellent ideas you’re after. The noise problem and the long tail problem are therefore linked.
On the other hand, it’s possible that the best AI-generated ideas are consistently worse (for now) than the best human ideas.
A distribution like this could pose serious problems for RSI: no matter how much compute we put into sifting through our AI-generated ideas, we’ll never find ideas that are good enough to significantly improve the next generation of models because the ideas just aren’t there to be found.
Of course, both the AI and human idea curves will shift to the right over time — the first as models become better, and the second as humans learn things from past experiments that improve their research taste.
Labs might be able to start fully-automated RSI as soon as AI-only idea-generation crosses some minimal threshold, potentially without beating idea generation via human + AI teaming. But they would probably choose not to as long as human-plus-AI idea generation remains more effective in absolute terms: their goal, after all, is to stay ahead of competitors, and not simply trigger RSI for its own sake.
That’s one important take-home: automated RSI can be technically possible, despite not yet being economically practical; many of the researchers we spoke to believe that to be the case now.5
Researchers we’ve talked to mostly have lots of ideas; more than they can easily test given the compute budgets they have.6 This implies that the bar for AI idea quality to drive RSI is reasonably high: if compute is scarcer than good human-generated ideas, then it only makes sense to delegate idea generation to AIs once they can outperform humans at idea generation on a consistent basis.
On the other hand, if AIs generate a lot of mediocre ideas, then their rare bangers have to be much better than the best human ideas to make up for all their slop, given that the compute to test everything is scarce.
And if, instead, the best AI ideas are only about as good as the best human ideas, then AIs need to be consistent, and generate good ideas as often as or more often than human researchers. Either way, the juice has to be worth the squeeze, because every AI idea you test is a human idea you didn’t test.
The home runs we lose along the way
The scaling and selection funnel rests on the assumption that good ideas look good early. In other words, that an idea that’s worth investing 1024 FLOP into will show a promising slope at 1018 FLOP.
That assumption is often true, but it’s known to be false in at least some important cases.
For example, imagine an idea that shows promising early scaling at low compute, and which scales reasonably well beyond that point, too. We’ll call it Idea 1.
We might expect Idea 1 to have a good chance of making it past Round 1 of idea selection. But consider another idea, Idea 2, which performs poorly at small scale with no clear sign of improvement, but suddenly and violently takes off at larger scales:
Idea 2 is unlikely to survive selection through Round 1 or Round 2, so it gets dropped before it has the chance to show its promise.
This isn’t a hypothetical problem. You see it reasonably often when you compare different deep learning architectures or training methods to each other. Reinforcement learning from human feedback (RLHF) is a good example: when applied to small models it decreases performance, whereas the performance of larger models improves under RLHF. Early chain of thought (CoT) scaling had similar properties: smaller models can produce illogical reasoning chains that lead them to perform worse than they would without CoT prompting.
A related question is: how many ideas show a promising scaling slope at small scales, but stop being useful — or even become actively detrimental — at large scales?
These sorts of ideas lead to false positives through the first parts of our funnel, and therefore also shape the economic tradeoffs of RSI. They also appear somewhat often: there are several transformer alternatives that are on par with, or better than, the ordinary transformer at small scale, but that fail to keep improving competitively with a higher compute budget.
So if enough really good AI ideas look good at small scales, we may be able to achieve “idea generation escape velocity” soon. Certainly this seems to have been the case for the invention of the transformer itself — arguably the most significant AI advance of the past decade. Transformers generally outcompeted LSTMs, their then-best performing alternative, at all compute scales, both in terms of their absolute performance and of their scaling properties. So they would have been identified as promising, correctly, by the scaling and selection funnel we’ve sketched out.
According to the researchers we’ve spoken to, large parts of the scaling-and-selection funnel shows signs of starting to work in a largely or even fully automated way, which accounts for a large part of what’s driving optimism about the near-term feasibility RSI within the big labs.7
RSI enabling capabilities
AI capabilities that support any part of the scaling and selection funnel can accelerate RSI, depending on what a lab’s bottlenecks are. For example:
Reading the curves better. The funnel’s performance depends on how much signal a cheap experiment carries about an expensive one. If a scaling curve that looks promising at 1020 FLOP tends to also look promising at 1024, then it’s easier to find good ideas early. But it’s probably also possible to train AIs to get better at extrapolating how well an idea will perform at large scales based on smaller-scale experiments. A system that’s better at extrapolating short curves, at knowing which experiments are informative, and at designing lower-variance experiments, makes every part of the funnel more accurate. That’s a compute multiplier, and it might be the single highest-leverage thing an AI researcher could do.
Making the runs cheaper. Better kernels, higher hardware utilization, less wasted training. These are basic software engineering improvements that show up as more effective compute, i.e., that lower the cost of every round of selection-and-scaling. Improvements like these help in our current regime, where scarce compute is the main bottleneck.
Practical constraints: why Big Training Runs are YOLOed
So far, we’ve described an idealized version of the funnel that labs run today. In that version, the rounds of the funnel are sequential: they run one after the other. You can’t start Round 3 before Round 2 finishes, because the point of Round 3 is to test the ideas that Round 2 selected.
The later rounds are also slower — a validation run at frontier scale can take days or weeks. So you’d still have to run compute- and time-intensive experiments at the bottom of the funnel and wait for them to complete before reconciling your winning ideas for one Big Training Run.
For exactly that reason, after running some promising experiments at smaller scales and moving through the first few steps of the funnel, labs currently YOLO their training runs, effectively skipping the later funnel stages altogether. This makes the payoff of curve extrapolation even more critical: the final, huge bet they place on a large training run — which can be on the order of a billion dollars or more today — has to be partly a leap of faith.
Another reason there’s still risk in big training runs is that ideas that work well individually don’t always work well together, and interactions between ideas can change with scale too. This creates an irreducible challenge for parallel search across ideas.
Now do it for alignment
Everything so far has been about capabilities. The natural next question is: can alignment research use the same funnel? If they can’t, then that’s a problem: it means we can’t couple our ability to steer AIs to our ability to make them smarter.
One reason this funnel picture might work less well for alignment is that it’s generally harder to come up with alignment metrics than capability metrics. Performance gap recovered is one attempt to solve for this, but it only covers a narrow set of alignment-relevant problems.
But there’s at least one way in which alignment progress could be coupled to the scaling-and-selection funnel we’ve discussed here. It covers only part of the problem of alignment, but it’s a start.
There are some alignment-related behaviors we’d want to be able to detect in our models. These are things like scheming, deception, and reward hacking. Models tend to perform these behaviors when they have more test-time compute available to them. Intuitively this is because scheming and deception are effortful processes – they cost compute. It takes a model more test time compute to scheme while simultaneously performing its task, than it would for the model to solely perform its task. In other words, any surplus compute a model has can be pointed towards things other than the task it’s been given — and that includes bad behaviors. This means that in theory, if you could perfectly match an agent’s test-time compute budget to the difficulty of its task, you might be able to mitigate things like scheming.
So we start with a pool of test-time compute CTest. We also come up with N alignment ideas. We test each of these ideas on a model, agent, or system, using a compute budget C1Test/N. If we see a high frequency of reward hacking, scheming, or some other undesirable behavior during this initial round of testing, we discard the corresponding idea. Just like before, we promote the surviving ideas, and push them harder with an expanded test-time compute budget. As we do this, we’re extending the test-time compute horizon over which alignment has been tested for, hopefully “pushing” detectable misbehavior further down the line.
On the surface, this might seem promising. And yet there’s a sense in which it leaves all our work still ahead of us. Using this approach, we can never know with confidence whether models truly are aligned, or whether we’ve simply “pushed” their misaligned behaviors beyond the reach of our testing budget. But it gets worse: the models also simply may have figured out ways to hack our evaluations to conceal misaligned behaviors or intent. That’s closer to the real alignment problem, and it’s the very behavior you’d most expect to emerge as we approach superintelligence.
Another problem has to do with infrastructure: in an ideal world, the training compute that leads to advances in capabilities would be coupled directly to the test-time compute used to advance alignment. But training and test-time compute infrastructure often looks different, and it’s possible that we end up in a situation where customer demand for inference compute reduces the amount of compute available for alignment evals.
Where this leaves us
If this analysis is generally right, then a few key factors will determine when and how fast RSI unfolds in earnest:
How much does a cheap experiment tell you about an expensive experiment?
How heavy is the right tail of the idea-quality distribution, for AI-generated ideas specifically? How is this changing over time and over generations of idea-generating AIs?
How much can we reduce the scale, and therefore the cost, of early-round experiments while still yielding good enough data on which to base idea selection?
What’s the irreducible wall-clock time of the last round of the scaling and selection funnel that the lab can’t skip?
Based on over a dozen conversations we’ve had with lab insiders over the last few weeks, we’d describe the attitude in the labs as highly optimistic about starting a genuine RSI loop some time in the next 3 to 12 months.
They are far less confident about their ability to make progress in AI alignment and AI control benefit from that same loop.
Espionage implications
China’s intelligence services have almost certainly penetrated all the major frontier labs. (We say this with high confidence. We’ll have more to say in the coming weeks and months, but we’ve been working on nation-state security for frontier labs and supporting infrastructure for years.)
A natural question, then, is: what does that get them?
One thing it very likely gets them is the weights of frontier models themselves. This matters a lot, both because current frontier models are reasonably described as weapons of mass destruction, and because a lot can be distilled and reverse-engineered from model weights.
But algorithmic secrets are a separate and particularly important thing they almost certainly have access to. It’s worth thinking about one consequence this has for the scaling-and-selection idea funnel concept.
American labs have access to far more compute than their Chinese counterparts. They’re therefore interested in advances that show promise at larger scales. The best architecture for a Western frontier model may be quite different from the best architecture for a Chinese model, for reasons that have nothing to do with the design of their chips or their network fabric, but rather just because of the quantity of compute each kind of lab has available.
Take the early forms of chain-of-thought (CoT) reasoning, an example we mentioned earlier. CoT introduced an entire new axis of scaling that, as first tested, could only be used by labs that could scale their models beyond a certain size. At that critical scale, it suddenly made sense to redesign your pipeline around generating and training on long chains of thought. If a Chinese lab had learned about CoT scaling while their compute budgets only allowed them to train <10B-parameter models, there would have been little they could do with that information directly — until they got access to enough compute to train their models beyond that scale.
Many of the most valuable AI ideas of the last decade have behaved like this: scaling poorly or performing very weakly at small scales, before suddenly emerging at larger scales as major capability drivers (see also the RLHF example discussed before). In a very rough sense, last year’s Western algorithms contain some of the more promising seed ideas for China’s big training runs today. This in turn could mean that today’s best Western algorithmic innovations may disproportionately pay off for Chinese labs only months or years down the road (assuming they can be combined efficiently with the stacks Chinese labs currently use).
One consequence is that a successful Chinese espionage operation against frontier AI labs can have important effects that are only fully felt much later on, as they become compute-mature enough to benefit from more of the algorithmic secrets they steal.
Poor frontier lab security also has implications for RSI safety. One frontier lab alignment researcher we spoke to expressed concern over Chinese labs’ distillation attacks, and the degree to which they cause Chinese models to inherit alignment properties from U.S. frontier labs “for free”. This could make Chinese labs more likely to think alignment will come along with capabilities by default if distillation — which is often framed as a capability-extraction process — also trains safety properties into their models as a side effect.8
If Chinese researchers can obtain exfiltrated U.S. frontier lab models, a similar problem might play out at the level of model architecture: choices made for alignment might end up being replicated by Chinese labs who don’t understand their purpose. There may be some precedent for this in other strategic technologies. When the Soviet Union stole the designs for the Boeing B-29 Superfortress to build their Tupolev Tu-4s, they allegedly copied errors, such as stray drill holes, as a result of pressure from their leadership to ship operational aircraft quickly.
As opposed to post-training or reinforcement learning (RL) experiments, which we’ll talk about more later.
But keep in mind that the idea selection funnel we’re describing in this post is a simplified picture. Labs don’t actually maintain a formal stable of ideas, or necessarily manage an explicit funnel like this. Though that could change as the RSI loop is increasingly formalized and automated.
If this procedure feels familiar to anyone with a machine learning background, it should. This is successive halving — the algorithm underneath Hyperband — which is what everyone already uses to tune hyperparameters. Evaluate many configurations cheaply, throw away the bottom fraction, give the survivors more resources, repeat. Labs run this same algorithm one level up. Not on hyperparameters, but on entire research programs.
Because having more good ideas on your hands from the beginning means you have to spend less compute on testing bad ideas.
This could happen, for example, if the best AI ideas are just good enough right now that you could, if you wanted to, start a slow RSI loop by incorporating lots of those just-barely-good enough AI ideas into your next AI model. If an RSI loop like this could succeed eventually, but would still take more time in total than continuing human-AI collaboration, then that path to RSI would be achievable for the labs but not economically viable for them.
This isn’t a universal view, but it’s reasonably common.
In fact there is an increasingly held view at the frontier labs that what’s holding back RSI isn’t any kind of fundamental breakthrough, but rather the clearing of a few remaining engineering bottlenecks.
This is especially likely to happen given that Chinese distillation campaigns are particularly focused on extracting data for post-training purposes, which tend to influence downstream agentic behavior more than pretraining data does.