Financing the AI Bailout
The Economic Fallout of Layoffs, Future Compute Contracts, and Extractive Frontier Labs
Frontier labs have signed roughly $1.9 trillion of compute contracts, $1.4 trillion at OpenAI and $518 billion at Anthropic, and both start billing hardest in 2027. Here is a model of the gap between those bills and plausible revenue, who absorbs it, what it does to the profits of the companies footing the bill, what workers and taxpayers would pay twice over, and how companies building on AI can keep their own operations out of the blast radius.
- OpenAI: about a two-in-three chance (66%) of defaulting on its compute contracts by the end of 2030, the point at which it would need a restructuring or a rescue. The risk starts in 2028 (7%) and peaks in 2029 and 2030, at about 30% in each year; 2029 is the most likely year of default. The median unpaid amount is $113 billion. This is the base case: revenue growth near 70% in 2027 that slows each year, and new investor money only while growth stays above 40%.
- Anthropic: about a three-in-eight chance (38%) of defaulting on its compute contracts by 2032, almost all of it concentrated in 2029 (32%), when its payments peak at about $83 billion a year. It would walk away from its cancelable xAI capacity in 56% of paths, typically that same year, and the median unpaid amount is $38 billion.
- If OpenAI’s IPO fails: near-certain default (98%) on its compute contracts by the end of 2029, most likely in 2028 (86%). In this scenario no new investor money arrives after 2026, and OpenAI has to pay its bills from the roughly $150 billion it holds now plus its own revenue. That cash runs out in 2028, the second year of Oracle billing. The median unpaid amount roughly triples, to $328 billion, with a 90th percentile of $442 billion. That is a TARP-sized hole.
- If Anthropic’s IPO fails: about a four-in-five chance (82%) of defaulting on its compute contracts by 2030. The risk starts in 2028 (21%) and reaches 78% by the end of 2029, when payments peak at about $83 billion a year. The median unpaid amount is $33 billion even after it cancels its xAI capacity.
The short version
- Frontier labs have signed about $1.9 trillion of compute contracts: about $1.4 trillion for OpenAI and $518 billion for Anthropic. About 80% of Anthropic’s total, roughly $414 billion, is owed whether or not the capacity gets used. The bills step up sharply in 2027, when Oracle’s $300 billion OpenAI contract starts billing at about $60 billion a year and Anthropic’s $111 billion of Google TPU capacity begins to arrive.
- OpenAI’s current revenue covers about 29 cents of each dollar of its average annual compute commitment. Its own plan shows negative free cash flow every year through 2030, and its cash break-even revenue rises to $409 billion by then.
- Anthropic looks better on paper, but it isn’t safe. Its $65 billion run rate is counted gross, including the share its cloud partners keep. Even that gross figure is below the roughly $68 billion a year it would need to break even on an average year of its contracts, if its costs outside compute look like OpenAI’s. The peak years cost more than the average.
- In my model, OpenAI has about a two-in-three chance of leaving contracted compute unpaid by 2030, with a median shortfall of $113 billion.
- To cover their compute in 2030, the two labs need about $477 billion a year from customers. That is $215 billion from individuals, equal to 853 million people paying $20 a month, and $262 billion from corporations, equal to 10.6% of all software spending worldwide. Customers fall short in 81% of simulated paths, and the median gap is $165 billion in 2030 alone.
- OpenAI’s losses land first on Oracle, which is rated one notch above junk, carries $129.5 billion of debt and holds about $319 billion of OpenAI backlog. From there they spread to GPU clouds, private credit funds and banks. Anthropic’s obligations sit with Broadcom, Google, Amazon, Microsoft and xAI. Broadcom’s $161 billion share is largely non-cancelable equipment leases, and xAI is a direct competitor supplying up to $84.5 billion of Anthropic’s capacity.
- When the labs price to cover their compute, model prices rise 2.35 times at break-even and 3.19 times with a 20% lab margin. Heavy AI users lose a third to two-thirds of their profits, AI-native companies are wiped out, and US companies take a net hit of about $102 billion a year after tax. That squeeze lands on Anthropic’s own customer base, which includes AI-native companies already running at thin or negative margins.
- The claim that companies will pay for AI by cutting staff isn’t holding up. AI-attributed job cuts, net of rehiring, fund only about 28% of the bill, and every 100 jobs cut cost the economy another 15 through lost spending.
- If a rescue comes, the public pays twice. Lost earnings, lost tax receipts and the bailout itself average about $257 billion in the shortfall scenarios.
- Companies can protect themselves now. Open-weight models, run through several hosts or on compute they control, cost a fraction of what closed APIs do and cannot be repriced or withdrawn.
The Full Version
The bill comes due in 2027
OpenAI has told the public it carries about $1.4 trillion of infrastructure commitments over roughly eight years. Anthropic’s IPO prospectus, as reported by Reuters, lists $518 billion more over about ten years:
- $161.2 billion with Broadcom, largely non-cancelable equipment leases
- $111.1 billion with Google for TPU capacity beginning in 2027
- $110 billion with Amazon
- up to $84.5 billion with xAI through 2029
- $31.4 billion with Microsoft
About 80% of Anthropic’s total is payable regardless of usage. These are not options on capacity. They are take-or-pay contracts, and the largest of them back-load their payments. Oracle’s $300 billion OpenAI contract does not start billing in earnest until 2027, when it steps up to roughly $60 billion a year. Anthropic’s Google capacity starts the same year.
Revenue is real and growing fast. OpenAI told investors this month that annualized revenue reached about $50 billion at the end of September and should pass $70 billion by year end. But $1.4 trillion over eight years averages $175 billion a year. Today’s run rate covers about 29 cents of each dollar of average annual commitment. The plan to close that gap rests on revenue compounding at about 77% a year from 2026 to 2030, roughly a tenfold increase in four years from a $36 billion base.
Anthropic’s revenue has grown faster, to $65 billion annualized at the end of July. On paper that covers its average commitment of about $52 billion a year 1.25 times. Three things undercut the comparison.
First, the $65 billion is counted gross, including what cloud partners keep, while OpenAI reports only its own share, so Anthropic’s net revenue is lower than the headline. If its costs outside compute look like OpenAI’s, it needs about $68 billion a year just to break even on an average contract year, which is more than its gross run rate today. And the payment ramp puts the peak years above the average.
Second, its revenue leans on customers who are themselves short of margin. Cursor was reported in mid-2025 to be paying Anthropic about $650 million a year against roughly $500 million of its own revenue. Bessemer puts the fastest-growing AI-native companies near 25% gross margin, many of them below zero. Those are the companies that break first when model prices rise.
Third, Anthropic’s own unit economics are still a forecast. Its gross margin was reported deeply negative in 2024, and its target is 77% by 2028.
Credit markets have started pricing the gap before equity markets have. S&P cut Oracle to BBB-, one notch above junk, on July 9 and named OpenAI as the reason. Oracle’s five-year credit default swaps reached 260 basis points in Morgan Stanley’s October 7 note, up from 57. When the $50 billion figure became public on October 8, Nvidia, Oracle and CoreWeave fell and the Nasdaq 100 lost 1.4% in a day. Anthropic’s largest counterparties have stronger balance sheets, but its biggest single commitment is a block of equipment leases, and a large share of its capacity comes from a competitor.
Washington’s stated position is that there will be no bailout. The White House AI adviser said so in November 2025, after OpenAI’s CFO floated a federal backstop and then retracted it. Sam Altman said the same. I take them at their word and still think the question is unavoidable, because a bailout is not a choice anyone makes in advance. It is what happens when $100 billion-plus of contracted obligations meets a counterparty that cannot pay. The creditors on the other side would be an investment-grade software company, a set of leveraged GPU clouds, private credit funds and the banks that lend to them.
This piece builds the problem from the ground up. It proposes a coverage ratio for compute obligations, calibrates a cash model that reproduces OpenAI’s own reported five-year plan, runs a Monte Carlo over revenue paths with a reflexive funding market, maps where the unpaid obligations land, prices the menu of rescue instruments, measures how much customers would have to spend to close the gap and why they won’t, prices the drag on the profits of the companies that would pay it, totals what workers and taxpayers would pay twice over, and closes with the part most readers can act on: how a company integrating AI can use open-weight models and compute it controls so that none of this becomes its problem. All the code runs as written.
The contract stack
Two labs account for nearly all of the long-dated compute obligations, and their counterparties are concentrated in five or six balance sheets. The table lists the commitments I could tie to a reported source. It is incomplete by construction: chip supply agreements (OpenAI’s arrangements with Nvidia, AMD and Broadcom) overlap the cloud contracts, and the $500 billion Stargate headline contains the Oracle deal, so summing every headline double counts.
The other side of these contracts is where the risk concentrates. Oracle ended fiscal 2026 (June 2025 to May 2026) with $638 billion of remaining performance obligations, roughly half of it OpenAI, against $129.5 billion of debt, $31.3 billion of cash and trailing free cash flow of negative $23.7 billion, according to its June 10 filing. It plans $90 to $95 billion of capital spending in fiscal 2027, and S&P now expects a free cash flow deficit near $42 billion that year. On top of the balance sheet sit about $260 billion of new lease commitments that start between fiscal 2027 and 2029. Those leases are the part Oracle cannot walk away from if its tenant does.
The structures around the hyperscalers spread the exposure further. Meta’s Hyperion campus in Louisiana was financed through a vehicle that is 80% owned by Blue Owl funds, with $27 billion of A+ rated debt anchored by PIMCO. The rating leans on Meta’s 16-year residual value guarantee, and the bonds priced about 225 basis points over Treasuries, roughly double Meta’s own spread. Oracle, according to the Wall Street Journal as cited by Morgan Stanley, may be buying chips through a third party and leasing them back. Each of these is a reasonable piece of project finance. Together they mean the loss from a lab shortfall would not stop at the lab.
A coverage ratio for compute obligations
The organizing idea of this piece is a coverage ratio, borrowed from how lenders look at a borrower’s debt service. A lab that has committed K dollars of compute over T years carries an average annual obligation of K / T. Its coverage ratio is current annual revenue divided by that obligation.
Coverage alone does not tell you whether the lab can pay, because compute is not the only cost. Let o be non-compute operating cost (people, sales, cash compensation, everything that is not chips, power and buildings) as a share of revenue. Free cash flow in year t and the revenue needed to break even on cash are then:
So the coverage a lab needs to stand on its own is κ ≥ 1 / (1 − o). A third quantity matters for anyone buying from these labs. If volume follows the plan but revenue falls short, the price multiple needed to close the gap is π = R* / R. That is the repricing risk a customer carries even if no one defaults.
Worked example. OpenAI’s $1.4 trillion over about eight years gives C̄ ≈ $175 billion. Against a $50 billion annualized run rate, κ ≈ 0.29. With o = 0.24 (calibrated in the next section), the self-funding threshold is 1 / 0.76 ≈ 1.32. OpenAI’s coverage is about a fifth of what it needs, and the rest has to come from investors until revenue catches up.
Anthropic’s figures, on the same arithmetic, give $518 billion over about ten years, so C̄ ≈ $52 billion against $65 billion of annualized revenue reported at the end of July, or κ ≈ 1.25. Two cautions apply. Anthropic counts gross sales through cloud partners while OpenAI books only its net share, so the two ratios are not on the same basis and Anthropic’s is flattered. And averaging hides the ramp: both companies’ payments climb steeply after 2027. Still, the ratio sorts the problem. One lab’s obligations are within sight of its revenue. The other’s are several multiples beyond it, and that is the one whose counterparties carry most of the debt.
The same ratio can be turned on the creditors. Oracle’s OpenAI backlog, roughly $319 billion, is about 2.5 times Oracle’s entire debt stack. For Oracle, κ is the wrong way around: the question is not whether OpenAI’s revenue covers its bill, but whether Oracle’s balance sheet survives if it doesn’t.
The cost balloon
The payment schedule is the problem, not the headline total. Two reported numbers pin it down for OpenAI: about $50 billion of compute spending in 2026, from Greg Brockman’s testimony as tracked by Presenc, and about $856 billion of compute and infrastructure spending from 2026 to 2030 in the five-year plan reported in September. I interpolate a ramp between them of $50, $105, $165, $225 and $311 billion. The same plan has revenue rising from $36 billion in 2026 to $350 billion in 2030.
Those two series plus the cash identity above leave one free parameter, the non-compute cost share o. Setting o = 0.24 makes cumulative free cash flow from 2026 to 2030 come out at negative $278.4 billion. The reported plan says negative $278 billion. So the model is not my opinion of OpenAI’s cost structure; it is the cost structure OpenAI’s own figures imply, and everything that follows changes only the revenue path.
The balloon is visible in the break-even line. Cash break-even revenue R* rises from $66 billion in 2026 to $217 billion in 2028 and $409 billion in 2030. Even the company plan never crosses it: free cash flow is negative every year, bottoming at about negative $80 billion in 2028. Oracle’s contract alone, at roughly $60 billion a year from 2027, is nearly the size of OpenAI’s entire planned 2027 revenue of $64 billion.
The pricing multiple makes the same point from the customer’s side. At plan volumes, π = R* / R is 2.2 in 2027, 1.9 in 2028, 1.5 in 2029 and 1.2 in 2030. A lab that had to self-fund in 2027 would need to charge more than twice what it charges today for the same tokens.
Simulating the gap
In the proposed model, OpenAI has about a two-in-three chance of leaving some contracted compute unpaid by 2030, with a median shortfall near $113 billion. That result depends on two assumptions worth stating before the code: revenue growth slows as the base gets larger, and outside capital keeps arriving only while growth looks spectacular.
The revenue process draws 2027 growth from a normal distribution centered on 70% with a standard deviation of 20 points, which brackets the plan’s 77%. Each later year, growth is multiplied by a decay factor drawn once per path from 0.60 to 0.95. Nobody can observe that decay today, so the uniform range is a stated prior, not an estimate. The funding process is reflexive in the sense Soros used the word: when a year’s growth clears 40%, investors supply $80 billion of new capital; when it doesn’t, the window shuts. The lab enters 2026 with $150 billion of cash and committed funding, roughly the March round plus existing balances. Any year in which cash would go negative, the shortfall is recorded as unpaid obligations and cash is floored at zero.
Proposed model: frontier-lab compute obligations vs revenue, and the unfunded gap.
All inputs in $ billions. Calibrated to reported figures;
import numpy as np
YEARS = np.arange(2026, 2031)
# Proposed compute schedule: 2026 anchored to the ~$50B reported spend,
# cumulative 2026-2030 anchored to the ~$856B in the reported five-year plan.
COMPUTE = np.array([50.0, 105.0, 165.0, 225.0, 311.0])
OPEX_SHARE = 0.24 # non-compute opex share of revenue (calibrated, see text)
R0 = 36.0 # 2026 revenue (internal forecast as reported)
CASH0 = 150.0 # cash on hand plus 2026 raises (assumption)
def plan_path():
g = (350 / 36) ** (1 / 4) - 1
return R0 * (1 + g) ** np.arange(5), g
def fcf(rev, compute=COMPUTE):
return rev * (1 - OPEX_SHARE) - compute
def simulate(n=200_000, seed=7, raise_cap=80.0, growth_gate=0.40):
rng = np.random.default_rng(seed)
g1 = rng.normal(0.70, 0.20, n).clip(0.05, 1.6) # 2027 growth
decay = rng.uniform(0.60, 0.95, n) # growth decays each year
rev = np.empty((n, 5)); rev[:, 0] = R0
g = g1.copy()
for t in range(1, 5):
rev[:, t] = rev[:, t - 1] * (1 + g)
g = g * decay
cash = np.full(n, CASH0)
unpaid = np.zeros(n)
for t in range(5):
growth = rev[:, t] / rev[:, t - 1] - 1 if t else np.full(n, 1.0)
# reflexive funding: markets fund only while growth stays above the gate
new_money = np.where(growth >= growth_gate, raise_cap, 0.0) if t else 0.0
cash = cash + new_money + fcf(rev[:, t], COMPUTE[t])
short = np.where(cash < 0, -cash, 0.0)
unpaid += short
cash = np.maximum(cash, 0.0)
return rev, unpaid
if __name__ == "__main__":
plan, g = plan_path()
f = fcf(plan)
print("plan CAGR", round(g, 4))
for y, r, c, x in zip(YEARS, plan, COMPUTE, f):
print(y, round(r, 1), c, round(x, 1), "breakeven R*", round(c / (1 - OPEX_SHARE), 1))
print("cumulative plan FCF", round(f.sum(), 1))
rev, unpaid = simulate()
print("median 2030 revenue", round(np.median(rev[:, 4]), 1))
print("P(2030 rev >= 350)", round((rev[:, 4] >= 350).mean(), 3))
print("P(unpaid > 0)", round((unpaid > 0).mean(), 3))
q = np.percentile(unpaid, [50, 75, 90, 95])
print("unpaid pct 50/75/90/95", np.round(q, 1))
print("mean unpaid", round(unpaid.mean(), 1), "mean | unpaid>0", round(unpaid[unpaid > 0].mean(), 1))Run as written, the plan path clears without a shortfall: constant 77% growth keeps the funding window open every year, and $150 billion plus four $80 billion raises covers the $278 billion cumulative deficit. The simulated paths are a different story. Median 2030 revenue is $174 billion, and only 6.1% of paths reach the plan’s $350 billion. In 66.4% of paths some obligation goes unpaid. The median unpaid amount is $113 billion, the 75th percentile $233 billion and the 90th percentile $364 billion. Conditional on any shortfall, the average is $221 billion.
The two funding assumptions drive most of the variance, so here is how the probability of a shortfall and its median move when they change.
The table is the honest summary of the model. If capital markets will fund $120 billion a year to a company growing 30%, a default is less likely than not. If investors want 40% growth before writing $80 billion checks, a shortfall is the base case. The decisive variable is not revenue alone. It is the willingness of outside money to keep paying the gap between revenue and contracts, and the March round, the $30 billion now being raised and an IPO pushed to 2027 are all bets on that willingness.
Anthropic’s version of the problem
Anthropic’s contracts are smaller than OpenAI’s relative to its revenue, but the same squeeze reaches it. Its payments jump more than fivefold in 2027, its revenue is counted gross and concentrated in a few customers, and the customers it depends on are the ones the profit drag hits first. Run through the same demand model as the rest of this article, Anthropic leaves contracted compute unpaid by 2032 in about 38% of simulated paths and walks away from its cancelable xAI capacity in 56%. When it falls short, the median unpaid amount is $38 billion.
What the prospectus shows
Reuters’ account of Anthropic’s leaked IPO prospectus gives the base. Revenue in 2025 was nearly $4.6 billion, up twelvefold, against an operating loss of $8.06 billion and $7.33 billion of compute and infrastructure expense. The reported $42 billion net loss is mostly a non-cash charge of about $34 billion on financing that could convert to shares. Cash and short-term investments stood at $20.28 billion at the end of 2025. In May, Anthropic raised a $65 billion Series H at a $965 billion post-money valuation, and its IPO, aimed above $2 trillion, may slip past the November midterms. Second-quarter 2026 revenue was $11.5 billion, and the annualized figure reached $65 billion gross at the end of July.
The risk disclosures are where the contract problem shows. Two customers accounted for nearly a quarter of 2025 revenue, and many of the largest customers have no long-term contracts. The $518 billion of commitments runs about a decade, and about 80% of it cannot be canceled. The exception is xAI’s up to $84.5 billion, reported as mostly cancelable on 90 days’ notice, which is Anthropic’s only real flexibility. Broadcom will lend Anthropic up to $42 billion to lease chips, and Amazon and Google are both investors and its main cloud suppliers. The suppliers are financing the purchases made from themselves.
The 2027 cliff
The prospectus reports totals, not schedules, so I spread each contract evenly across an assumed window: Broadcom from 2027 to 2033, Google 2027 to 2034, Amazon 2026 to 2035, xAI 2027 to 2029, Microsoft 2026 to 2033, and the remaining $19.8 billion from 2027 to 2033. Payments run about $15 billion in 2026, jump to $83 billion a year from 2027 through 2029, and settle near $55 billion once the xAI capacity ends.
Because Anthropic reports revenue gross, the break-even test has to account for the share that cloud partners keep. If Anthropic keeps a share ν of gross revenue:
Worked example. With ν = 0.85 (an assumption; the share is not disclosed) and the same o = 0.24 used for OpenAI, Anthropic needs $128 billion of gross revenue a year from 2027 through 2029. That is double the July run rate and 2.6 times an estimated $50 billion of 2026 revenue. If revenue froze at today’s $65 billion, Anthropic would run out of cash in 2029 even after canceling $20 billion of xAI capacity, and would leave $38 billion unpaid by 2032. At a steady $80 billion it barely survives.
Simulating Anthropic without rosy revenue
The base case assumes no growth rate of its own. About 85% of Anthropic’s revenue is corporate, so it inherits the corporate path from the demand model:
- token volume grows 50% to 180% a year, with 100% most likely
- revenue per token falls 25% to 55% a year
- open-weight models take 5% to 30% of workloads by 2030
- AI budgets are cut 5% to 25% by 2030, as layoffs squeeze customers’ profits and the consumer demand those customers sell into
The consumer 15% follows the consumer AI pool. Each path also carries a 30% chance of losing a top customer worth 10% to 25% of revenue.
Cash works as it does in the OpenAI model. Anthropic starts with $85 billion, its 2025 cash plus the Series H. It raises $80 billion a year only while growth stays at or above 40%, and it keeps 75% to 95% of gross revenue. When cash runs short, it cancels xAI capacity first.
The model adds one more mechanism: extractive pricing. When cash will not cover next year’s firm bills, Anthropic raises API prices by π = 1.5. With open weights available, customers respond with a price elasticity ε between 0.7 and 1.4:
A price increase raises revenue only if ε is below 1. Above 1, customers cut usage or leave by more than the price rises.
The results are bleak:
- Median growth in 2027 is 18%. Median gross revenue is $59 billion in 2027 and $84 billion in 2029, below break-even in every year until 2030.
- In 82% of paths Anthropic hits a cash squeeze that forces a price increase.
- Contracted compute goes unpaid in 37.6% of paths. The median shortfall when it happens is $38 billion, and the 90th percentile is $73 billion.
- Where customers are price-sensitive (ε above 1), the odds of a shortfall rise to 51%.
- Without the price increase, the overall odds are 36.2%. Extracting more from customers who are themselves cutting staff makes the problem worse, not better.
The table shows what Anthropic’s valuation is betting on. Keeping the odds of a shortfall near 15% takes 2027 growth averaging about 50%, sustained from a $50 billion base. That is the growth the demand model says customers squeezed by layoffs, lost consumer demand and rising API fees will not fund.
The two labs also draw on the same customers. The demand model’s median for total customer spending reaching both labs in 2030 is $313 billion. Every dollar Anthropic wins is a dollar OpenAI does not, so Anthropic’s best escape route runs through OpenAI’s shortfall and Oracle’s balance sheet. The system-wide gap does not shrink when one lab wins. It moves.
Proposed model: Anthropic's compute obligations vs revenue, 2026 to 2032.
All figures in $ billions. Counterparty totals are from Anthropic's prospectus as reported by
Reuters; the year-by-year spread of each contract is an assumption stated in the article."""
import numpy as np
YEARS = np.arange(2026, 2033)
OPEX_SHARE = 0.24 # non-compute cost share, same calibration as the OpenAI model
CASH0 = 85.0 # $20.3B cash at end-2025 plus the $65B Series H (assumption)
R0 = 50.0 # 2026 gross revenue (assumption from Q2 $11.5B and $65B run rate)
KEEP = 0.85 # share of gross revenue kept after cloud partners (assumption)
# (total, first year, last year, cancelable) per counterparty; windows are assumptions
CONTRACTS = {
"Broadcom": (161.2, 2027, 2033, False),
"Google": (111.1, 2027, 2034, False),
"Amazon": (110.0, 2026, 2035, False),
"xAI": (84.5, 2027, 2029, True), # reported mostly cancelable on 90 days' notice
"Microsoft": (31.4, 2026, 2033, False),
"Other": (19.8, 2027, 2033, False),
}
def schedule():
"""Straight-line each contract over its window; return firm and cancelable payments."""
firm, cancel = np.zeros(len(YEARS)), np.zeros(len(YEARS))
for total, y0, y1, cancelable in CONTRACTS.values():
per_year = total / (y1 - y0 + 1)
mask = (YEARS >= y0) & (YEARS <= y1)
(cancel if cancelable else firm)[mask] += per_year
return firm, cancel
def breakeven_gross(keep=KEEP):
firm, cancel = schedule()
return (firm + cancel) / (keep * (1 - OPEX_SHARE))
def run_cash(rev, keep, raise_cap=80.0, growth_gate=0.40):
"""Pay firm contracts first, cancel xAI capacity when cash runs short, record the rest."""
firm, cancel = schedule()
n, T = rev.shape
cash, unpaid, cancelled = np.full(n, CASH0), np.zeros(n), np.zeros(n)
for t in range(T):
growth = rev[:, t] / rev[:, t - 1] - 1 if t else np.full(n, 1.0)
new_money = np.where(growth >= growth_gate, raise_cap, 0.0) if t else 0.0
cash = cash + new_money + rev[:, t] * keep * (1 - OPEX_SHARE) - firm[t]
pay_cancel = np.minimum(np.maximum(cash, 0.0), cancel[t])
cancelled += cancel[t] - pay_cancel
cash = cash - pay_cancel
unpaid += np.where(cash < 0, -cash, 0.0)
cash = np.maximum(cash, 0.0)
return unpaid, cancelled
def simulate(growth_mean=0.80, n=200_000, seed=13):
"""Stress grid: a plain growth prior, used only for the growth table."""
rng = np.random.default_rng(seed)
T = len(YEARS)
g = rng.normal(growth_mean, 0.25, n).clip(-0.2, 2.0) # 2027 gross revenue growth
decay = rng.uniform(0.55, 0.90, n) # growth decays each year
keep = rng.uniform(0.75, 0.95, n) # share of gross revenue kept
shock_year = np.where(rng.random(n) < 0.30, rng.integers(1, T, n), -1)
shock_size = rng.uniform(0.10, 0.25, n) # loss of a top customer
rev = np.empty((n, T)); rev[:, 0] = R0
for t in range(1, T):
rev[:, t] = rev[:, t - 1] * (1 + g) * np.where(shock_year == t, 1 - shock_size, 1.0)
g = g * decay
unpaid, cancelled = run_cash(rev, keep)
return rev, unpaid, cancelled
def simulate_demand_linked(n=200_000, seed=17, corp_share=0.85, reprice=1.5, raise_cap=80.0,
growth_gate=0.40):
"""Base case: revenue follows the article's demand model, not a growth prior.
Corporate revenue grows with token volume, shrinks with price per token and with work lost
to open weights, and is cut further as layoffs squeeze customers' profits and their own
consumer demand. When cash runs short the lab raises API prices by `reprice`; customers
respond with elasticity eps, so the increase lifts revenue only if eps < 1."""
rng = np.random.default_rng(seed)
firm, cancel = schedule()
T = len(YEARS)
g_vol = rng.triangular(0.50, 1.00, 1.80, n) # corporate token volume growth
d = rng.uniform(0.25, 0.55, n) # revenue per token decline a year
m = rng.uniform(0.70, 0.95, n) # closed share kept by 2030
squeeze = rng.uniform(0.05, 0.25, n) # AI budget cut by 2030: profit hit + lost demand
g_pool = rng.triangular(0.15, 0.40, 0.90, n) # consumer AI pool growth
eps = rng.uniform(0.7, 1.4, n) # price elasticity with open weights available
keep = rng.uniform(0.75, 0.95, n)
shock_year = np.where(rng.random(n) < 0.30, rng.integers(1, T, n), -1)
shock_size = rng.uniform(0.10, 0.25, n)
corp_idx = cons_idx = shock = price = np.ones(n)
rev = np.empty((n, T))
cash, unpaid, cancelled = np.full(n, CASH0), np.zeros(n), np.zeros(n)
repriced = np.zeros(n, dtype=bool)
for t in range(T):
fade = 0.5 ** max(t - 4, 0) # after 2030, excess growth halves each year
phase = min(t / 4, 1.0) # substitution and squeeze phase in by 2030
if t:
corp_idx = corp_idx * (1 + ((1 + g_vol) * (1 - d) - 1) * fade)
cons_idx = cons_idx * (1 + g_pool * fade)
shock = shock * np.where(shock_year == t, 1 - shock_size, 1.0)
corp = R0 * corp_share * corp_idx * (1 - (1 - m) * phase) * (1 - squeeze * phase)
cons = R0 * (1 - corp_share) * cons_idx
rev[:, t] = (corp + cons) * shock * price ** (1 - eps)
growth = rev[:, t] / rev[:, t - 1] - 1 if t else np.full(n, 1.0)
new_money = np.where(growth >= growth_gate, raise_cap, 0.0) if t else 0.0
cash = cash + new_money + rev[:, t] * keep * (1 - OPEX_SHARE) - firm[t]
pay_cancel = np.minimum(np.maximum(cash, 0.0), cancel[t])
cancelled += cancel[t] - pay_cancel
cash = cash - pay_cancel
short = cash < 0
unpaid += np.where(short, -cash, 0.0)
cash = np.maximum(cash, 0.0)
# a lab that could not cover this year's bills raises prices once for the years ahead
hike = (short | (cash < firm[min(t + 1, T - 1)])) & ~repriced
price = np.where(hike, price * reprice, price)
repriced |= hike
return rev, unpaid, cancelled, repriced, eps
if __name__ == "__main__":
firm, cancel = schedule()
for y, f, c, b in zip(YEARS, firm, cancel, breakeven_gross()):
print(y, f"firm {f:.1f} cancelable {c:.1f} break-even gross revenue {b:.1f}")
for flat in (65.0, 80.0):
rev = np.array([[R0] + [flat] * (len(YEARS) - 1)])
u, c = run_cash(rev, np.array([KEEP]), raise_cap=0.0)
print(f"revenue flat at {flat:.0f}: unpaid {u[0]:.1f}, xAI cancelled {c[0]:.1f}")
rev, u, c, rp, eps = simulate_demand_linked()
hit = u[u > 0]
print(f"BASE demand-linked: P(unpaid) {(u > 0).mean():.1%}, median unpaid if any {np.median(hit):.1f}, "
f"p90 unpaid {np.percentile(u, 90):.1f}, P(cancel xAI) {(c > 0).mean():.1%}")
print(" median gross revenue", np.round(np.median(rev, axis=0), 1))
print(" median 2027 growth", round(float(np.median(rev[:, 1] / rev[:, 0] - 1)), 3))
print(f" repriced {rp.mean():.1%}; P(unpaid | repriced, eps>1) {(u[rp & (eps > 1)] > 0).mean():.1%}")
r0, u0, c0, _, _ = simulate_demand_linked(reprice=1.0)
print(f" without repricing: P(unpaid) {(u0 > 0).mean():.1%}")
for gm in (0.80, 0.50, 0.30, 0.15, 0.0):
rev, u, c = simulate(gm)
hit = u[u > 0]
print(f"2027 growth {gm:.0%}: P(unpaid) {(u > 0).mean():.1%}, "
f"median unpaid if any {np.median(hit) if hit.size else 0:.1f}, "
f"P(cancel xAI) {(c > 0).mean():.1%}, median 2030 revenue {np.median(rev[:, 4]):.1f}")If Anthropic does fall short, the loss lands on stronger balance sheets than OpenAI’s: Google, Amazon, Microsoft and Broadcom. It also lands on companies that are Anthropic’s shareholders and lenders as well as its suppliers. A shortfall there would not need a federal rescue to hurt. It would arrive as write-downs at the same companies carrying the hyperscaler capital spending described earlier.
Where the losses land
An unpaid compute bill is not a loss of the same size. The counterparty still owns the data center and the chips and can rent them to someone else. If it re-leases at a fraction ρ of the original contract price, the loss is the unpaid amount U times one minus that fraction.
Applied to the simulated distribution, a recovery of ρ = 0.5 gives a median loss of $56 billion and a 90th percentile of $182 billion. At ρ = 0.3 the figures are $79 billion and $255 billion; at ρ = 0.7 they are $34 billion and $109 billion.
The recovery rate is the variable to watch, and today it looks healthy. The median on-demand H100 rents for $3.51 an hour across 40 providers, up 18% over the past year, which says capacity is scarce. The trouble is that recovery and default are correlated. The scenario in which OpenAI misses its revenue path is the scenario in which demand for frontier inference disappointed, and that is when rental prices fall. Credit analysts call this wrong-way risk: the collateral loses value at the moment you need it.
Oracle sits at the center of the map because its exposure is large relative to its own balance sheet. If Oracle carried half of a median $56 billion loss, in line with its half share of the backlog, that $28 billion would consume nearly all of its $31.3 billion of cash, arrive while it is already running a free cash flow deficit, and would land on a company rated one notch above junk. A downgrade to high yield would push $129.5 billion of bonds out of portfolios whose mandates require investment grade. Microsoft and Amazon would take the hit to earnings and move on. The GPU clouds and the private vehicles that bought chips to lease back are a different case: their equity cushions are thin and their only collateral is the capacity nobody is paying for. Behind them are the banks and private credit funds; one projection cited by the Open Markets Institute has about $800 billion of new private credit flowing to AI data centers over three years.
This is the path by which a private company’s revenue miss becomes a public question. No one bails out a lab. Governments step in when a forced seller of investment-grade bonds, a run on private credit funds and the idle capacity of a strategic industry all arrive in the same quarter.
Financing the bailout
If the median shortfall arrives and Washington decides to act, the expected net cost to taxpayers in this model is about $71 billion, with a 90th percentile near $230 billion. The cost depends far more on the instrument chosen than on the size of the hole.
A proposed formula for the net fiscal cost of a rescue: the government covers a share s of the unpaid obligations U, recovers a fraction ρ by re-leasing or reselling the capacity, pays interest at rate r on its outlay for τ years until recovery, and keeps any upside Π from equity it took in exchange.
Worked example. Full coverage (s = 1) of the median U = $113 billion, recovery ρ = 0.5, a 4.4% Treasury yield (roughly where the 10-year stood at the end of June), three years to recovery and no equity upside: $56.4 billion of loss plus $14.9 billion of interest carry, or $71.3 billion. Across the simulated distribution the median is $71 billion and the 90th percentile $230 billion. At ρ = 0.3 those become $94 billion and $303 billion. Interest carry on the outlay runs about $5 billion a year in the median case and $16 billion at the 90th percentile.
For scale, the Troubled Asset Relief Program disbursed about $444 billion and, by the Congressional Budget Office’s final accounting in April 2024, cost $31 billion net, because the government took equity and warrants and held them through the recovery. The 90th percentile unpaid amount here, $364 billion, is about 82% of TARP’s disbursement. The lesson of 2008 to 2010 is that the gross number makes the headline and the instrument decides the bill.
The financing question splits into who fronts the money and who ends up paying. Fronting is easy: Treasury issues debt, as it did for TARP, or the Federal Reserve lends against collateral under its emergency authority. Paying is the policy choice. Three options deserve more attention than they get.
The first is to make the industry pre-fund its own resolution, the way banks fund the FDIC’s insurance fund and paid a special assessment after the 2023 bank failures. A proposed levy: the mean net cost at ρ = 0.5 is about $93 billion, and the two labs’ contracts total about $1.9 trillion, so a charge of roughly 4.8% of contract value, or about 1% a year over five years, would pre-fund the expected case. That is small enough to absorb and large enough to make counterparties price the risk.
The second is to take equity at distressed prices whenever public money goes in, so taxpayers own the recovery. The 2025 conversion of CHIPS Act grants into a roughly 10% federal stake in Intel shows the current administration will take equity in a strategic company, which makes this route politically live in a way it was not five years ago.
The third is to buy the capacity rather than the companies. If the data centers are strategic, the government can acquire stranded compute at market prices for agencies, national laboratories and research, and let the equity holders and lenders who priced the risk take their losses. This is the closest thing to a clean answer to the Open Markets Institute’s argument that the right policy is to let failing companies fail and rescue the real economy instead.
Nationalization in the full sense, the state owning a frontier lab, sits at the end of this menu. It becomes plausible only if two conditions hold together: a lab’s failure would leave the United States without a competitive frontier model, and open-weight alternatives from abroad are good enough that policymakers see a strategic gap. The second condition is closer to true than it was a year ago, which is the subject of the next section.
Where the revenue argument breaks
The bull case for these contracts rests on one claim: that today’s revenue run rate is the early part of a curve that keeps compounding. I don’t think it is. To cover their compute by 2030, OpenAI and Anthropic together need about $477 billion a year of cash revenue, roughly $215 billion of it from individuals and $262 billion from corporations. In the demand model below, that money shows up in about one path in five, and the median shortfall is $165 billion in 2030 alone.
The argument comes in three parts: the run rate overstates durable revenue, the price of what the labs sell is collapsing, and the wallets that would have to fund the gap are a fraction of the size required.
The run rate is not a revenue line
An annualized run rate is one month multiplied by twelve. It counts pilots, prepaid commitments and promotional usage at full value, and it can be reported gross or net. The difference is not academic: an earlier $68 billion figure for OpenAI turned out to be gross partner revenue rather than OpenAI’s own share, according to CNBC, and Anthropic still reports its $65 billion figure gross. Recognized revenue tells a slower story. OpenAI booked about $5.7 billion in the first quarter of 2026 and $6.7 billion in the second, $12.4 billion for the half, against a full-year plan of $36 billion. The plan needs $23.6 billion in the second half, nearly double the first.
The corporate half of the run rate also sits on uncertain returns. MIT’s Project NANDA studied more than 300 public deployments and found about 95% of organizations reporting no measurable business return on $30 to $40 billion of generative AI spending. Spending without returns survives one budget cycle as experimentation. It does not survive five as a line item that has to grow about 34% a year to reach the corporate requirement below.
Price deflation turns revenue growth into a volume problem
Revenue is volume times price. If revenue must grow at rate g_R while the revenue earned per unit of usage falls at rate d, volume must grow at:
The price side is not hypothetical. Epoch AI measured the price of reaching a fixed level of model capability falling between 9 and 900 times per year, depending on the benchmark. The cheapest capable open-weight models now sell output tokens at roughly 1/150th of GPT-5.5’s price, and enterprises expect open weights to carry 41% of their token usage within a year, up from 34%. Frontier list prices have held, but workloads migrate down the price ladder as cheaper models become good enough.
Worked example. The plan needs revenue growth of about 77% a year. If revenue per token falls only 40% a year, far slower than Epoch’s measured declines, volume must grow (1.77 / 0.60) − 1 ≈ 194% a year. That is usage nearly tripling every year for four consecutive years, on top of a base that already includes most of the world’s early adopters.
The wallets are too small
The requirement follows from the cost model. Each lab’s cash break-even revenue is its compute obligation divided by (1 − o). Split it by the share σ_j of each lab’s revenue that comes from individuals:
For OpenAI, R* in 2030 is $409.2 billion and enterprise revenue has passed half of the total, so I set σ = 0.5. For Anthropic I use its average annual obligation, $51.8 billion, for R* = $68.2 billion, and σ = 0.15 because its revenue is mostly corporate. That gives X = $477.4 billion, X_ind = $214.8 billion and X_corp = $262.5 billion.
Start with individuals. OpenAI’s consumer requirement alone is $204.6 billion a year. At $20 a month, that is 853 million paying subscribers, about 95% of the roughly 900 million weekly users OpenAI reported in February, when about 50 million paid. All consumer AI spending worldwide, on every product, is about $40 billion this year according to Menlo Ventures. Even if the two labs captured 60% of that pool, it would have to compound at 73% a year through 2030 to cover their consumer requirement.
Now corporations. Gartner puts worldwide software spending at $1.43 trillion in 2026, growing 14.7%. If that growth held to 2030, the corporate requirement would be 10.6% of all software spending on Earth, paid to two model vendors. For scale, all enterprise generative AI spending in 2025 was $37 billion, and foundation model APIs were $12.5 billion of it. Bain reached the same conclusion from the industry side in 2025: AI compute demand needs about $2 trillion of annual revenue by 2030, and even counting the savings AI produces, the world comes up about $800 billion short.
Simulating the demand side
The supply side of the model projects what individuals and corporations are likely to pay the two labs in 2030:
W_0 is this year’s $40 billion consumer pool, growing at g_w, of which the labs capture share s. E_0 is corporate spending reaching the labs today, which I put at $80 billion (roughly half of OpenAI’s $50 billion run rate plus most of Anthropic’s), growing in token volume at g_q while revenue per token falls at d, and keeping a share m of workloads that would otherwise move to open weights. A is advertising revenue, a corporate dollar paid to reach individuals. G is the gap that must be filled by someone other than customers.
The priors are deliberately generous to the labs. Consumer pool growth is triangular from 15% to 90% a year with a mode of 40%; the labs’ share is 45% to 75%. Corporate volume growth is triangular from 50% to 180% with a mode of 100%, revenue per token falls 25% to 55% a year, the closed-model share retained is 70% to 95%, and advertising reaches $10 to $40 billion by 2030.
Proposed model: who would have to pay for frontier-lab break-even by 2030, and will they.
All figures in $ billions a year. Sources and assumptions are stated in the article.
import numpy as np
OPEX_SHARE = 0.24 # calibrated non-compute cost share (see cost model)
REQ_OPENAI = 311.0 / (1 - OPEX_SHARE) # 2030 cash break-even revenue, OpenAI
REQ_ANTHROPIC = 51.8 / (1 - OPEX_SHARE) # average annual obligation, Anthropic
CONSUMER_SHARE = {"openai": 0.50, "anthropic": 0.15} # share of revenue from individuals
CONSUMER_POOL_2026 = 40.0 # global consumer AI spending, all products
CORP_TO_LABS_2026 = 80.0 # corporate spend reaching the two labs (assumption)
SOFTWARE_2026, SOFTWARE_G = 1433.6, 0.147 # worldwide software spending and growth
def requirement():
req = REQ_OPENAI + REQ_ANTHROPIC
individuals = (REQ_OPENAI * CONSUMER_SHARE["openai"]
+ REQ_ANTHROPIC * CONSUMER_SHARE["anthropic"])
return req, individuals, req - individuals
def required_volume_growth(rev_growth, price_decline):
"""Revenue = volume x price, so volume must grow by (1 + g_R) / (1 - d) - 1."""
return (1 + rev_growth) / (1 - price_decline) - 1
def simulate(n=200_000, seed=11):
rng = np.random.default_rng(seed)
g_pool = rng.triangular(0.15, 0.40, 0.90, n) # consumer AI pool growth a year
s_lab = rng.uniform(0.45, 0.75, n) # two labs' share of that pool
g_vol = rng.triangular(0.50, 1.00, 1.80, n) # corporate token volume growth
d = rng.uniform(0.25, 0.55, n) # revenue per token decline a year
m = rng.uniform(0.70, 0.95, n) # closed share kept vs open weights
ads = rng.uniform(10.0, 40.0, n) # 2030 advertising revenue
individuals = CONSUMER_POOL_2026 * (1 + g_pool) ** 4 * s_lab
corporate = CORP_TO_LABS_2026 * ((1 + g_vol) * (1 - d)) ** 4 * m + ads
return individuals, corporate
if __name__ == "__main__":
req, ind_req, corp_req = requirement()
print(f"2030 requirement {req:.1f}: individuals {ind_req:.1f}, corporations {corp_req:.1f}")
print(f"OpenAI consumer need {REQ_OPENAI*0.5:.1f} = {REQ_OPENAI*0.5/0.24:.0f}M people at $20/month")
sw2030 = SOFTWARE_2026 * (1 + SOFTWARE_G) ** 4
print(f"software 2030 {sw2030:.0f}; corporate share needed {corp_req/sw2030:.1%}")
print(f"consumer pool growth needed at 60% lab share: {((ind_req/0.6)/CONSUMER_POOL_2026)**0.25-1:.1%}")
print(f"volume growth for 77% revenue growth at 40% price decline: {required_volume_growth(0.766, 0.40):.0%}")
ind, corp = simulate()
tot = ind + corp
gap = np.maximum(req - tot, 0)
for name, x in (("individuals", ind), ("corporate", corp), ("total", tot)):
print(name, np.round(np.percentile(x, [10, 50, 90]), 1))
print(f"P(supply >= requirement) {(tot >= req).mean():.3f}")
print(f"P(individuals >= need) {(ind >= ind_req).mean():.3f} P(corporate >= need) {(corp >= corp_req).mean():.3f}")
print("gap p50/p90", np.round(np.percentile(gap, [50, 90]), 1), "mean", round(gap.mean(), 1))
Median customer spending reaching the two labs in 2030 is $313 billion. Taken separately, the median from individuals is $111 billion and from corporations, advertising included, $182 billion (medians do not add). Total customer spending reaches the $477 billion requirement in 19.1% of paths. Individuals cover their share in 8.3% of paths and corporations in 30.7%. The median gap is $165 billion, the 90th percentile $297 billion.
That gap is the number this article has been circling. It is the X dollars a year that customers will not pay and that someone else must: investors, while the funding window stays open, and then the counterparties and, potentially, taxpayers. Two independent routes lead to the same neighborhood. The cash model, which starts from the funding side, puts OpenAI’s median unpaid obligations at $113 billion over five years; the demand model, which starts from the customer side, puts the two labs’ shortfall at $165 billion in the single year 2030.
The corporate side is the closer call, and it is where this conclusion is most exposed. If token volume grows near 180% a year and revenue per token holds up, corporations alone clear their requirement in about three paths in ten. The consumer side is where the case is strongest: no plausible path gets 850 million people to pay $20 a month for one company’s chatbot.
The drag on corporate profits
The labs cannot stay below cost. Once they price to cover their compute contracts and earn a return, the companies built on their models pay for it out of their own earnings. For heavy users the hit is a third to two-thirds of net income. Across the S&P 500 it comes to roughly $130 billion a year of after-tax earnings by 2030, and US companies as a group lose about $100 billion a year after tax once lower customer demand and rehiring are counted. This section counts the bill, not any offset, because the bill is contractual and the offsets are not.
Today’s prices are subsidized by investors. OpenAI’s own plan shows negative free cash flow in every year through 2030, bottoming near negative $80 billion in 2028. The labs already earn healthy margins on serving a model: The Information reported OpenAI’s compute margin at about 70% in October 2025, and Anthropic has projected a 77% gross margin by 2028. The subsidy is in everything else, the training runs and the take-or-pay contracts. Closing that gap means raising what customers pay per unit of work, and a lab that wants a free cash flow margin m on top of break-even needs revenue of:
Worked example. With 2030 compute of $311 billion, o = 0.24 and a 20% margin, OpenAI needs $555 billion of revenue. At the volume customers are likely to buy, the simulated median of $174 billion, the price multiple is π = 3.19. Break-even alone takes π = 2.35. Customers who bought at 2026 prices would be paying two to three times as much for the same work.
What that does to a company’s earnings
For a company that spends a share s of its revenue on frontier models, earns a net margin n and pays tax at rate τ, a price multiple π removes this fraction of its net profit:
The formula says the damage scales with AI intensity and inversely with margin. That is why the hit lands hardest on the companies that adopted fastest. SaaStr reports one $100 million software business facing about $6 million of added inference cost in a year, six points of revenue. Bessemer’s 2025 data put the fastest-growing AI-native companies near 25% gross margins, many of them negative, and Cursor was reported to be paying Anthropic about $650 million a year against roughly $500 million of revenue.
Model spend and margins in the table are illustrative profiles, set from the reported cases above; τ = 21%. An AI-native company spending 30% of revenue on models cannot survive a doubling of its main input. A services firm on an 8% margin loses most of its profit to a 3% line item. Even a broadly adopting enterprise gives up 5% to 9% of earnings, every year, for a cost that did not exist five years ago.
The aggregate bill
Summing over both labs, the corporate share of what they must collect is $262.5 billion a year at break-even and $356 billion at a 20% margin. Letting the labs’ target margin range from 10% to 30%, the median corporate bill in 2030 is $370 billion. If S&P 500 companies pay 35% to 55% of it and their combined profits grow 4% to 9% a year from today’s $2.73 trillion, the after-tax bill is about $132 billion, or 3.7% of index earnings at the median and 4.8% at the 90th percentile. Measured only as the increase over what companies pay the labs today, it is 2.9%. That is a permanent tax on index earnings, collected by two private companies and concentrated in the sectors that moved first.
Proposed model: the raw drag on corporate profits when frontier labs price to cover
their compute contracts and earn a margin. Counts the bill only; no productivity offsets.
All figures in $ billions a year unless noted.
import numpy as np
OPEX_SHARE = 0.24 # calibrated non-compute cost share
COMPUTE_2030 = {"openai": 311.0, "anthropic": 51.8}
CORP_SHARE = {"openai": 0.50, "anthropic": 0.85} # share of lab revenue paid by companies
MEDIAN_OPENAI_REV_2030 = 174.3 # simulated median from the cost model
CORP_SPEND_2026 = 80.0 # corporate spend reaching the two labs today
SP500_PROFIT_TTM = 2730.0 # S&P 500 trailing net income, October 2026
TAX = 0.21 # federal statutory rate as a simple proxy
def lab_revenue(compute, margin):
"""Revenue a lab needs to cover compute, other costs and a free cash flow margin."""
return compute / (1 - OPEX_SHARE - margin)
def corporate_bill(margin, corp_share=CORP_SHARE):
return sum(corp_share[k] * lab_revenue(c, margin) for k, c in COMPUTE_2030.items())
def repricing_multiple(margin, volume_revenue=MEDIAN_OPENAI_REV_2030):
"""Price multiple needed at the volume customers actually buy."""
return lab_revenue(COMPUTE_2030["openai"], margin) / volume_revenue
def firm_profit_hit(ai_share_of_revenue, net_margin, pi, tax=TAX):
"""Fraction of a firm's net profit lost when its model bill is multiplied by pi."""
return ai_share_of_revenue * (pi - 1) * (1 - tax) / net_margin
def simulate(n=200_000, seed=3):
rng = np.random.default_rng(seed)
m = rng.uniform(0.10, 0.30, n) # labs' target free cash flow margin
k_oai = rng.uniform(0.45, 0.60, n) # OpenAI revenue share from companies
phi = rng.uniform(0.35, 0.55, n) # share of the bill paid by S&P 500 firms
g = rng.uniform(0.04, 0.09, n) # S&P 500 profit growth to 2030
bill = (k_oai * COMPUTE_2030["openai"] + CORP_SHARE["anthropic"] * COMPUTE_2030["anthropic"]) \
/ (1 - OPEX_SHARE - m)
pool = SP500_PROFIT_TTM * (1 + g) ** 4
drag_total = phi * bill * (1 - TAX) / pool
drag_increment = phi * (bill - CORP_SPEND_2026) * (1 - TAX) / pool
return bill, drag_total, drag_increment
if __name__ == "__main__":
for m in (0.0, 0.2):
print(f"margin {m:.0%}: corporate bill {corporate_bill(m):.1f}, "
f"repricing multiple {repricing_multiple(m):.2f}")
archetypes = [("AI-native software", 0.30, 0.10), ("SaaS adding AI features", 0.06, 0.20),
("Services and outsourcing", 0.03, 0.08), ("Large enterprise, broad use", 0.005, 0.10)]
for name, s, n in archetypes:
print(name, [f"{firm_profit_hit(s, n, pi):.0%}" for pi in (repricing_multiple(0), repricing_multiple(0.2))])
bill, dt, di = simulate()
print("bill p10/50/90", np.round(np.percentile(bill, [10, 50, 90]), 1))
print("drag total p10/50/90 %", np.round(100 * np.percentile(dt, [10, 50, 90]), 2))
print("drag increment p10/50/90 %", np.round(100 * np.percentile(di, [10, 50, 90]), 2))The double whammy
The direct bill is only half of what companies face. The industry’s answer to “who pays” is that companies will fund their AI spending by cutting staff. That answer hits the same companies twice. The workers they let go are their customers, so demand falls. And the cuts do not stick: Forrester found 55% of employers regret AI-driven layoffs, Gartner expects half of the companies that cut customer service staff for AI to rehire for similar roles by 2027, Robert Half found about 32% of hiring managers who cut roles for AI later refilled them, and Careerminds found 35.6% of employers had already rehired more than half of the roles they eliminated. Klarna, the best-known case, said its assistant did the work of about 700 agents in 2024 and was hiring human agents again by 2025. The World Economic Forum’s employer survey expects AI-era change to create 170 million jobs by 2030 against 92 million displaced: the technology needs people around it.
Put together, a company pays the higher model bill, keeps only part of the payroll it cut, and loses margin on the spending its former employees no longer do. In the model in the next section, US companies’ extra AI bill is a median $167 billion a year by 2030, the payroll savings that survive rehiring cover $47 billion of it, and lost customer demand costs another $8 billion of margin. The net is a pre-tax hit of $129 billion a year, about $102 billion after tax, with a 10th to 90th percentile range of $74 to $136 billion after tax.
Paying twice: workers, taxpayers and the bailout
The revenue has to come from somewhere, and the industry’s answer is payroll: companies will pay for AI with the wages of the people it replaces. That route is not delivering the money. What it does deliver bills the public twice. Displaced workers lose earnings and the Treasury loses the taxes on them, and because the payroll savings fall far short of the AI bill, the same taxpayers are then on the hook for the rescue. In the simulated paths where the labs leave contracts unpaid, the combined cost averages $257 billion and the median is $246 billion, with a 90th percentile of $390 billion.
What the payroll route would require
If US companies pay a share η of the increase ΔB in the corporate AI bill by cutting jobs that each cost c a year, and they need r dollars of payroll savings for every dollar of AI spending, the jobs that must go are:
The Bureau of Labor Statistics puts private employers’ cost at $46.89 per hour worked in June 2026, of which $32.82 is wages, so c ≈ $97,531 a year and the wage w ≈ $68,266. The median increase in the corporate bill from today’s roughly $80 billion is about $290 billion. With η = 0.55 and the minimum r = 1, dollar for dollar, US employers would have to eliminate 1.64 million jobs just to fund the bill. No company cuts staff to break even, so the real figure would be higher.
It is not proving out
Challenger, Gray & Christmas counted 112,713 US job cuts attributed to AI from January through July 2026, 24% of all announced cuts. At $97,531 each, that is $11 billion of annual payroll, against a corporate bill that has to rise by roughly $290 billion. Overall announced cuts were down 41% from the same period of 2025 and hiring plans were up 25%. This is not a labor market being hollowed out to pay for AI; it is a few employers cutting and many of them reversing, as the rehiring surveys in the previous section show.
Run the 2026 pace forward. About 193,000 AI-attributed cuts a year, less the 32% to 55% that get reversed, leaves about 480,000 net jobs gone by the end of 2030. That frees $47 billion a year of payroll, 28% of the $167 billion median US share of the bill, with a 10th to 90th percentile range of 21% to 37%. The payroll route pays for about a quarter of the bill. The rest is the shortfall that ends up with investors, counterparties and the public.
The cuts that do happen compound
A job cut to fund AI spending removes a customer. Let MPC be the share of lost take-home pay that would have been spent, t_e the employee-side tax rate, cm the contribution margin companies earn on that spending and k the spending multiplier. Each cut job then forces q further cuts, and the total is a geometric series:
With MPC from 0.5 to 0.9, take-home pay of 78% of wages, contribution margins of 25% to 40% and a multiplier of 1.0 to 1.5, q has a median of 0.15: every 100 jobs cut for AI cost the same economy another 15 through lost spending. The 480,000 becomes about 570,000, and the companies paying the AI bill lose about $8 billion a year of margin on demand that is no longer there. They are being asked to fund the labs at the moment their customers have less to spend.
The double bill
The cost to the public has three parts. Davis and von Wachter found that workers displaced from stable jobs lose the equivalent of 1.4 years of pre-displacement earnings in present value when unemployment is low and 2.8 years when it is high. The OECD puts the US tax wedge for an average worker at 30.1% of labor cost, so every lost year of earnings also removes that share in income and payroll taxes. And the rescue costs what the bailout section showed.
Here L is the earnings loss in years and τ_w the tax wedge. The model draws L from 1.4 to 2.8 and takes the net fiscal cost of the rescue from the cash model, with recovery from 0.3 to 0.7. It leaves out unemployment insurance, Medicaid and every other transfer a displaced household draws on, so it understates the public’s side.
Proposed model: the double cost to workers and taxpayers if the labs' revenue is meant to
come from corporate payroll cuts, plus the consumer-spending feedback on the same companies.
Dollar figures in $ billions a year unless noted. Assumptions are stated in the article.
import numpy as np
from bailout_model import simulate as simulate_shortfall
COMP = 46.89 * 2080 / 1e9 # employer cost per worker, $B a year (BLS ECEC, June 2026)
WAGE = 32.82 * 2080 / 1e9 # wages and salaries per worker, $B a year
TAX_WEDGE = 0.301 # US tax wedge, share of labour cost (OECD Taxing Wages 2025)
TAKE_HOME = 0.78 # wage kept after employee-side taxes (assumption)
CORP_SPEND_2026 = 80.0 # corporate spend reaching the two labs today
AI_CUTS_YTD, MONTHS = 112_713, 7 # AI-attributed US job cuts, Jan to Jul 2026 (Challenger)
YEARS_TO_2030 = 4.4 # August 2026 to end of 2030
def jobs_to_fund(bill_increase, us_share, payroll_per_ai_dollar=1.0):
"""US jobs that must be cut so payroll savings pay for the extra AI bill."""
return us_share * bill_increase * payroll_per_ai_dollar / COMP
def feedback_ratio(mpc, contribution_margin, multiplier=1.0):
"""Extra payroll each cut job forces: lost spending, spread through the economy by the
multiplier, times the margin it carried, divided by what one job costs."""
return multiplier * mpc * WAGE * TAKE_HOME * contribution_margin / COMP
def simulate(n=200_000, seed=5):
rng = np.random.default_rng(seed)
m = rng.uniform(0.10, 0.30, n) # labs' target margin
k_oai = rng.uniform(0.45, 0.60, n)
bill = (k_oai * 311.0 + 0.85 * 51.8) / (1 - 0.24 - m)
us = rng.uniform(0.50, 0.65, n) # US share of the corporate bill
rehire = rng.uniform(0.32, 0.55, n) # share of AI cuts later reversed
pace = AI_CUTS_YTD / MONTHS * 12 # gross cuts a year at 2026 pace
jobs = pace * (1 - rehire) * YEARS_TO_2030 # net displaced by 2030
funded = jobs * COMP # payroll freed, $B a year
need = us * (bill - CORP_SPEND_2026)
years_lost = rng.uniform(1.4, 2.8, n) # PV earnings loss in years of wages
mpc = rng.uniform(0.5, 0.9, n)
cm = rng.uniform(0.25, 0.40, n)
k = rng.uniform(1.0, 1.5, n) # spending multiplier (assumption)
q = feedback_ratio(mpc, cm, k)
jobs_total = jobs / (1 - q) # including feedback-induced cuts
lost_earnings = jobs_total * WAGE * years_lost
lost_tax = jobs_total * COMP * TAX_WEDGE * years_lost
lost_profit = k * mpc * jobs_total * WAGE * TAKE_HOME * cm
_, unpaid = simulate_shortfall(n=n, seed=7)
rho = rng.uniform(0.3, 0.7, n)
bailout = unpaid * (1 - rho) + 0.044 * unpaid * 3
return dict(bill=bill, need=need, funded=funded, jobs=jobs, q=q, jobs_total=jobs_total,
lost_earnings=lost_earnings, lost_tax=lost_tax, lost_profit=lost_profit,
bailout=bailout, unpaid=unpaid)
if __name__ == "__main__":
print(f"comp ${COMP*1e9:,.0f}, wage ${WAGE*1e9:,.0f}")
print(f"jobs to fund $290B increase, 55% US, $1 for $1: {jobs_to_fund(290, 0.55)/1e6:.2f}M")
pace = AI_CUTS_YTD / MONTHS * 12
print(f"AI cuts annual pace {pace:,.0f}; payroll of YTD cuts ${AI_CUTS_YTD*COMP:.1f}B")
print(f"feedback q at mpc .7 cm .33 k 1.25: {feedback_ratio(0.7, 0.33, 1.25):.3f}")
r = simulate()
pct = lambda x: np.round(np.percentile(x, [10, 50, 90]), 2)
for key in ("bill", "need", "funded", "jobs", "q", "jobs_total", "lost_earnings", "lost_tax", "lost_profit", "bailout"):
print(key, pct(r[key]))
print("funded share of need", pct(r["funded"] / r["need"]))
short = r["unpaid"] > 0
total = r["lost_earnings"] + r["lost_tax"] + r["bailout"]
print("P(shortfall)", round(short.mean(), 3))
print("total public+household cost, shortfall paths", pct(total[short]))
print("components median, shortfall paths",
[round(float(np.median(r[c][short])), 1) for c in ("lost_earnings", "lost_tax", "bailout")])
print("mean components shortfall",
[round(float(r[c][short].mean()), 1) for c in ("lost_earnings", "lost_tax", "bailout")],
round(float(total[short].mean()), 1))
hit = r["need"] - r["funded"] + r["lost_profit"] # US corporate double whammy, pre-tax
print("corporate net hit pre-tax", pct(hit), "after tax", pct(hit * 0.79))[embed: node/6486bfc5–2561]
The rescue is the largest single piece, but it is not most of the bill. Workers and the Treasury together lose about $117 billion in the average shortfall before a dollar of rescue money moves, and those losses arrive whether or not Washington steps in. The payroll route was supposed to make a bailout unnecessary. On the evidence of 2026, it adds a second bill to the first.
The enterprise exit ramp
The profit drag and the double bill are the case for getting out from under the labs’ pricing before it resets. A company building AI into its products and operations does not need to forecast whether a bailout happens. It needs an architecture in which the answer doesn’t matter. Open-weight models served from compute the company controls, or from several interchangeable hosts, are that architecture, and the economics now favor it for a large share of workloads.
Start with what the risk looks like from the buyer’s side. A lab under financial pressure has three levers and every one of them reaches its customers. It can reprice: the multiple π from earlier is 2.2 in 2027 at plan volumes. It can ration: capacity goes to the largest contracts, older models are retired faster, rate limits tighten. Or it can be restructured, and a receivership or a forced merger is a bad time to depend on an API’s terms of service. Proprietary agent frameworks, fine-tunes that live only on a vendor’s servers and prompts tuned to one model’s quirks all raise the cost of leaving at the moment leaving matters.
Open weights change the contract. Weights you have downloaded cannot be repriced, withdrawn or rate limited. The same weights run on many hosts, so a host failure is a configuration change rather than a migration. And they run on hardware you rent or own, so the worst case is a capacity problem you can buy your way out of.
The adoption data says companies have noticed. In an Enterprise Technology Research survey of 200 organizations published in September, open-weight models carried 34% of enterprise token usage, up from 23% a year earlier, and respondents expected 41% within twelve months. Cost was the most cited benefit (69% of production users), but control over deployment was the main driver; model quality was the concern for only 10% of respondents. On OpenRouter, the a16z and OpenRouter study of more than 100 trillion tokens found open-weight models carrying roughly a third of volume. OpenRouter’s June review puts the best open-weight models 3 to 6 months behind the closed frontier, a gap that has held for more than 18 months.
The price gap is an order of magnitude. GPT-5.5 lists at $5 per million input tokens and $30 per million output. GLM 5.2, the top open-weight model on Artificial Analysis’s index in June, averaged $0.447 and $3.31 on OpenRouter; DeepSeek V4 Flash’s first-party price is $0.14 and $0.28. For companies that cannot use Chinese-origin weights for compliance reasons, Nvidia’s Nemotron 3 Ultra ranked second among open-weight models at $0.423 and $2.61.
The self-hosting break-even
The useful question is when running open weights yourself beats paying per token. Let a be the ratio of input to output tokens, h the hourly price of a GPU, n the GPUs in a serving node, θ the node’s aggregate throughput in tokens per second, F the monthly cost of the people who run it and H = 730 h n the node’s monthly rent. Then:
Here p is the blended API price per million tokens, c is the self-hosted cost per million at full utilization, u* is the utilization at which hardware alone breaks even, and V* is the monthly volume at which hardware plus staff break even.
Worked example with a = 3, an eight-GPU H100 node at the October median of $3.51 per GPU hour, an assumed aggregate throughput of 8,000 tokens per second for a mid-sized open-weight model with batching, and $37,500 a month of engineering time (one and a half engineers at an assumed $300,000 fully loaded). Against GPT-5.5, p = $11.25 and c = $0.975, so the node breaks even on hardware at 8.7% utilization. Including staff, it breaks even at 5.2 billion tokens a month, about 25% of the node’s 21 billion token capacity. Against hosted GLM 5.2, p = $1.16 and the break-even volume is 50 billion tokens a month, more than twice what the node can serve.
That second result is the one to remember. Self-hosting beats closed frontier APIs at modest volume, but it rarely beats competitive hosted open-weight pricing. The reason to own compute is continuity and control, not unit cost. The cheapest hedge for most companies is open weights through several hosts, with a tested path to run the same weights on owned or rented hardware if every host disappears at once.
Whether the hedge pays for itself is a one-line calculation. If a company spends S a year on closed APIs, assigns probability P to a repricing of multiple π over its planning horizon, and keeping a portable stack costs H a year, the hedge pays when:
With P = 0.5, π = 1.5 and H = $300,000 (one engineer maintaining evals and routing), S* = $1.2 million a year. A company spending more than that on closed APIs is underinsured, before counting the cost of an outage.
A portability layer
The code below is the minimum version: one interface, endpoints in priority order, owned hardware first, a hosted open-weight model second, a closed API last, with cost recorded per call. vLLM and SGLang servers expose the OpenAI-compatible chat API, as do most open-weight hosts, so a single client library covers all three. Model names and URLs are placeholders set through environment variables.
Portable inference for companies building on AI.
Routes the same chat request across endpoints that speak the OpenAI-compatible API
(vLLM and SGLang servers expose it, as do most open-weight hosts), in priority order.
Configure endpoints with environment variables; model names here are placeholders.
import os
import time
from dataclasses import dataclass
from openai import OpenAI
@dataclass
class Endpoint:
name: str
base_url: str
model: str
api_key: str
usd_in: float # $ per million input tokens (0 for owned hardware; cost tracked separately)
usd_out: float # $ per million output tokens
def client(self) -> OpenAI:
return OpenAI(base_url=self.base_url, api_key=self.api_key, timeout=30, max_retries=0)
def endpoints_from_env() -> list[Endpoint]:
env = os.environ.get
return [
Endpoint("owned", env("LOCAL_URL", "http://localhost:8000/v1"),
env("LOCAL_MODEL", "your-open-weight-model"), env("LOCAL_KEY", "none"), 0.0, 0.0),
Endpoint("open-weight host", env("HOST_URL", "https://your-host.example/v1"),
env("HOST_MODEL", "your-open-weight-model"), env("HOST_KEY", "none"), 0.447, 3.31),
Endpoint("closed api", "https://api.openai.com/v1",
env("CLOSED_MODEL", "gpt-5.5"), env("OPENAI_API_KEY", "none"), 5.00, 30.00),
]
def complete(messages, endpoints, **kwargs):
errors = []
for ep in endpoints:
try:
t0 = time.perf_counter()
resp = ep.client().chat.completions.create(model=ep.model, messages=messages, **kwargs)
u = resp.usage
pt, ct = (u.prompt_tokens, u.completion_tokens) if u else (0, 0)
return {"endpoint": ep.name,
"text": resp.choices[0].message.content,
"latency_s": round(time.perf_counter() - t0, 2),
"usd": round((pt * ep.usd_in + ct * ep.usd_out) / 1e6, 6)}
except Exception as exc: # outage, rate limit, retired model, repriced plan
errors.append(f"{ep.name}: {type(exc).__name__}")
raise RuntimeError("all endpoints failed: " + "; ".join(errors))
def self_host_breakeven(p_in, p_out, in_out_ratio=3.0, gpu_hr=3.51, gpus=8,
tok_per_s=8_000, ops_usd_month=37_500, hours=730):
"""Compare a per-token API price with renting a GPU node and running open weights."""
p = (in_out_ratio * p_in + p_out) / (in_out_ratio + 1) # blended $ per M tokens
node_month = gpu_hr * gpus * hours
full_util_cost = gpu_hr * gpus / (tok_per_s * 3600 / 1e6) # $ per M at 100% use
v_star = (node_month + ops_usd_month) / p # M tokens per month
capacity = tok_per_s * 3600 * hours / 1e6 # M tokens per month
return {"blended_api_usd_per_M": round(p, 3),
"selfhost_usd_per_M_full_use": round(full_util_cost, 3),
"breakeven_utilization_hardware_only": round(full_util_cost / p, 3),
"breakeven_tokens_per_month_B": round(v_star / 1e3, 2),
"node_capacity_tokens_per_month_B": round(capacity / 1e3, 2),
"breakeven_utilization_with_ops": round(v_star / capacity, 3)}
if __name__ == "__main__":
print("vs closed frontier API:", self_host_breakeven(5.00, 30.00))
print("vs hosted open weights:", self_host_breakeven(0.447, 3.31))
if os.environ.get("RUN_LIVE"):
msg = [{"role": "user", "content": "Summarize our refund policy in two sentences."}]
print(complete(msg, endpoints_from_env(), max_tokens=200))Three choices in that code are deliberate. Retries are off in the client (max_retries=0) so a failing endpoint hands off to the next one immediately instead of stalling. Owned hardware is first in the list because its marginal cost is zero once you are paying for it. And the cost line is there because the business case for the hedge is made with those numbers, not with this article’s. The break-even function treats throughput as one blended figure for input and output tokens, which flatters long-output workloads; measure your own θ with your own prompts before you buy anything.
The router is the easy part. What makes a stack portable is an evaluation suite that runs the same task set against every endpoint each week, so you know the quality cost of failing over before you have to, and a rule that fine-tunes and retrieval indexes live on infrastructure you control. Open-weight models also come with their own risks: licensing terms differ between releases, the security review is yours to do, and a model from a jurisdiction your regulators distrust can be a compliance problem in its own right.
One macro footnote. Every company that moves workloads to open weights takes revenue out of the labs’ plans, which makes the shortfall more likely. In the model, cutting the revenue path by 10% raises the probability of unpaid obligations from 66% to 74% and the median shortfall from $113 billion to $150 billion. The hedge is individually rational and collectively self-fulfilling, which is the strongest argument for buying it early.
The path forward
The next twelve months decide which branch of the simulation we are on, and the signals are public. The first is whether OpenAI’s $30 billion round closes near the reported $1.4 trillion valuation, because in this model the funding window matters more than any single quarter’s revenue. The second is Oracle’s credit: its five-year CDS, any move by Moody’s from a negative outlook to a downgrade, and whether its planned $20 billion of equity gets done this calendar year. The third is the GPU rental index, which is the market’s live estimate of ρ. A sustained fall in H100 and B200 rents while the labs are still ramping payments is the combination that turns a revenue miss into a credit event.
For companies building on AI, the work is the same whichever branch we take. This quarter, inventory every production dependency on a closed model and attach an annual spend to each, then compare the total to S*. Stand up an evaluation suite that runs your real tasks against at least one open-weight model and one alternate host, and run it on a schedule. Move one production workload to open weights end to end, including monitoring and on-call, so the failover path has been used before you need it. Keep fine-tunes, embeddings and retrieval indexes on infrastructure you control. And in the next vendor negotiation, ask for price caps, model retirement notice periods and termination rights on a change of control: terms that cost a healthy vendor nothing and a distressed one a great deal.
For policymakers, the cheapest moment to design a resolution regime is before anyone needs it. Two steps would cost little now. Require the counterparties of large take-or-pay compute contracts to disclose concentration the way Oracle’s lease commitments surfaced through S&P, and decide in advance that any public money comes with equity and a claim on the capacity. A rescue designed in a weekend tends to protect whoever is closest to the room. One designed now can protect the companies and workers who use these systems, and leave the people who priced the risk to bear it.
About the Author
Brian James Curry is a data science and AI leader, hands-on machine learning practitioner, and published applied researcher. He is the founder of Vector1 Labs, an independent lab working on causal inference, marketing economics, cognitive AI architecture, complex systems, and the economics of intelligent automation.
His career combines sustained business and technical leadership across media, retail, industrial markets, hospitality, and telecom. His responsibilities have spanned marketing, operations, finance, sales, product strategy, and organizational development, including director-level leadership at McClatchy and management roles at AT&T and YP. That commercial foundation informs his approach to building data and AI capabilities around business decisions.
At Koch Ag & Energy Solutions, part of Koch Industries, Brian established the data science and ML practice from scratch. He combined practice leadership with hands-on data engineering, modeling, experimentation, and MLOps, leading large-scale initiatives with CEO-level visibility. He evaluated emerging technologies and vendors, integrated new capabilities into existing systems, and developed proofs of concept, frameworks, and tools with technology and research partners, including AWS.
At Tractor Supply Company, he helped lead the development of AI, ML, experimentation, and advanced analytics capabilities across Azure, Databricks, Snowflake, and open-source technologies. At Vail Resorts, he leads the Advanced Analytics/ML capability and the architecture and implementation of app analytics, aligning teams around use cases while delivering solutions across large-scale datasets. Throughout these roles, he has combined future-state planning and technical direction with direct contributions to development and implementation.
His public open-source and private research portfolio includes Papilon, for causal modeling, marketing measurement, and complex-system simulation; PyCausalSim, for simulation-driven causal discovery and counterfactual analysis; OMNI Intelligence, for multi-model AI evaluation; and Memory-Node Encapsulation, for artificial episodic memory. Additional work explores semantic geometry, forecasting, emerging-signal detection, and the economic effects of intelligent automation.
In 2016, Brian founded KC AI Lab, originally the Kansas City Machine Learning Group. The community grew to more than 1,500 practitioners, supporting education, collaboration, and exploration of emerging AI technologies.
He holds a BS in Economics from Kansas State University, where he was a collegiate athlete. He is a musician, composer, and painter, has trained in Brazilian Jiu Jitsu, and is the father of two. He lives in Kansas City.
Vector1 Labs: https://vector1.ai
Substack: https://brianjamescurry.substack.com
Medium: https://medium.com/@brian-curry-research
GitHub: https://github.com/Bodhi8
Sources
- Oracle Q4 FY2026 results, Form 8-K exhibit 99.1, Oracle, June 2026
- S&P’s downgrade leaves Oracle financing OpenAI’s bet years before it pays off, Startup Fortune, October 2026
- S&P cuts Oracle to BBB- as AI buildout widens cash deficit to $42bn, PPC Land, July 2026
- Morgan Stanley: Oracle’s 5-year CDS rises to 260bps, TechFlow, October 2026
- OpenAI projects $70 billion annualized revenue by end of 2026, Quartz via Yahoo Finance, October 9, 2026
- OpenAI financial fact sheet, June 2026, Luminix, 2026
- OpenAI compute commitments tracker, May 2026, Presenc, May 2026
- OpenAI revenue miss: WSJ report and the $1.4T Stargate bet, Tech Insider, 2026
- Report: Anthropic locks in $518B AI infrastructure commitments, TechTarget citing Reuters, September 29, 2026
- Sam Altman says he doesn’t want the government to bail out OpenAI if it fails, TechCrunch, November 6, 2025
- OpenAI signs $38bn multi-year agreement with AWS, DCD, November 2025
- CoreWeave expands agreement with OpenAI by up to $6.5B, CoreWeave, 2025
- Meta and Blue Owl’s $27B bet, Global Data Center Hub, 2025
- Hyperscalers hit $700 billion in 2026 AI spending plans, Yahoo Finance, May 1, 2026
- No Bailouts for Big Tech Billionaires: Policies for when the AI bubble bursts, Open Markets Institute, 2026
- Final Report on the Troubled Asset Relief Program, Congressional Budget Office, April 2024
- GPU rental price trends, GetDeploying, week of October 12, 2026
- The open-weight models that matter: June 2026, OpenRouter, June 27, 2026
- Open-weight AI models expected to capture 41% of enterprise token usage, Techstrong.ai, September 22, 2026
- OpenRouter’s 100 trillion token study, Crypto Briefing, July 2026
- OpenAI API pricing (2026), Morph, August 2026
- Consumer AI report 2026, Menlo Ventures, September 15, 2026
- 2025: The State of Generative AI in the Enterprise, Menlo Ventures, December 9, 2025
- Gartner forecasts worldwide IT spending to grow 10.8% in 2026, Gartner, February 3, 2026
- LLM inference price trends, Epoch AI, March 12, 2025
- MIT report finds most AI business investments fail, Virtualization Review, August 19, 2025
- ChatGPT surpasses 900 million weekly users, 50 million paying subscribers, ROIC.ai, February 27, 2026
- $2 trillion in new revenue needed to fund AI’s scaling trend, Bain & Company, September 23, 2025
- Have AI gross margins really turned the corner?, SaaStr, December 2025, updated July 2026
- S&P 500 earnings, trailing 12 months, Chartrow, October 13, 2026
- Compensation costs for private industry workers averaged $46.89 per hour worked in June 2026, Bureau of Labor Statistics, 2026
- Challenger Report, July 2026, Challenger, Gray & Christmas, August 2026
- 55% of employers regret AI layoffs; Gartner predicts more rehires by 2027, People Matters, 2026
- Klarna is hiring customer service agents after AI couldn’t cut it, Entrepreneur, May 9, 2025
- Future of Jobs Report 2025, World Economic Forum, January 2025
- Recessions and the Cost of Job Loss, Steven J. Davis and Till von Wachter, NBER, 2012
- Taxing Wages 2025, OECD, April 2025
