Pricing the compute economy.
AI compute became a traded financial asset — cleared GPU-rental futures, exchange-listed reservations, and roughly a trillion dollars of circular vendor financing — faster than anyone built the tools to price it. This is how we value a whole portfolio of compute-capacity contracts, built up in five steps from a single contract to the bound on the risk that neither spreading your bets nor a commodity hedge can remove.
1 — A single contract: commodity + credit
2 — A portfolio: five priced dynamics
3 — Technology: obsolescence & competition
4 — Financial shock: contagion
5 — The result: a good-deal bound
The gap
A contract that is neither a commodity nor a bond
A compute-capacity contract is a promise to deliver rented GPU time in the future — say, a block of H100 hours next quarter — from a named issuer who has to survive to deliver it. That one sentence breaks both standard playbooks. It is not a clean commodity, because the value that changes hands depends entirely on which issuer and whether they are still standing. And it is not debt, because the risk is not an unpaid loan — it is a prepaid good that never gets delivered. Worse, the good melts: each new chip generation marks down everything already deployed.
So the market is incomplete — nothing you can trade replicates the claim, and no textbook arbitrage pins its price. That is the regime where a model has to earn its keep. We build it in five steps.
Step 1 / A single contract
Commodity value, times the odds the issuer delivers
Price one contract as a defaultable claim on a commodity forward. It splits into two branches that most models keep in different departments:
- a commodity branch — what the delivered compute is worth as it obsolesces; and
- a credit branch — the chance the issuer survives to deliver, plus what is recovered if they fail.
Put together, the fair value is the survival-weighted delivery value plus a recovery term. Call it F — the whole single-issuer contract in one line, and the building block the portfolio in Step 2 sums over:
F = S · Gg · e−Γ + Lrec − Lop
S = survival · Gg = the survival-conditional compute forward · e−Γ = the spot–credit coupling (Γ = covariance of the hazard and the log price); it is 1 only if the two were independent — which is exactly what they are not · Lrec = expected recovery · Lop = operating loss
The move that makes compute an asset class of its own is what happens between the branches. A single hardware-obsolescence lifecycle ζ drives both at once — the same cadence that depreciates the good also raises the issuer's default risk, and, through the bankruptcy estate's option to keep or reject the contract, sets the recovery. One clock, three effects:
carry loses value at ηlife(ζ)
bankruptcy intensity λbk = λ0 + βlife·D(ζ)
The same lifecycle ζ loads both lines — fixed in advance from the roadmap, not fit as a free knob — so the hazard and the price move together, which is why Γ ≠ 0 above. The direction is the subtle part, and it splits: on delivery the coupling runs right-way — issuers fail hardest exactly when compute prices are low, the states where little was going to be delivered anyway, so e−Γ > 1 lifts the survival-weighted value above S·Gg. The wrong-way bite lands on recovery, worth least at the very moment default is most likely.
Step 2 / A portfolio
The book is a sum — but its risk is not
The object a desk actually manages is not one contract but a book across many issuers — a weighted sum of single-name values:
Π(t,T) = ∑i wi Fi(t,T)
One portfolio, priced by one closed-form engine — but carrying five distinct dynamics the single-name model treats in isolation or not at all.
Each dynamic enters a different term of the price and pushes in a different direction, so it is the joint distribution — not the marginals — that governs the book. The five:
- Obsolescence — the deployed fleet ages as each new generation ships, lowering both value and survival.
- Competition — a rival architecture can displace the incumbent: a rare tip on locked-in workloads, a steady share-walk on the rest.
- Continuous factors — shared macro and supply moves; the one channel a basket index genuinely hedges.
- Common shocks — one Marshall–Olkin firing defaults a whole tied group at once; a shared external cause (an outage, a ruling, a supplier) sets it off.
- Self-exciting cascade — the same group-default shock, but its firing rate feeds on itself: each failure raises the odds of the next (branching ratio n; band ×1/(1−n)).
Two are on the technology side, three on the credit side — and the last two are one Marshall–Olkin common shock with two firing rates, not separate mechanisms. Four push value down and, unspanned by any tradeable hedge, land in the unhedgeable residual; only continuous market co-movement is hedgeable by a basket index.
Step 3 / Technology
Obsolescence, and the fight to replace the architecture
Compute value melts for two reasons, and they behave nothing alike. The first is obsolescence: within one architecture, the deployed fleet ages as each successor generation ships, on a one-to-three-year cadence. That is a steady, roadmap-pinned depreciation — the melting is predictable.
The second is competition: the whole architecture — today, NVIDIA and its CUDA moat — can be displaced. The two-part depreciation splits exactly this way:
ηg = ηlife + ηarch
ηlife = within-architecture obsolescence (steady) · ηarch = cross-architecture substitution (regime-dependent)
Substitution — the ηarch piece — arrives in two regimes, and a single ratio decides which. Write ρ for how strongly an architecture's gains spill to rivals and γ for the strength of lock-in:
ρ < 2γ → lock-in (a rare tip) | ρ > 2γ → coexistence (a steady walk)
On the contestable training market — where everyone builds on the incumbent stack — lock-in holds: a challenger must clear a high ridge, so migration is a rare, discrete tip, a tail event. On the overall market — training plus the fast-diversifying inference workloads — there is no ridge; share simply erodes, and that slow walk widens the price band even when nothing dramatic happens.
Step 4 / Financial shock
How a tied cluster fails together
On the credit side, one dynamic is benign — continuous factors, the shared macro and supply co-movement that a basket index genuinely hedges. The other two are where the cluster risk lives, and they are why it does not diversify: the issuers are bound to one another.
The first is a common shock: one event — a datacenter outage, a regulatory ruling, a shared supplier — strikes a whole tied group at the same instant. Names that looked independent default together because they share a cause. This is one Marshall–Olkin common shock — a single firing defaults the whole loaded group — and the cascade below is the same shock with a self-exciting firing rate rather than an external trigger.
The second is subtler and more dangerous: a self-exciting cascade. In a circular-financing web, one failure does not just happen — it raises the odds of the next: a shortfall at one node tightens financing on the others, which makes their failure more likely, which tightens financing further. The whole spiral collapses to one number, the branching ratio n — the average count of fresh failures each failure sets off — and that number multiplies the price band:
band multiplier = 1 / (1 − n)
n = knock-on failures per default. In the flagship cluster n ≈ 0.64 already widens the band ×2.8; as buffers erode it climbs to ~0.76 (×4.2) along the projected walk — but stays sub-critical. Reaching n → 1, where the band blows up, takes outright collateral stranding or an architecture tip, not the ordinary walk.
Step 5 / The result
You cannot hedge it away — but you can bound it
Stack the five dynamics and one channel is left with no hedge: the cross-issuer cluster. When the only tradeables are the commodity index and continuous factors, that channel is wholly unhedgeable, and there is no unique price — only a band. The headline result bounds that band. Its half-width is the leftover cluster risk, priced at the good-deal budget left after hedging: of the reward-for-risk ceiling h (a “good-deal” ceiling — no strategy should earn more than that per unit of risk), the tradeable hedges already use up a slice hS, leaving the residual h⊥ = √(h² − hS²) to price the cluster:
band half-width = h⊥ · σcluster · (1 − spanned)
h⊥ = √(h² − hS²), the good-deal ceiling net of the Sharpe the tradeable hedges already span · σcluster = the unhedgeable cluster volatility · spanned = the fraction of it that credit instruments cover
Add credit instruments — single-name CDS, a CDS index, GPU-loan ABS tranches — and the spanned fraction rises, contracting the residual to an explicit cluster-basis floor. We show the bound is sharp — attained, not loose — and that it closes to zero only in the limit where those instruments fully span the cluster and architectures are diversified. Short of that limit, the correlation is redistributed across tranches, never removed.
Seen on one deal / The 2025–26 loop
The whole machine, on the deal everyone is arguing about
NVIDIA takes an equity stake in OpenAI; OpenAI commits to buy compute from Oracle; Oracle buys NVIDIA GPUs to build it. Cash flows chipmaker → lab → cloud → and back. Commentators call it round-tripping. The model calls it a cluster, and prices it — technology, contagion, and the bound, all at once.
Here is the counter-intuitive read. NVIDIA's $100B into OpenAI looks like de-risking — fresh capital should make the payer safer. The model says the opposite: that same capital binds the three names into one self-exciting cascade. Vendor financing does not remove risk; it trades idiosyncratic risk (one firm stumbles) for systematic risk (all three fall together) — and only the systematic kind survives diversification. So the priced value of Oracle's backlog is worth materially less than its face, and the discount deepens as the loop tightens.
vendor financing : trades idiosyncratic risk→ systematic risk
Name-diversification inside the loop buys nothing: the guarantor fails in the same state as the names it guarantees.
The takeaway
What the bound tells a holder to do
Read forward, the good-deal bound is a price. Read backward, it is a playbook — because it names exactly which risk you can shed and which you must hold.
Lay off the commodity leg
Compute-price exposure is the one channel a cleared index genuinely hedges. Use it.
Diversify across independent clusters
Not across names inside one loop — that buys nothing. Across separately-financed clusters and hardware families.
Distrust single-name protection
A guarantor tied into the same loop defaults in the same state. Price it as correlated, not as insurance.
Capital-hold the residual
The irreducible cluster-and-architecture risk is real and priced into the spread. Hold capital against it.
Compute is the asset class that makes all of this concrete and timely — but nothing in the machinery is specific to it. The same construction prices any basket of defaultable claims exposed to common shocks that no traded index spans. It is a framework for a market that arrived before its own tools.