Notes on Implications of Scale-Dependent Algorithms

Forethought research argues that many past algorithmic improvements reducing LLM pretraining loss are "scale-dependent," meaning they deliver larger compute-equivalent gains relative to prior algorithms as training compute grows. The analysis treats this as moderate evidence that attempts to limit algorithmic progress without compute limits will be ineffective, weak evidence that past-based forecasts of algorithmic progress are invalid, and part of a plausible argument for or against a software-only intelligence explosion. The piece distinguishes scale-independent algorithms, which hold a constant compute-equivalent gain across training FLOPs, from scale-dependent ones, and examines pretraining loss, end-to-end task performance, and policy implications.

This article was created by Forethought https://www.forethought.org/about . See all our research on our website https://www.forethought.org/research . Of past algorithmic improvements which decrease LLM pretraining loss, many have been “scale-dependent” – that is, improvements which decrease LLM pretraining loss by more, relative to prior algorithms, at larger quantities of compute. The influence of such scale-dependent algorithms is 1 moderate evidence that attempts to limit algorithmic progress in absence of compute limitations will be ineffective, 2 weak evidence that our inferences about the future scale of algorithmic progress, based on the past, are invalid, and 3 part of a plausible argument either for or against a software intelligence explosion, depending on other details of one’s model. I’ll proceed by discussing the following: 1. How scale-dependent algorithms for pretraining loss probably account for the majority of algorithmic improvements in this domain 2. How scale-dependent algorithms for end-to-end task performance might account for the majority of algorithmic improvements in this domain 3. How scale-dependent algorithms in the past should influence our model of algorithmic improvements in the future 4. Possible policy implications Before starting, a note on method – when discussing questions regarding AI’s past and future progress, there’s a natural continuum from “the intractable, high-impact, abstract question, which we terminally care about” to “the tractable, dubious-impact, concrete question, which we instrumentally care about.” Consider questions about scale-dependent algorithmic improvements, sliding from the former to the latter along such a continuum. - We are most terminally interested in questions about the future: “Will future improvements to AI task performance depend more on compute scale-up or on algorithmic improvements? What can we know about how these two will be causally intertwined? Will future improvements enable a software-only intelligence explosion – that is, in a world with total compute held constant, could algorithmic progress lead to an intelligence takeoff in a comparatively short period of time?” - The data we can gather most relevant to this question is about the past: “Did past improvements to AI task performance depend more on compute scale-up or on algorithmic improvements? Would past AI algorithmic improvement have counterfactually looked slower, without the datacenter buildout?” - And finally we have the narrower sub-question for which we have the most past data, which contributes to answering the broader historical question: “Did past improvements to LLM pretraining loss depend more on compute scale-up or on algorithmic improvements?” I’m going to start by discussing the evidence for this last question, before moving to the increasingly impactful and increasingly difficult earlier questions. Scale-Dependence of Algorithmic Improvements for Pretraining Loss Are the algorithmic improvements that have most decreased pretraining loss for LLMs scale-dependent or scale-independent? What would either of these mean? The compute-equivalent-gain https://arxiv.org/pdf/2312.07413 CEG for some algorithm A’, relative to another algorithm A, is the ratio of the FLOPs needed to train an A-using model to a given level of performance, over the FLOPs needed for an A’-using model to reach that same level. If it takes 3x as much compute to train an LLM with algorithm A to reach the same pretraining loss as another LLM trained with algorithm A’, then A’ has a 3x compute-equivalent gain on pretraining loss relative to A. Given the above notion of CEG, algorithmic improvements that produce some kind of CEG could conceivably be scale independent or scale dependent . A scale-independent algorithm has a constant CEG across different quantities of training FLOPs. So if A’ gives a 2x multiplier relative to A at about 10<sup 15</sup FLOPs, it continues to give a 2x multiplier at about 10<sup 25</sup FLOPs. Correspondingly, if one were somehow able to know antecedently that some algorithm was scale independent, one would just need to test it at one scale to find whatever this constant happened to be. By contrast, a scale-dependent algorithm has a variable CEG, which is a function of the number of FLOPs used in training. So A’ might give a 2x multiplier relative to A at about 10<sup 15</sup FLOPs, but give a radically different 1000x multiplier at about 10<sup 25</sup FLOPs. If one were somehow able to know antecedently that some algorithm was scale dependent, one would know that one needed to test it at many scales to find the function mapping from FLOPs to the compute multiplier. The thesis of 2025’s “ On the Origin of Algorithmic Progress in AI https://arxiv.org/pdf/2511.21622 ” is that the vast majority of apparent algorithmic progress in LLM pretraining loss per-FLOP has come from a handful of scale-dependent algorithms. So, according to the paper, the apparently steady flow of “algorithmic improvements” in the past came from choosing a reference point algorithm A prior to some particular scale-dependent algorithmic improvement A’ , and then mistaking the continued improvements A’ makes over A as compute increases for the presence of additional algorithms, B, C, and so on. In the absence of an increase of FLOPs, this apparent radical increase in performance would not have been nearly as large. What kind of evidence is there that the majority of progress in LLM pretraining loss per-FLOP actually does depend on scale-dependent algorithms? - Well, the paper presents good evidence that scale-dependent algorithms are very important. - LSTM to Transformer Change : “On the Origin” uses experiments to estimate how much the Transformer improves over the LSTM as compute scales up. At ~10<sup 15</sup FLOPs, this comes to about 6x CEG; at ~10<sup 17</sup , it comes to a 28x CEG increase; at the level of compute with which the Transformer was introduced in 2017, they extrapolate it to about a 91x CEG increase. - Kaplan to Chinchilla Change : “On the Origin” grants that Chinchilla scaling is correct, then projects forward the gains you get by switching to Chinchilla from Kaplan; they are approximately equivalent at 10<sup 20</sup , and give a ~10x or more gain at frontier scales. - The paper also presents evidence that scale-independent algorithms are less important than one might imagine. - Their ablations find that scale-independent additions are not multiplicative. That is, doing a bucket of changes that move one from the “retro” Transformer to the modern Transformer in theory should give a CEG of 3.5x, if one were to multiply the gains that the additions make separately; but in practice only gives 1.3x. - The modern transformer similarly does not improve greatly on the “retro” Transformer as you scale up. So “On the Origin” projects that, given the actual historical increase in FLOPs that makes scale-dependent algorithms more efficient, one observes a 21,400x CEG increase from 2017 to 2025. But if one counterfactually holds compute constant at 10^18 FLOPs, this amounts to only a 155x CEG increase. This amounts to the difference between a ~7 month doubling time for algorithmic efficiency very close to Ho et al. 2024 https://epoch.ai/publications/algorithmic-progress-in-language-models ’s 8-month doubling time ; and a ~13 month doubling time of algorithmic efficiency. But note that the second “doubling time” here is specifically relative to the level of compute at which one calculates the increase in algorithmic efficiency; there would be a different doubling time for a different absolute quantity of compute. So there is a very approximate halving of the speed of algorithmic improvement, given that you hold FLOPs fixed at 10<sup 18</sup , once you take into account the difference between scale-dependent and scale-independent algorithms. And of course, this ~13 month doubling time is still fueled almost entirely by the gigantic LSTM to Transformer transition at 10<sup 18</sup FLOPs – leaving this quantity of algorithmic progress out means that the doubling time gets vastly larger. This is a pretty large change to the proposed rate at which constant-FLOP algorithmic improvements occur. But you can actually make a case that “On the Origin” understates the degree to which algorithmic improvements in LLM pretraining loss depend on scale-dependent algorithms. The largest single purportedly scale-independent gain 2x described in the paper belongs to mixture-of-experts MoEs , an alteration to the Transformer architecture. But several subsequent works have shown that the gain from MoEs over dense architectures is actually strongly scale-dependent, and probably larger than 2x. “Towards Greater Leverage: Scaling Laws for Efficient Mixture-of-Experts Language Models” estimates a 7x gain https://arxiv.org/pdf/2507.17702 at 10<sup 22</sup FLOPs. “Scaling Laws for Fine-Grained Mixture-of-Experts” estimates a 20x https://openreview.net/pdf?id=Iizr8qwH7J gain at 10<sup 20</sup FLOPs. In both cases, the size of the CEG relative to a dense model keeps improving with the quantity of FLOPs. Although it’s uncertain which exponent is correct, both papers point toward MoEs being a scale-dependent algorithmic improvement that substantially improves with the quantity of FLOPs. So – to return to the motivating question – most of the algorithmic improvements to LLM pretraining loss, so far, have probably depended on a compute scale-up. Apparent algorithmic progress in pretraining loss would have been much smaller if total compute had been held constant. Scale-Dependence of Algorithmic Improvements for End-to-End Performance No one actually cares about pretraining loss for its own sake, though. “Decreased pretraining loss” is just one way to improve end-to-end performance. There are also post-training innovations https://arxiv.org/pdf/2312.07413 like RLHF https://arxiv.org/abs/1909.08593 or best-of-N that improve task performance. There are also changes to data mixtures https://www.beren.io/2025-08-02-Most-Algorithmic-Progress-is-Data-Progress/ that improve performance. And of course RLVR-over-CoT https://arxiv.org/abs/2501.12948 has probably been by itself responsible for the greatest https://epoch.ai/gradient-updates/quantifying-the-algorithmic-improvement-from-reasoning-models single leap in AI performance of the last few years. How much are algorithmic improvements to end-to-end performance scale-dependent? In particular, how much does RLVR-over-CoT depend on scale-dependent algorithmic improvements? This is deeply uncertain. There’s certainly no work that provides a clean FLOPs-to-CEG function, as in the case of pretraining loss. There are several reasons for thinking that RLVR works extremely poorly or not at all beneath a certain scale, and so is somewhat scale-dependent. You need a certain success rate for reinforcing successes to be viable. Several https://arxiv.org/pdf/2607.12395 works https://arxiv.org/pdf/2501.12948 remark on how RLVR without sufficient scale simply doesn’t teach the required diversity of behaviors, and that RLVR on small models plateaus far lower than RLVR on larger and longer-trained models. So there’s suggestive evidence https://arxiv.org/pdf/2607.16097v1 that at the frontier RLVR is scale-dependent, but nothing conclusive. It would also be difficult to perform an experiment to cleanly determine whether RLVR-over-CoT is scale-dependent for several reasons. For instance, the importance of RL, in general, probably https://arxiv.org/pdf/2509.25123 comes https://arxiv.org/abs/2512.07783 from https://arxiv.org/abs/2501.17161 how it permits at least somewhat out-of-distribution generalization, rather than from how it improves performance on in-distribution tasks. But to my knowledge, there’s no publicly proposed clear way to measure out-of-distribution generalization; so there’s no measure against which one could test how RLVR improves with scale on the matter where it ostensibly has the greatest impact. Similarly, RLVR takes place as the final stage of training, after a large sequence of data-selection, pretraining, and midtraining, which means there are just many more free variables it would be necessary to consider before deciding on an experimental design. Apart from RLVR, there’s some evidence that some apparent scale-independent improvements may scale negatively with FLOPs, and thus provide few or limited gains at the frontier. For instance, the paper https://arxiv.org/pdf/2605.19407 “A Bitter Lesson for Data Filtering” claims that although filtering data improves performance at a small amount of compute, it scales negatively with FLOPs, such that with enough computing power it’s best to do no data filtering at all. I think it’s rather likely that RLVR and other important post-training techniques improve in a strongly scale-dependent way, and some of my analysis below will lean on that belief. I’d be surprised if RLVR doesn’t improve in a somewhat scale-dependent way. But I don’t think there’s any conclusive empirical evidence here, and to the degree I’m wrong, some of my inferences below are less likely to be true. How scale-dependent improvements in the past impact our model of “algorithmic progress” for the future Let’s grant that, in the past, scale-dependent algorithms have been responsible for the majority of algorithmic improvements in both LLM pretraining loss and in end-to-end task performance. What consequences would this have for how we expect algorithmic progress to go in the future? What consequences does this imply about a future where compute is “held constant,” as in the case of a software intelligence explosion? Would it lead us to expect a radical trend break, in either direction? Let’s take the other side by contrast, first – imagine a model of the world where almost all algorithmic improvements are scale independent : improvements are drawn from a pool of possible improvements, and the number and efficacy of the algorithms taken from the pool do not change merely by the fact of compute scaling up. If you operate off this model, then there are some natural consequences. - Algorithmic improvements do not become “more discoverable” as FLOPs scale up. More compute may make it easier to run experiments to find improvements, but scaling up the FLOP count within each experiment does not make finding the right algorithm easier or harder per-experiment. - There could, of course, be other factors that make algorithmic improvements easier or harder to find. One improvement could open up a line of research that leads to other improvements, making it easier; it might decrease the total pool of improvements, making it harder. But the fact of having scaled up FLOPs alone does not make improvements easier or harder to find. - Some particular algorithmic improvement does not become “higher impact,” should its discovery be pushed into the future. If some algorithm X is found today and gives a 3x CEG, it would equally well give a 3x CEG if it were found two years into the future. - Broadly, our actual historical rates of “algorithmic progress” reflect something like the rate at which algorithms are naturally found, in a way indifferent to compute build-out. By contrast, one can model a world where most algorithmic improvements are scale dependent as a world where improvements are drawn from a changing pool of FLOP-specific algorithmic improvements. Pools get “unlocked” as the compute frontier moves past the point where they start to become significant, and the pools grow progressively more explored over time as more and more researchers have access to the compute necessary to explore them. So both “how explored” each pool is, and the consequences of finding an entry from each pool, are always changing. If you operate off this model, then: - Algorithmic improvements become much “more discoverable” as FLOPs scale up; the more FLOPs you use in an experiment, the higher the relative CEG might become, and so the easier the new algorithm will find it to overcome the “well-tuned baseline” algorithm with very well-adjusted hyperparameters. So in addition to letting you run more experiments, additional compute may enhance “research taste.” - Some particular algorithmic improvement might actually become “higher impact,” should its discovery be pushed into the future. If some algorithm X is found today and gives a 3x CEG, it might give a 100x CEG in the future when applied with more FLOPs, if its discovery is delayed. - Broadly, this view implies that “algorithmic progress” depends on past compute scale-ups, and would be much slower without them. Imagine that one is trying to determine how much algorithmic progress is likely in the future, granted that one is in a scenario where total compute is held constant. It’s important to note that switching to a view of algorithmic progress as scale-dependent might move your estimate of the likely rate of algorithmic progress in a constant-compute regime either up or down. The case for moving it down is clear. Switching to a view where scale-dependent improvements are significant could move one’s estimate of algorithmic progress down, because it moves one estimate of past algorithmic progress in a constant-compute regime down. One used to estimate a ~8 month halving time to reach equivalent loss for equal FLOPs; now one estimates a ~13 month halving time; and the future is likely to be like the past, so future FLOP-constant algorithmic progress is likely to be slower. But switching to such a view could move one’s estimate of algorithmic progress up, because it decreases your credence that the future will be like the past in this respect If different algorithms get unlocked at different levels of compute, then potentially some future yet-to-be-unlocked regime of algorithmic improvements might differ enormously from past algorithmic improvements. There’s likely less reason to think that the number or importance of algorithmic improvements available in one prior algorithmic bucket will be equally important as algorithmic improvements in subsequent buckets as compute increases. So if one finds such a picture compelling, then the likelihood one assigns to a SIE could go up. If there is a future compute scale-up to 10<sup 32</sup FLOPs, a SIE taking place then might find many algorithms that were totally unavailable to us in the 10<sup 27</sup regime. Overall, all this remains uncertain. I think various philosophical arguments suggest that there’s a greater diversity of room for algorithmic progress as compute scales up. The human brain is largely a linearly scaled-up https://pubmed.ncbi.nlm.nih.gov/19915731/ primate brain, but individual humans and humans in aggregate can do many calculations no non-human primate can. And there are likely greater gains from organizing 10,000 humans well than from organizing 10 humans well. Possible Policy Implications If a majority of algorithmic improvements to task performance consistently come from scale-dependent algorithms, and are likely to keep doing so in the future, how would this impact policy interventions into AI? There are two notable consequences, which mirror each other: 1 efforts to decrease algorithmic progress, in absence of a training compute scale-up, would be less necessary than previously believed; and 2 efforts to decrease algorithmic progress, in the presence of a training compute scale-up, would be less effective than previously believed. I will discuss them each in turn. First, some policy interventions meant to slow or stop the development of advanced AIs have focused on limiting the size of the largest training runs. In this context, a steady advance of scale-independent algorithmic improvements would have decreased the efficacy of any particular maximum training-run size limitation. For instance “An International Agreement to Prevent the Premature Creation of Artificial Superintelligence” https://arxiv.org/pdf/2511.10783 recommends a maximum training-run size of 10<sup 24</sup , but also notes that the “number of operations used to train an AI to a given capability level drops by 3x each year.” Given this trend, it’s easier to derive the need to prohibit AI algorithmic research, a measure that the paper itself notes may be “controversial and normally a bad idea,” but which it believes to be necessary to avoid the creation of ASI. But if the majority of algorithmic improvements have been scale-dependent, then prior estimates for scale-independent algorithmic improvements are too high; and so prior work gives a less-good reason for thinking that the number of operations used to train an AI to a given capability level drops by 3x every year. So the need to ban and monitor research would be correspondingly decreased; a hard cap on maximum training-run size would be more effective than previously estimated. Second, some proposed policy interventions have focused on scaling up the size of compute while trying to decrease or hold constant algorithmic progress. AI 2040, for instance, proposes continuing to increase the size https://ai-2040.com/supplements/compute-supplement of training runs from 10<sup 26</sup now to 10<sup 32</sup in 2035, while decreasing the rate of algorithmic progress. Overall, if you believe that the majority of important future algorithmic improvements will be scale dependent in the way that the majority of past algorithmic improvements were scale dependent, that should decrease the credence you give to our ability to “not find” these improvements. Why? As mentioned above – as compute scales up, the increasing gains from scale-dependent improvements will make them more obvious. By analogy to a counterfactual world in which the Transformer was never discovered, an incredibly poorly-done, badly-implemented Transformer in 2026 still obviously improves on an LSTM, because even an awful implementation might mean it is only 100x better rather than 1000x better than the LSTM. It’s probably impossible to present the Transformer from being discovered for too long. Similarly, continuing to scale up compute makes scale-dependent algorithms more obvious; it probably decreases the quantity of research taste you need to discern them. The other part of the reason is just because, well, continuing to scale up compute keeps opening up new possible unseen algorithmic buckets that allow improvement; the space of algorithmic improvements will keep growing, different kinds of research taste will find more progress. This article was created by Forethought https://www.forethought.org/about . See all our research on our website https://www.forethought.org/research .