AI progress is driven by improved algorithms and additional compute for training runs. Understanding what is going on with these trends and how they are currently driving progress is helpful for understanding the future of AI. In this post, I'll share a wide range of general takes on this topic as well as open questions. Be warned that I'm quite uncertain about a bunch of this!

This post will assume some familiarity with what is driving AI progress, specifically it will assume you understand the following concepts: pre-training, RL, scaling laws, effective compute.

Training compute trends

Epoch reports a trend of frontier training compute increasing by 4.5x per year. My best guess is that the future trend will be slower, maybe more like 3.5x per year (or possibly much lower) for a few reasons:

• While Grok 3 is basically on trend for the 4.5x per year trend, other AI companies seemingly haven't released an AI with much more compute than GPT-4 (at least, an AI they actually keep deployed, GPT-4.5 is going to be quickly deprecated).
• Part of the 4.5x per year trend is due to the duration of training runs increasing. However, I don't think we'll keep increasing the duration of training runs. If anything I expect training runs might be a bit shorter than they were historically due to seeing faster algorithmic progress recently, in particular algorithmic progress yielding improved RL and reasoning models. Generally, faster algorithmic progress will result in AI companies doing shorter training runs as the opportunity costs (in terms of algorithmic progress which doesn't make it into the run) of a longer run are higher. (It's possible that scaled up moderate horizon RL will make training runs longer as step length might be longer for RL, but I currently don't expect this in the short term.) An alternative way to estimate the compute scaling trend is to multiply the trend in spending (around 2.6x) by the trend in FLOP/$ (around 1.35x) which yields 3.5x per year. (Somewhat lower is also plausible.) Another source for this is here. We also see a similar estimate of around 3.5x per year (not including longer training runs) in recent years here.
• There are some reasons to think that the current returns to putting more compute into pretraining are much lower than they were historically which is motivating a shift to scaling up RL. It's probably somewhat slower and harder to scale up RL FLOP, so this might (at least momentarily) slow down the compute scaling trend.

What's going on with pretraining runs much larger than GPT-4 and why might we not be seeing them?

There have been reports that pretraining has delivered unsatisfying returns or at least has been difficult to scale up. Mostly, people have reported that this is due to running out of (reasonable quality) data, but the public evidence is also consistent with this being due to the returns to further pretraining on reasonable quality data being low.^[1]

Grok 3 and GPT-4.5 (the models with the largest pretraining runs we're aware of) don't seem qualitatively that much better than models trained with much less compute. That said, GPT-4.5 is actually substantially better than other OpenAI models in many respects and it probably hasn't been RL'd very effectively (due to this being inconvenient on a model of this scale). It's also worth noting that Grok 3 is trained by xAI, so it probably has somewhat worse algorithms than models trained by OpenAI, Anthropic, and GDM. Additionally, Grok 3 appears to be substantially smaller than we'd expect a compute optimal model of that scale to be, in particular it appears much smaller than GPT-4.5 (based on inference speeds^[2]) which I'd guess is roughly compute optimal. This is probably so that Grok 3 is better to utilize for RL and inference, but this shaves some off the gain from scaled up pretraining. It's also possible that public reports about Grok 3's compute are overestimates. Another candidate model which might have used much more pretraining compute than GPT-4 is Gemini 2.5 Pro; it currently seems unlikely this model used 10x more (pretraining) compute than GPT-4, but this isn't inconceivable.

Regardless of exactly what is going on with pretraining, it minimally seems like returns to scaling up RL currently look better than returns to scaling up pretraining. For instance, I'd guess that the improvement from o1 to o3 was mostly more (and possibly better) RL, with OpenAI reporting it used 10x more RL compute than o1.^[3] (o3 probably used GPT-4.1 as a base model and this model isn't that much better than the base model used for o1 which is GPT-4o. Additionally, OpenAI seems to imply most of the improvement relative to o1 is from RL.) Overall, rumor and other sources seem to indicate that at least OpenAI is mostly focused on scaling up RL. My guess is that the RL run for o3 probably used an amount of compute similar to what was used for pretraining GPT-4 (including RL inefficiency relative to pretraining, as in measuring by H100 equivalent GPU time), so there should be room for substantial scaling with the compute AI companies current have, probably to around 30x more RL compute than o3 used (or enough for o4.5 if the 10x compute per reasoning model generation trend continues). My understanding is that right now RL scaling is limited by the quantity of useful environments that AI companies have (a type of data constraint), but AI companies are scaling this up rapidly and we should naively expect that RL scaling catches up to the available compute pretty soon. While RL scaling might soon eat the available compute overhang for RL, I'd expect that there is still far more algorithmic progress which is possible.

While RL scaling can continue, it's unclear whether it will hit diminishing returns. My guess is that relevant downstream metrics (e.g., performance on agentic software engineering tasks) will have reasonably smooth log linear scaling (at least with well optimized RL algorithms) for at least the next 2 or 3 orders of magnitude. Of course, progress may still qualitatively slow once RL compute catches up to the available compute.

Another important aspect of training compute scaling trends is that we expect compute scaling to slow down in a few years (maybe by around 2029) due to limited investment or limited fab capacity. See here for discussion of investment slow down. I think we're currently at maybe ~15% of fab capacity being used for ML chips which only permits a small number of additional doubling before fabs will mostly be producing ML chips and further production will be bottlenecked on needing more fabs. That said, note that there will probably be a lag (maybe 2-3 years?) between compute scaling slowing and AI progress slowing as I discuss here.

This yields some important open questions:

• Are returns from pretraining really mostly dead or is it just that the returns look somewhat disappointing as the increase in effective compute is still too small and GPT-4.5 (perhaps the only model which is solidly 10x more effective compute) isn't RL'd well?
  • Will we see GPT-4.5 scale models grow in adoption over time?
• Will progress slow down substantially after RL scaling catches up to the available compute?
• Sometimes people speculate that RL is well described as better eliciting capabilities which the base model "already had"; to the extent this is true, does that imply that RL gains will cap out soon?
• How slow will it be to scale up the number of RL environments? Does reward hacking make this substantially slower?

Algorithmic progress

Epoch reports that we see a 3x effective compute increase per year due to algorithmic progress in LLMs. More precisely, Epoch finds that the compute required to achieve a given level of loss at next token prediction decreased by around 3x per year.

Effective compute is a way of converting algorithmic progress into an equivalent amount of bare metal compute. It corresponds to "how much compute would get you the same level of performance without these algorithmic improvements". While conversion into a single effective compute number is missing some nuance, I still think this is a useful baseline model for understanding the situation.^[4]

However, loss doesn't accurately capture downstream performance and many aspects of the algorithms (data mix, RL, training objectives other than next token prediction, inference code, scaffolding) can improve downstream performance without improving loss. Given that there are these additional ways to improve downstream performance (particularly RL), my sense is that overall algorithms progress on the downstream tasks we care about (e.g., autonomous software engineering given some high inference budget) has actually substantially outpaced 3x effective compute per year in the last 2 years and probably overall algorithmic progress looks more like 4.5x effective compute per year^[5], though I'd be sympathetic to substantially higher estimates. I'd also guess that the pure loss algorithmic progress over the last 2-3 years is somewhat lower than 3x, partially due to focus shifting away from pretraining loss towards focusing on downstream performance through RL and better data (which might improve downstream performance much more than it improves loss). I don't currently have a good sense of the breakdown in recent years between loss improvements and purely downstream improvements, particularly because these might funge, so AI companies might shift focus without this being super obvious. However, it's more confusing to reason about effective compute increases in the regime where pretraining scaling appears to no longer work. I don't have a particularly great estimation methodology here, I'm just taking a best guess by eyeballing the gains from additional compute in the current regime and comparing that to progress that I think is algorithmic. This will be very sensitive to what benchmark mixture you use when assessing the improvements: there have been much larger algorithmic improvements in some domains like solving competition programming problems.

More minimally, I'd say that most progress in the last 2 years is down to algorithmic progress rather than due to scaling up the overall amount of compute used for training. (As in, if you used GPT-4 level compute to train a new AI system with the latest algorithms, it wouldn't be that much worse than current frontier systems like o3.)

