In DC and San Francisco, a fragile consensus is waxing and waning by the week: maybe we should ‘pace’ the frontier of AI development. The idea is popular for good reason: AI is moving very fast. It’s already too fast for our institutions to keep pace today, and might be too fast for its creators to keep pace tomorrow.
To deal with that prospect, a pause on AI was always a fraught idea—halting AI progress and then resuming it in a worse position later on seems like a blunder. But pacing seems different: it means choosing how fast AI development proceeds—go faster if we’re comfortable with security and resilience, slow down if we think that further acceleration would overwhelm our institutions. In effect, we’re ‘flattening the curve’ of AI progress.
The problem with getting pacing done is that no one knows what that means or how it would be operationalised. As long as no one knows what pacing would mean, its political economy will remain confusing: opponents will accuse proponents of things they don’t want, and those in favour will claim benefits that wouldn’t actually manifest. Sometimes for good reason: it’s very easy to say you’d like to ‘pace the frontier’, and much harder to defend one of the many flawed mechanisms to do so.
That needs to change: either we develop operationalisations and enforcement mechanisms today, or policymakers will reach for a flawed version tomorrow. Ultimately, that development will have to include bill text and technical sophistication; hopefully not what you’re reading this blog for. But first, it requires distinguishing between different types of pacing and their respective political economies—which I can at least attempt to offer.
For better or for worse, I think we will try to pace at some point in the near future, as capabilities keep growing and the government tries to reassert its authority. Maybe it’s because progress itself is very fast and policymakers start hearing about recursive self-improvement; maybe it’s because harmful misuse and loss-of-control incidents keep happening. Sooner or later, not just the general notion of AI risks, but specifically the speed of progress will start freaking people out.
When that time comes, I doubt many politicians will be reassured by San Franciscan acrobatics about doing a little bit of RSI, handing off alignment research to AIs, and pacing at just the right time. Similarly, I think they’re past the point where ‘but China’ is a sufficient reason to refrain from unilateral AI policy in America. The lead is large enough, the dynamic is volatile enough, that I think both Congress and the executive branch could be willing to constrain accelerating AI progress very soon, deal with China or not.
They’ll ask if there’s a clever way to pace, and if there isn’t, they’ll go for the blunt way to pace instead: just shut down a lab or two, ban the deployment of new models, allocate all compute to external inference, call in the CEOs and tell them ‘RSI is now banned’. That doesn’t strike me as very sophisticated policy, so by that point, we’d better have figured out what pacing should look like.
Three types of pacing are worth preparing.1 Input limits, where we put fewer resources (like compute) into AI development and thereby slow it down. Safety gates, where we pass safety standards that need to be cleared before further development. And speed limits, where we only allow so much progress to be made at a time. Sustainably pacing means combining all three in sequence.

Why Pace?
We shouldn’t confuse ‘pacing’ with ‘safety legislation’. You can pace the frontier without imposing burdensome substantive safety requirements on the labs. If slower progress lets defenders keep up and diffusion continue, we might get through rapid AI growth with fewer drastic interventions.
You can think that AI models should clear certain safety bars, that rogue agent swarms ought to be stopped, or that we should clamp down on the labs, and still not think the frontier should be paced. Or you could oppose all kinds of substantive safety regulation and still want to pace the frontier, because it gives society and defenders time to react, reducing the need for other interventions.
In that sense, pacing the frontier could turn out to be decent ‘accelerationist’ policy. The techno-optimist’s worst case is a full-on crackdown on AI technology, nearing nationalisation or securitised oversight of who gets to build and access AI. That sort of crackdown is most likely if AI blows past its speed limit far enough that policymakers respond drastically and take the AI ecosystem away from Silicon Valley. Pacing the frontier might keep the industry sufficiently slow that it can avoid the worst-case interventions.
To support pacing is to say we’d like to be able to make AI slower if we want to. The underlying concern is not one specific risk, but that AI systems are developing faster than our ability to deal with them. Iterative deployment becomes much harder if cyberdefenders are still reeling from Mythos when open-source Mythos comes out. Legislation becomes difficult if passing a bill takes longer than a model generation. The ‘continuous’ oversight that some congressional bills imagine works through regular reports, but who knows what can go wrong between two quarterly reports in 2027? Further down the road, technical oversight mechanisms also come apart: if AI systems rapidly build their next generations, it’s hard for human safety experts to really understand what’s happening, or even for embedded evaluators to understand if things are proceeding safely.
As so often, RSI makes things worse. Over the last few weeks, the idea of breakaway AI progress in 2027 has become more popular and credible. The jury’s still out on the strongest version of RSI—what Dean W. Ball calls strong recursion—but San Francisco is taking it very seriously these days.
If strong recursion is possible, there are good reasons to oppose it. But even weak recursion might motivate pacing: AI-assisted research could move faster than our institutions can respond, even without anything resembling an intelligence explosion. At any rate, I think pacing the frontier is, in effect, one practical way to ‘ban strong recursion’: if there is a speed limit enforced on AI progress, it follows that attempting to ‘foom’ gets you in trouble with the highway police.
Supporting pacing really means we might need to go slower to prevent loss of effective control. That is much easier said than done: most ways to get pacing done face practical constraints that make them almost unworkable today.

