Compute Equilibrium

The price of an hour of compute is not set by what it costs to build a data center. It's set by what the least valuable job running in that data center is worth, because that job is the one that walks away first when the price rises.

Say it as a rule: in equilibrium, an hour of compute costs what the marginal AI task can capture. Not what the best task is worth. The best tasks earn far more than they pay, the same way the electricity keeping a hospital running is worth more than the electricity price. The last job in the queue clears the market, and everything above it earns a surplus.

That one line explains most of what looks strange about the compute market right now, and it explains why the debt piling up behind it is a separate problem from whether the technology works.

Why the marginal job sets the price

The mechanism is an arbitrage, and arbitrages are stubborn.

If an hour of compute can be turned into more captured value than it costs, someone buys more of it, and buyers keep arriving until the last one barely breaks even. If an hour costs more than the last job can capture, that job stops, capacity idles, and the price falls until something else is worth doing. Either way the market walks to the same place: price equals the value of the marginal job.

Bitcoin ran this experiment in public. Revenue per hash converges on the cost of hashing regardless of what anyone believes about the coin. The difference with AI is only in enforcement. Bitcoin has a difficulty adjustment. AI has competition between people who own accelerators, which is slower, noisier, and easier to mistake for something else while it's happening.

The convergence shows up in two regimes, and confusing them is where most bad forecasts come from.

When supply is short, price is set by demand. You can't conjure fabs or substations. Silicon takes years, power takes longer. So the price rises to meet whatever the marginal task is worth, and the surplus flows to whoever owns the scarce thing. That is what accelerator margins and premium power contracts have been.

When supply catches up, price falls to cost and the adjustment moves to quantity. With free entry, an hour settles near the cost of producing it: hardware amortized, energy, capital. The equilibrium then holds by expanding usage instead of raising price.

Both regimes have been visible at once, which is why the market reads as contradictory. Rental prices for a given class of accelerator have fallen sharply from their shortage peak while frontier capability still commands a premium. Same rule, two sides: supply arriving on the commodity tier, capability rents surviving only as long as the lead does.

What decides the value of the marginal job

Wages, mostly.

If a task is one people are paid to do, the compute doing it is worth about what the task is worth, adjusted for quality, speed, and how much supervision the output still needs. That gives the theory a floor and a ceiling that aren't guesses. Capability jumps don't move demand smoothly. They release blocks of work in steps, and each step drags a chunk of a wage bill onto the demand curve for compute. Supply answers late, because supply always answers late.

The convergence runs both ways. The price of compute is pulled up toward the wage-equivalent of newly automatable work. The wage of that work is pulled down toward the cost of compute.

Value created and value captured are different quantities, and the equilibrium is about the captured one. Competition on the output side pushes prices toward cost, so most of what gets created leaks to whoever buys the output. What you capture depends on how long your capability lead lasts, how well you're distributed, and how expensive you are to leave. Capability leads decay in months. Distribution and switching costs decay in years.

Where margins sit tells you which constraint is binding. Silicon margins mean silicon is scarce. Power premiums mean power is scarce. Model margins mean capability is scarce. Application margins mean distribution is scarce. The scarcity migrates, and the profits migrate with it.

Advantage has a clock

Read the same rule from the buyer's side and it becomes a much older argument.

Paul Strassmann spent years looking for a correlation between what companies spent on IT and how profitable they were, and kept not finding one. Nicholas Carr's IT Doesn't Matter concluded that once a technology is available to everyone and standardized, it stops being an advantage and becomes infrastructure. Both described an outcome without a mechanism. The equilibrium is the mechanism.

If the price of an input converges on the value the marginal buyer can capture with it, buying that input returns zero in expectation. The value is already in the price. That's why the spend studies found nothing when they measured spending and something when they measured practices, and it's why aggregate AI capex will not correlate with aggregate profit either. When that gets reported as disillusionment, it will only be the price mechanism working.

What Carr couldn't say was when the crossing from advantage to infrastructure happens, or at what price. The equilibrium says both. A capability is an advantage for exactly as long as your competitor can't buy it. So the test is procurement, not sophistication:

Can a competitor buy this, at list price, this quarter, and stand where you're standing? If yes, it's cost of doing business, however advanced it feels. Running frontier models is cost of doing business. Having agents in the workflow is on its way there, and the follower lag on model capability is measured in months, too short to hold a strategy. What isn't purchasable is the state you've accumulated, the loops you've closed and can prove work, and the permission you hold to act inside systems others can't touch.

The narrow version of Carr is the one that holds: the priced input stops mattering, and the unpriced complements matter more than they ever did, because they're the only place return can accumulate. AI sharpens that split rather than settling it. The priced part is deflating faster than any input in industrial history, and state, position, verification, and rights of way are getting scarcer relative to it.

The operational consequence is a rule about time. Cost of doing business has to be cheap, and the way it stops being cheap is by being locked in. Match the length of a commitment to the rate at which the thing deflates. A multi-year contract at shortage prices for something that becomes a utility inside the term is a fixed floor under a falling input, and a durable disadvantage against a competitor who waited.