Progress has been somewhat bumpy in recent years due to a small paradigm shift to increased RL and reasoning models with more inference compute usage in chain of thought. It's worth keeping in mind that trends might not be super smooth and progress could go much faster (or slower) at times. That said, the resulting performance on METR's horizon length metric looks surprisingly smooth over this period despite the underlying source of performance gains likely shifting some over time. So, we might expect that while new approaches emerge, underlying trends in downstream metrics broadly continue (we see something similar in a bunch of industries, likely due to these approaches and improvements generally averaging out).

An open question here is what fraction of the progress from o1 to o3 was algorithmic progress. My sense is that this question is somewhat a mess to answer as scaling up to o3 probably required building a bunch of additional environments. Should we count work on figuring out strategies for getting AIs to generate environments as algorithmic progress or something else? What about when humans write code for purely programmatically generating the environments? (If generating more environments just involves scaling up inference compute on environment generation it seems reasonably natural to count this under training compute scaling as you can just consider RL environment construction as a particular type of self-play training.) Either way, my sense is that large scale human labor on generating environments or buying data is unnatural to include in the algorithmic progress category as I'll discuss in the data section below.

Given that there was a bunch of algorithmic research on achieving lower loss for pretraining, a natural question is whether this transfers to RL (by helping achieve lower on the RL loss objective faster). My overall sense is that it mostly will transfer, but it's very unclear as the learning regime for RL is quite different.