Input-Limit Pacing
Input-limit approaches pace the frontier by limiting resources needed to advance AI progress. They’re all the rage because they’re easy to measure and easy to agree to. AI progress is a function of the compute we spend on making AI better, so if we just spent less compute on doing that and more on inference and safety, the frontier would get paced.2
Mark Zuckerberg got people excited about this when he suggested Meta might shift more of its compute from R&D to inference (though cynics might note that Meta is generally better at deploying mediocre products than at generating breakthroughs anyway). David Sacks’ recent skepticism of RSI hits a similar accelerationist note: just spend more compute making great products and less compute on a potentially uncontrollable dynamic.
The immediate problem is that these limits seem fairly easy to game. Consider an input-limit regime that limits how much of their compute AI developers get to spend on R&D—namely experiments, training, and internal inference. There would still be many ways for these labs to deploy compute beyond that limit toward capability gains: they can provide inference to external firms that collect and curate data or develop reinforcement learning environments, as with Anthropic and Mercor; or to research units at partnering firms, as with OpenAI and Microsoft. Given a little time, I suspect we’d get an efficient division of labour: labs reserve their R&D compute for work tied closely to their own IP, while vendors using the labs’ external inference supply other breakthroughs.
The deeper problem with input limits is that they mostly buy us time until we get to a steep part of the exponential instead of solving the problem of too-rapid progress. Next to the importance of compute, one other ironclad rule of AI progress seems to be the inevitability of algorithmic efficiency gains: over time, we usually learn to squeeze the same performance out of much less compute. That means, in time, we’ll be back on the same exponential. If algorithmic efficiency kept improving threefold each year despite a 50% cut in R&D compute, and research speed scaled with effective compute, we’d regain the pre-cut pace of research in roughly eight months. We’d still be behind the unpaced path, sure, but we’d fundamentally face the same accelerated dynamic.
Buying that time isn’t pointless, of course. We can develop better monitoring and pursue more suitable alignment research. By the time we reach the same steep exponential again, we’ll be in a better position to deal with it. That’s not nothing, especially if you’re worried about the concrete safety implications of reaching a steeper part of the exponential too soon, before we’ve had time to bolster our institutions. None of that is a definite strike against input-limit pacing.
But it means an input cut is most suited to an immediate stopgap intervention: things start going very fast, everyone scrambles to get a handle on AI, and we reach for an ad hoc input-limit regime until we figure out what the hell is going on. My worry is that we may not get many windows for getting pacing right, and a fixed cut would not hold the pace down for long: in time, you’d expect vendors to find dangerous loopholes, and alogrithmic efficiency puts a cap on the effectiveness of a one-time cut. It’s ultimately not suitable as a long-term approach to deal with a technology with as much autocatalytic potential as AI. Still, maybe kicking the can down the road is enough—many people are sufficiently concerned to be content with a stopgap solution that works fast.
The problem is that, for an immediate stopgap, we don’t know enough about how to pull it off just yet. Labs have highly imperfect accounts of where their compute actually goes; they can usually differentiate at a reasonably high level, but there is no tried-and-tested way to determine what exact percentage is ultimately contributing to capabilities, to communicate these percentages to an external regulator or overseer, and to adjust them as needed. But in a situation where you need a stopgap, these kinds of operational details are what kills you: they lead to infighting between the labs that don’t trust each other’s accounting, cost valuable time to implement that lets political energy dissipate, and so on. If you think input-based approaches are viable and desirable, you need to put in the work to make them instantly deployable well before there’s enough political support.
We should prepare for scenarios where decisionmakers reach for input limits. In terms of operations, input-limit pacing requires solving the many difficulties of measuring compute for research and development. If we are to reach for input limits if and when we realise the need to pace, it would be great if serious compute accounting procedures were already set up by the labs, red-teamed by external evaluators, and understood by the agencies that would supervise them.

