$29.3 Million vs. $5,000: What One Company Pays to Ask the Same Question 8.76 Billion Times

Q: How was the $28.7 million annual figure calculated?

1,000,000 calls per hour (8.76 billion per year) against GPT-5.6 Sol's list price of $5/$30 per million input/output tokens, modeling 415 total input tokens per call (400 cached system-prompt/tool-schema tokens plus 15 fresh question tokens, billed at full rate in this worst-case scenario) and 40 output tokens. This is the no-caching worst case; with prompt caching correctly implemented, the same volume costs roughly $12.9M/year instead.

Q: What is the real difference between the build cost and the operate cost here?

Build cost is a one-time infrastructure expense, roughly 69x higher for the sandboxed architecture. Operate cost recurs every year the service runs and is nearly 5,900x higher, because it is dominated by per-call API token billing rather than infrastructure, which only has to be paid for once per hardware refresh cycle.

$29.3 Million vs. $5,000: What One Company Pays to Ask the Same Question 8.76 Billion Times

One company. One agent. One question with exactly one right answer: "What's the cost of 'xyz'?" Invoked 1,000,000 times an hour. Two ways to answer it.

$29.3 million a year, or $5,000 a year. Here is every number that produces both totals, including the parts that make this comparison fair rather than flattering.

The scenario

A customer, or another system, asks: "What's the cost of 'xyz'". One architecture sends that sentence to GPT-5.6, which decides to call a pricing tool, and — worst case — that tool runs inside a freshly provisioned sandboxed VM. The other architecture skips the sentence entirely and dispatches this directly:

execute:eshop.get-cost
   sku:xyz
return-value:x:-/*

Three lines. No inference, no sandbox, no ambiguity about what "xyz" refers to — the SKU is the argument, pinned, verified before dispatch, the same mechanism this site has shown the source code for before.

Pricing the natural-language path

GPT-5.6 Sol — list price $5 / $30 per million input/output tokens, or a promotional $4 / $20 confirmed by AWS Bedrock's own pricing announcement through November 21, 2026. Neither figure comes from OpenAI's own pricing page directly — worth checking before you quote either one elsewhere.

A real single-tool deployment sends more than the seven-word question on every call: a system prompt and the tool's function schema travel with it. Modeled here as 400 cached tokens (system prompt + schema, eligible for the ~10%-of-standard cached-input rate), 15 fresh tokens (the actual question), and 40 output tokens (the function call plus a short answer).

	List price, no caching (worst case)	List price, cached	Promo, cached
Per call	$0.003275	$0.001475	$0.001020
Per year (8.76B calls)	$28.7M	$12.9M	$8.9M

The headline figure below uses the worst case: list price, no caching — the scenario where nobody bothered to implement prompt caching for a repeated system prompt, which is a realistic failure mode, not a strawman.

Adding the sandbox

Worst case means a real virtual machine per call, not a lightweight microVM — 5-second boot and execution, 250W host draw while active, the same figures used throughout this site's prior cost modeling. Concurrent VM capacity per physical host is the open variable:

Concurrent VMs/host	Hosts needed	Capex	Depreciation/yr	Electricity/yr
5 (worst case)	278	$2.78M	$694K	$304K
10 (used below)	139	$1.39M	$347K	$304K
20	69	$694K	$174K	$304K
50 (optimistic)	28	$278K	$69K	$304K

10 concurrent VMs per host is the figure carried into the totals — a middle point on a range this article isn't pretending to have measured.

Company A: the full bill

	Amount
Build (capex)	$1.39M — the sandbox-hosting fleet
GPT-5.6 API, annual	$28,689,000
VM hardware depreciation, annual	$347,222
VM electricity, annual	$304,167
Operate (annual total)	$29,340,389

Company B: the full bill

1,000,000 calls an hour is ~278 requests per second — trivial for two ordinary application servers kept for redundancy, nothing purpose-built. No LLM API call exists in this path. No VM is ever provisioned.

	Amount
Build (capex)	$20,000 — two standard servers
Server depreciation, annual	$5,000
Dispatch electricity, annual	$0.018
Operate (annual total)	$5,000.02

The ratios, and which one actually matters

Build: 69x. Operate, per year: ~5,900x.

The build gap is almost a footnote. The operate gap is the entire story, because it recurs every single year the service stays live, and because 97.9% of Company A's annual bill is the API token cost alone — not sandboxing, not hardware, not electricity. The company is paying, 8.76 billion times a year, to have a question re-interpreted that was only ever going to have one answer, the first time anyone wrote the five words execute:eshop.get-cost sku:xyz.

The honest part

This isn't a claim that every agentic workload collapses this cleanly. It specifically describes the case where the answer was already decided — a lookup, a price check, a status query — and a natural-language model is being paid, on every single call, to re-derive an intent that a human already fully specified once, in a config file, months earlier. Plenty of real agent tasks genuinely need judgment on every call, and nothing here claims otherwise. The claim is exactly as narrow as that distinction, and exactly as strong within it: when the model isn't deciding anything new, every token it spends deciding it again is pure waste, priced per call, forever.

Frequently asked questions

How was the $28.7 million annual figure calculated?

1,000,000 calls/hour (8.76 billion/year) against GPT-5.6 Sol's list price of $5/$30 per million input/output tokens, modeling 415 total input tokens per call (400 cached system-prompt/tool-schema tokens plus 15 fresh question tokens, billed at full rate in this worst-case scenario rather than the discounted cached rate) and 40 output tokens. This is the no-caching worst case; with prompt caching correctly implemented, the same volume costs roughly $12.9M/year instead.

What does the "97.9%" figure refer to?

Of Company A's $29.3M annual operating cost, $28.7M is the GPT-5.6 API bill alone — the remaining $654K covers sandbox VM hardware depreciation and electricity. The API token cost, not the infrastructure, is the overwhelming majority of the expense.

Does this apply to every AI agent, or only specific cases?

Only to the case modeled here: a query whose answer was already fully decided before the question arrived, such as a price or status lookup. Agent tasks that genuinely require judgment, synthesis, or reasoning on each individual call are a different problem this article doesn't address.

What's the real difference between the build cost and the operate cost here?

Build cost (capex) is a one-time infrastructure expense — 69x higher for the sandboxed architecture. Operate cost (annual opex) recurs every year the service runs and is nearly 5,900x higher, because it's dominated by per-call API token billing rather than infrastructure, which only has to be paid for once per hardware refresh cycle.