The loop that overshoots

An equilibrium says where a system settles, not how it gets there, and the path is where the damage happens. The current path is a loop:

Belief in AI funds capacity, increasingly with debt. That capacity arrives into a shortage, so buyers sign long commitments at shortage prices, and the resulting backlog underwrites the next round of borrowing. Meanwhile the capacity that isn't sold isn't idle. It runs internal work, training, evaluation, self-improvement. That work produces visible progress. Visible progress reinforces belief. Belief funds more debt.

Every step is individually rational. The loop still has a problem: the asset is capability, and the debt is serviced out of captured value. The equilibrium says captured value at the margin converges on the cost of compute, so the loop is borrowing against the margin it's competing away.

Two things make it worse than an ordinary build cycle.

Backlog looks like demand and behaves like exposure. A multi-year commitment at shortage prices is a firm number on a page. When supply lands and spot falls under the contracted price, that number becomes concentrated counterparty risk, exactly when the borrowing needs it to be solid. It's also the contract that puts a cost floor under the buyer: the crossing above, happening to both parties at once.

Internal work substitutes for revenue in the story and never in cash. Physical usage stays near full while paid usage doesn't. Depreciation is real, the activity is real and visible, the cash isn't there. Once there's debt against the hardware, internal work is also the option that defers recognizing the loss, because idle capacity is the visible indicator that forces a write-down and a busy cluster isn't. That isn't fraud. It's what the incentives ask for, and it can run a long time.

The loop ends when improvement stops changing what anyone can capture. Not when improvement stops. Those are different dates, and the debt is dated against the first one.

Visible progress and economic progress are not the same measurement

This is where the compute question meets a line we've written about before: what can be checked, and what can't.

Benchmark progress is progress against a scorer. Economic progress is progress at work someone pays for, which means work whose result can be checked well enough that a buyer accepts it. A model can get better at every scorable task in existence while the set of work you can hand it, unsupervised, and get paid for, stops growing, because that set is bounded by verification and not by capability.

When the gap opens, the belief signal keeps rising and the revenue signal doesn't. Unlike a general feeling that valuations are high, the gap is measurable: revenue per deployed accelerator-hour against debt service per deployed accelerator-hour, with the share of internal workload alongside it. If capability is compounding into capture, the first number rises. If it isn't, no benchmark result will save you from the second.

The end of the utilization arbitrage

There's a quieter consequence for everyone building on shared infrastructure.

Cloud economics rest on statistical multiplexing. Sell the peak at a premium, fill the trough with elastic work priced near zero, because an idle cycle had almost no opportunity cost. Spot markets, preemptible instances, per-invocation serverless, burst credits: all products built on the spread between peak and trough.

An AI workload that is elastic, patient, and effectively unbounded reprices every idle cycle. The trough now has a bidder, and the bidder is the operator itself. The spread compresses toward a single price, and anything sold out of the spread loses its basis.

The objection is that this is an accelerator story while cheap elastic products run on ordinary processors. That holds until power and floor space bind instead of silicon. After that every workload class bids for the same watt, and a watt spent on a cheap invocation is a watt not spent on inference. The reservation price transmits through the power budget even where the silicon never touches.

What to look for, some of it already visible: thin discounts on interruptible capacity where they used to be deep, elasticity rationed by quota and negotiation rather than offered as a free option, widening gaps between committed and on-demand pricing, steady workloads moving back onto owned hardware. Providers end up competing with their own customers for their own capacity, which is a different business from renting out slack, and a worse one.

Building for it

None of this is a reason to slow down. It's a reason to be exact about what you're buying.

Price your agents in captured value per unit of compute, not in tokens. Tokens are an input. The number that decides whether your system survives the cycle is what one accepted action costs to produce and what someone pays for it.

Assume elasticity has a price now. Designs that quietly relied on free trough capacity (wide fan-out, speculative work thrown away, retries as a first resort) get repriced whether or not your architecture changes.

Buy the commodity as a commodity. Anything a competitor can purchase this quarter is overhead, bought on price and on short terms. Put the money and the long commitments into what nobody can buy: the state you keep, the loops you can prove close, the access you hold. Spending more on the priced input isn't a strategy, and underspending isn't either. It's a threshold, not an investment.

Spend compute where a check exists, and judgment where none does. Making many attempts against a sound check is what compute is for. Work nothing can score doesn't get cheaper when compute does. There's an old line about DevOps that applies almost unchanged: if you need it and don't hire it, your developers pay for it anyway. Verification is now that job, and the bill arrives as review time, incidents, and defects.

Expect the surplus to arrive. A build cycle that overshoots ends with capacity in the hands of owners who can't exit and have to run it, which means compute below replacement cost for a while. The last time this happened with fiber, the people who inherited the glut built the decade that followed.

Which is the argument in one line. The capital structure is what breaks, the priced input keeps deflating toward cost, and the return moves to whatever the market can't put a price on. The equilibrium stays exactly where it was.