Safety-Gate Pacing
The second way to pace is to use safety gates: you can go fast as long as your outputs are safe. This approach paces the frontier as an almost-incidental consequence of making AI systems safer: we set a safety bar, such as passing specified evals or an assessment by a third-party or government evaluator. A developer is only allowed to develop and deploy models that clear this bar. For as long as they can’t, they need to work on safety instead; and so the overall progress is slower, and safety is higher.
As a piece of AI safety policy, safety-gate pacing works very well, almost definitionally: it’s a hard pre-deployment gate for dangerous models. Not only can dangerous models not be released, they can’t even be developed until the safety of their predecessors is established. That of course requires that we know what actually constitutes a safe model, which is a much more laden concept than the input limits discussed above or the speed limits discussed below. Requiring an affirmative safety case for development to proceed means that we have to come up with plausible affirmative safety cases for highly capable models first.
Currently, these safety cases don’t really stand up to scrutiny; so I worry that safety-gate pacing basically attempts to smuggle in an outright pause through the back door by setting impractical safety barriers that won’t be cleared anytime soon. It’s fine if you think that’s prudent; but it’s a drastically more contentious political ask, and we probably shouldn’t taint the politically viable pacing conversation by associating it with a much more blunt range of unilateral pausing ideas. I still think the latter would be misguided.
To make matters worse, as a pacing policy in the long term, these safety gates don’t actually do much. At their worst, they actually increase at least the peak velocity of AI progress: because periods of slowdown are followed by periods of catch-up growth, the times of catch-up growth will be even less controllable than our default pace. That is, in essence, the old AI safety concept of compute and algorithmic overhangs: while safety improvements are made and deployed capabilities plateau, the compute base and the technical ideas keep increasing.

I think whether you endorse safety-gate pacing comes down to why you want to pace: is it because you’re just deeply worried about immediate safety implications, or is it because you have fundamental concerns about exponential trajectories and our ability to oversee them? If your motivation to pace just comes down to hitting the slowdown button because the risks are getting too scary, you might be very happy with safety-gate pacing; but if you want to rein in the exponential itself for principled reasons, you might find it lacking.
In the long run, I think we’re fairly likely to end up in a safety-gate regime; in a way, it would be the most permissive version of pacing because it still allows for going extremely fast. Right now, I think it’s prudent to want to flatten the curve of AI progress. But in the future, with better monitoring, oversight, and institutional capacity, we might be comfortable riding the exponential. In that case, we have no material, substantive reason to continue pacing as long as we’re convinced that systems are safe. Under these conditions, we could let compute allocations and other pacing tools go and instead rely exclusively on safety standards. But I think these conditions are still very far away.

Speed-Limit Pacing
Speed-limit pacing is the simplest form of pacing: it means introducing an upper bound on AI progress. I think there’s some prima facie elegance to that. What we care about here, on a more fundamental level, isn’t really inputs—compute, researchers, whatever—but material AI progress. So maybe our pacing provision should be about material AI progress instead?
Very simply, the way this would work is that AI progress is limited to a certain amount of capability growth per unit of time. For the next few months, you only get to advance (internal) model capabilities to an upper bound of so-and-so-many points on an aggregate capability index; the months after that, you get to add some more. If we feel good about where we are on safety and oversight, we increase the allowance; if we feel bad, we cut it. It’d be fun—like the Fed, press conference and all, with the chair of the (self-)regulatory body announcing the permissible capability rate for the next quarter.
As with all these ideas, there’s a whole separate conversation around implementation and state capacity to be had—but for the sake of exploring the ideal approaches, let’s bracket that for just a moment. Iterative post-training may make this more feasible than it was when development centred on large, discontinuous pretraining runs: it gives us more opportunities to measure progress and intervene before a model blows past the limit.
A speed limit targets the shape of the capability curve by allowing gains to rise from one period to the next while keeping growth below the exponential trajectory. Returning to the initial discussion of why we would pace, I think there’s an elegance to that kind of approach: what we care about is the actual speed of progress, and its implications for oversight and control. So pacing should be about reducing that speed, not about hitting some other, vaguely correlated metric that smuggles in a bunch of other considerations.
Speed-limit pacing has two big problems. The first is a version of the overhang argument: while capability gains are hard-limited, the inputs—algorithmic innovations and compute—keep building. Once free from the constraints of pacing, labs could make rapid progress. That means that going for speed-limit pacing essentially commits us to seeing pacing through: we need to keep the pacing provisions in place, or at least replace them with a safety-gate approach, or we get a period of rapid capability growth in an even more condensed timeframe than our initial exponential. That’s a big risk to take in a chaotic political environment: I expect there’ll be enough political appetite to get a version of pacing done soon, but I’m not so sure it’ll last for very long. There’s a natural push and pull; we might very well rescind the pacing rule again at some point, or let it expire, and then the dry tinder catches fire.
Without embedding into a longer-term setup, speed-limit pacing is dangerous; that means it’s less suitable as a stopgap solution than its alternatives.
The second is that it’s very hard to measure capabilities. If we get the aggregate benchmark even subtly wrong, the approach runs into serious problems: the model seems harmless on the aggregate benchmark, but in fact that’s just because we’ve failed to measure a new threat vector, or because the developers have spoofed the benchmark by making the model cracked at AI research and awful at some random irrelevant elements of the aggregate benchmark. That needs to be prevented. But I feel generally optimistic because I’m not too worried about unknown-unknowns in dangerous capabilities. We have a pretty good sense of what kind of acceleration would be risky: toward automated AI R&D, and toward specific dangerously misusable capabilities in particular. Endless cohorts of AI safety researchers have spent years and years thinking about how to measure these dangerous capabilities. Granted, we haven’t made much progress fixing them, but I think we have a pretty good lay of the land of risks, and would be decent at reflecting them in an adversarially robust benchmark.
This is very difficult, perhaps as difficult as fixing the practical difficulties of the other two approaches. But at least it’s symmetrically difficult. One of my worries with the alternative pacing approaches is that it’s easy for them to favour one lab or the other. Compute allocations in terms of percentages are difficult, because labs with a smaller installed compute base are hit harder. Safety gates are difficult, because safety evals can easily favour one alignment approach over the other. Aggregate capability evals are usually much less biased against one particular lab; barely anyone thinks their own models overperform massively on, for instance, the ECI. That means speed-limit approaches contain much less potential for infighting within industry, which makes semi-voluntary agreements more likely and vociferous political opposition from powerful AI labs less likely.