To get a better sense of what's going on with algorithmic progress, I find it is slightly helpful to break things down into improvements that help with next token prediction loss vs improvements that don't.

Improvements which help with next token prediction loss:

• Architecture
• Hyperparameters
• Quantity of data relative to parameters
• Optimizer
• General training code efficiency and utilization (including using lower floating point precision etc)
• Pretraining data mix (this could help with next token prediction loss, though might yield larger gains on downstream performance)

Basically all types of improvements could in principle help with downstream performance without helping with next token prediction loss. So, I'll discuss the ones which I expect to differentially have this property.

• Pretraining data mix
• Better objective for pretraining (e.g. multi token prediction from deepseek v3)
• Longer context length (and longer effective context length)
• RL improvements (algorithms, RL code efficiency/utilization, environment mixture)
• Inference code (this helps with downstream performance as we care about the cost vs performance Pareto frontier and we can often exchange cost for performance)
• Scaffolding (though my sense is that scaffolding has yielded extremely minimal gains on general purpose autonomous software engineering to date, it might ultimately be important in a regime where AIs are constantly constructing new scaffolds for themselves or for other AIs to improve efficiency)

Data

When I talk about data, I'm including both RL environments and pretraining data, though these might have somewhat different properties. Above I mentioned how data can be unnatural to lump under algorithmic progress. This depends a lot on what the data construction process looks like. In the case where humans are just writing better web scraping or data filtering code, it seems to clearly have similar properties as other algorithmic research. However, if it looks more like a large scale human labor project on building RL environments (rather than writing a smaller amount of code which makes AIs more effectively generate RL environments) or like buying data, then this has properties which are quite different from algorithmic research.

In particular, acquiring data in this way doesn't cleanly scale with effective compute in the same way (it isn't a multiplier on the training compute), you can keep accumulating this data in a capital intensive way (more similar to compute than algorithms), and it doesn't reduce down to a relatively small amount of code or a small number of ideas.

An important open question around data is where the RL environments for models like o3 mostly come from. If these basically come from paying humans to substantially manually make RL environments, then we might expect that RL scaling will slow some due to a human labor bottleneck while if environments are mostly AI generated or programmatically generated in a relatively scalable way then RL scaling can more easily continue.

---

1. Part of the story could be that data filtering and identification has improved over time and as we've identified the higher quality data, training on the marginal tokens has become less valuable as this is no longer getting us a bit more of the high quality data that we were unable to isolate. (This sort of consideration implies that the returns to data filtering aren't scale invariant.) ↩︎

2. My understanding is that GPT-4.5 generates tokens substantially slower than Grok 3; I get around 2x slower in my low effort testing. This would naively imply GPT-4.5 is more than 2x more (active) params, all else equal. ↩︎

3. Source: the graph they briefly showed in the youtube video introducing o3. ↩︎

4. Examples of missing nuance include: some algorithmic improvements aren't scale invariant and help more and more as more training compute is used, algorithmic improvement is at least a bit discrete historically and larger paradigm shifts than what we've seen recently are possible, algorithmic improvements might change frontier effective compute quite differently from improving efficiency at a given level of capability (I think efficiency is initially easier, but probably has lower absolute limits for improvement), and algorithmic improvements are sometimes much larger in some domains than in others (e.g., we've recently seen very large algorithmic improvements in math and competition programming problems that seemingly don't transfer as well to other domains). ↩︎

5. Multiplying this with the trend for 3.5x more training compute per year, you get 16x effective compute per year. ↩︎