Preparing Options
Ideally, we’d deploy these pacing ideas sequentially. We’d start with a one-time cut to compute R&D inputs as an immediate way of slowing down a little bit; transition into a speed-limit approach before we’re back on the same exponential; and ultimately relax the speed limit by introducing conditional safety gates once we feel confident in our ability to develop safety cases.
That sequence solves the problems with each pacing approach: we never rely on input-based methods long enough to see them deteriorate or be gamed; we have time to develop a speed-limit approach while the compute cut buys us time; and we end up in a safety-gated world that allows for fast-but-safe AI progress again.
But pacing will be done under imperfect political conditions, and ideal sequences aren’t particularly useful. So how do we retain most of this optimal approach under suboptimal conditions?
The pace of AI progress will soon become a problem for policymakers, and they’ll seek to reassert control. Maybe it’ll be because AI progress manifests in the shape of one or two very concrete and harmful incidents, so the reaction will bias toward safety gates. Maybe it’ll be because lab insiders start freaking out and calling up their administration counterparts, so the reaction will bias toward speed limits and input limits. Either way, the government will want to react.
To do that, they’ll reach for a pacing proposal of some kind. If the proposals are underdeveloped and underoperationalised, they’ll be stuck choosing between bad options. If the proposals hinge on half-baked enforcement mechanisms that favour one lab’s approach over another, industry infighting might derail attempts to pace successfully. If the pacing ideas still have any of the glaring weaknesses described, they’ll be rejected. So it’s on us on the outside to put the pieces in place such that they can choose between good, workable, and fair options.
That means we need to create the operational conditions to do many versions of pacing today. That in turn means we need to accept that the concrete approach will be shaped by political constraints, and consist of letting decisionmakers choose between the best versions of pacing.
Any serious version of pacing, but in particular a combination of approaches, requires payment in advance. For input limits to seem viable, compute accounting is by far the most important precondition. Developers need to have, and be able to share, a sophisticated accounting of where their compute goes; decisionmakers and evaluators must have experience in navigating and verifying this accounting. Speed limits require building adversarially robust capability benchmarks that can’t be gamed to break out of the constraint. And safety gates, for which we hopefully have some more time before we need them, obviously require sophisticated and falsifiable safety cases, but that’s easier said than done.
All of these are very hard to do, but as opposed to pacing itself, they’re somewhat easier to do unilaterally: for motivated policy organisations, for an external evaluation ecosystem, but also for labs in particular.
Lab representatives will tell you they’d love to make more progress on pacing, but their hands are tied: they’re scared of antitrust, and their Claude keeps telling them about something called the Sherman Act. They should rejoice: there’s a concrete agenda of things they can do, unilaterally, just by themselves, to make pacing more likely and more actionable. Set up the compute accounting in case the vote falls on input limits; set up the benchmarks in case we end up in a speed-limit pacing paradigm. And start unilaterally circulating all of these approaches with qualified third parties now, so that we know these metrics are robust, and perhaps even comparable between developers.
Sooner or later, democratic institutions will realise that RSI means that AI might slip out of their control. If they realise it late into the exponential, their reaction will be more violent; if they realise it early, their reaction will have to draw on more incomplete information. They’ll reach for tools accordingly, but either way, react they will—so let’s make sure they can get it right.
Much credit to Joe Carlsmith’s prescient piece from March; many of the technical distinctions are his.
There are many other inputs you could control, such as talent or AI effort, but compute strikes me as both the easiest input to restrict and the most fleshed-out input-based idea.




