Ask what a unit of AI compute costs and you get an answer in the wrong unit. The chip is priced by the hour. The model is priced by the million tokens. The product is priced by the seat. Nobody who pays one of those prices can see the other two, and the gap between them is where the money is.
This piece sets out a taxonomy we built to read that gap. It gives every unit of compute a seven-part address, one code from each of seven layers, running from the silicon that did the work up to the commercial terms it was sold on. Each layer has its own unit of price. Each layer inherits the full cost of the layer beneath it and adds a margin of its own. Once a workload has an address, three numbers become readable: what it should cost at the lowest layer, what it is being charged at the highest, and which layer in between is taking the rent.
The taxonomy was built for our own use, to understand the cost structure of a market that has indices at the bottom, list prices in the middle and flat fees at the top, with nothing joining them. We are publishing it because the same problem faces anyone who has to budget for, price, sell or hedge AI consumption. Sections 01 to 03 set out the address and the margin stack it exposes. Section 04 works three examples end to end: a finance team reconciling a bill, an application company pricing a seat, and a dealer pricing a fixed-price contract. Every list price is a United States list price read between September 26 and 28, 2026, and every measured cost carries its date, from the pages in the register at the end. Five of the figures are live, and the companion Navigator carries the rest.
Seven layers, one code from each. Price is decided below the line; quantity above it.
The address answers seven questions in order. What silicon ran it. How that silicon was held. Which model ran. What kind of task it was. How consumption grows with use. Who delivered it. On what terms it was sold.
The layers build on the Tokenomics Foundation’s five-layer stack (silicon, capacity, serving software, model, routing), which sets where price is decided, and on its consumption classes, which set how quantity scales; that keeps a classification lined up with the tools buyers already use. We add two layers the foundation leaves out, delivery path and commercial terms, because that is where most of the rent sits. The dashed line in Figure 1 marks the foundation’s own split: the price of a token is decided below it, and the number of tokens is decided above it.
An address is written as one code per layer, separated by bars. Figure 2 builds one. Pick a code from each layer and it returns the address, the unit each layer is priced in, and the price range the September snapshot gives for the layers that carry a price. The presets are the buyers this piece keeps returning to.
Three conventions hold for the rest of the piece. Cost means the resources consumed to produce the output. Rent means what is charged above that cost by whoever owns the layer. And a price without a layer is not a price: “$2.70 an hour” is layer two, “$10 a million tokens” is layer three, “$20 a month” is layer six, and none of them can be compared until the same output has been given the same address.
One kilowatt through one chip, resold at every layer. The rent grows on the way up.
Electricity is the only input that is physically consumed, and it is about 4 percent of the price of a rented chip-hour. Everything above it is capital, hosting, software, capability and contract, and each of those is somebody’s margin.
Figure 3 puts nine ways of buying the same million output tokens on one scale. The three self-hosted rows are measured throughput from SemiAnalysis InferenceX priced at an owner’s cost of about $1.20 a chip-hour, or at the $4.50 on-demand H200 rate for the rented row. The rest are list prices. Input tokens, caching and batch change the blend; they do not change the order.
Step 1 · From chip to chip-hour
An owner’s all-in cost for one H100-hour is three lines: capital, electricity and hosting. Figure 4 builds it from the September inputs and sets it against the prices the same hour fetches on the market. At full utilisation the owner’s cost is about $1.07. At 70 percent, because idle hours cost the same, it is $1.53. The rental indices print $2.54 to $2.70, a neocloud charges $3.85 to $4.25 on demand, and a hyperscaler $11 to $12. The rent share of price is therefore about 40 to 60 percent at the index, 60 to 75 percent at a neocloud, and 85 to 90 percent at a hyperscaler. Spot at $0.79 sits below the owner’s own cost, which is what unsold capacity looks like.
Owner’s inputs
Utilisation
Step 2 · From chip-hour to token
An H200 serving DeepSeek V4 Pro produces about 5,100 tokens a second at 100 tokens a second per user, or 18.5 million tokens an hour. At the $4.50 on-demand rate that is $0.24 a million tokens; at an owner’s cost of about $1.80 a productive hour (70 percent utilisation) it is about $0.10. The same model is sold hosted at $1.32 a million input tokens and $3.96 a million output. On a four-to-one input-to-output blend the hosted price is about $1.85, roughly 8 times the rented cost and 19 times the owned cost. Serving software, utilisation, redundancy and the host’s margin sit in that gap.
Step 3 · From open-weight token to frontier token
Frontier vendors do not publish cost, so their rent can only be bounded, not measured. Frontier flagship output lists at $20 to $30 a million tokens, and the top tier at $50, which is 5 to 13 times a hosted open-weight large model. Frontier small tiers list at $1.20 to $5.00, on top of and sometimes below open-weight mid models, which is where price competition is real. The frontier premium is a price for a capability with no substitute. It is the one layer where a buyer has no cost-side lever, only routing and terms.
Step 4 · From token to seat
A seat converts a variable token bill into a flat fee: $20 a month for a prosumer plan at OpenAI, Anthropic and Cursor, $100 and up for heavy plans, $20 a seat plus usage at API rates for an enterprise plan. The vendor sets a usage cap so that the fixed fee covers the expected tokens. The cap is the vendor’s hedge, and the heavy user who hits it is the vendor’s tail risk. No vendor publishes tokens per seat, so the seat rent cannot be measured from outside. What can be seen is that the prosumer plans at OpenAI, Anthropic and Cursor all carry the same twenty-dollar price point, which says the price is set by the market for seats, not by the cost of tokens.
The cost of a given output is set in the bottom three layers and is knowable to within a factor of two. The price paid is set in the top four and can be anywhere from 3 to 500 times that cost. The address is the tool for putting a number on that ratio for a particular buyer and a particular use, and section 04 does so three times.
Who pays rent at which layer, and the twelve levers that close the gap, ranked by size.
Classify seventeen buyer types by their dominant use and three patterns fall out. Only three of them own the chip. The buyers with the thinnest margins run the least forecastable workloads. And the enterprise adopter is the only buyer paying rent at all four upper layers at once.
Figure 5 is the condensed map; the Navigator carries all seventeen rows with the revenue basis, cost basis and main cost risk for each. Rows run from the bottom of the stack, the chip owners, to the top, the seat buyers.
| Buyer | Dominant use | Address, main codes | What it pays, and at which layer | Margin shape | Main cost risk |
|---|---|---|---|---|---|
| Frontier lab | Serving its own API | SI-GPU-B/H · CF-OWN · MC-FR · TT-INF-ON · DP-API · CT-LIST | Owned chip-hours at about $1 to $1.50 per H100-hour; serving software; idle capacity off-peak | Highest rent in the stack; margin not disclosed | Demand moving to open weights at the small tier; utilisation swings |
| Neocloud | Renting chip-hours | SI-GPU-H/B · CF-RES sold as CF-OD | About $1.07 an hour at full use, $1.53 at 70 percent | Rent 40 to 75 percent of price; spot below cost | The index falling below owner cost on the older generation |
| Inference host | Selling tokens on open weights | SI-GPU-H/B · CF-OWN/RES · MC-OW · CF-SVL | Chip-hours at owner or reserved cost; $0.07 to $0.24 per million tokens produced | Price 8 to 19 times production cost, competed down by the number of hosts | Utilisation below break-even; price war on popular models |
| AI-native application | Coding, legal or support product on frontier models | MC-FR-L/M · TT-AGT · WS-TA · DP-API/GW · CT-COMMIT+CACHE | Frontier tokens at list less commitment discount; input-heavy at 25 to 1 in agent loops | Thin and variable; agent depth sets the gross margin | Token cost per seat exceeding seat price; vendor price reset; model retirement |
| Enterprise, regulated | Document processing, service, internal copilots | MC-FR-M · TT-INF-BA/ON · WS-T1/TK · DP-CLOUD · CT-COMMIT | Tokens through a cloud commitment; seats for knowledge workers; some self-hosting for data residency | Pays rent at four layers: chip, model, cloud, seat | Unused commitment; consumption drifting from linear to multiplicative; model retirement mid-contract |
| Enterprise, general | Coding assistants and productivity seats | MC-FR · TT-AGT · DP-APP · CT-SEAT/CREDIT | $10 to $100 a seat a month plus credit overage | Rent to the application vendor; cheapest frontier tokens per outcome for light users | Seat sprawl; heavy users on credits |
| Developer or prosumer | Building and using tools | MC-FR/OW · TT-AGT · DP-APP/API · CT-SEAT/CREDIT | $20 to $200 a month in seats and credits | Pays full retail rent; most tokens per dollar on open weights | Credit burn in agent loops |
The second thing the address returns is a ranked list of what to do about it. Figure 6 orders twelve levers by how much each can move the cost of a given output on the September prices, using the multiple between the worst and best case on that lever alone. The levers compound. The largest three sit in the upper layers and belong to the buyer. The chip-level levers are real but small by comparison, and they belong to whoever owns the chip.
| # | Lever | Layer | Size | Who captures it today | Evidence |
|---|
Only the two bottom layers are hedgeable on a listed instrument today. The chip-hour has two published H100 indices and B200, H200, A100 and MI300X series, and NYMEX has filed futures on two of them (see The Contract Lost Its Date). Nothing above layer two is indexed. The model-class price is a vendor list that resets a few times a year; the quantity of tokens is decided by architecture; the seat is a contract. So for a desk the address is a decomposition: it says what share of a client’s cost can be hedged on the screen (the chip leg of any self-hosted share), what has to be written as a private instrument (the frontier list leg and the quantity leg), and what has to be held as capital. Example C in the next section runs that decomposition on a stylised contract.
The same address, read by a finance team, an application company and a dealer.
Each example starts with an address, prices it from the snapshot, and then moves the dials that matter for that buyer. The inputs are round illustrative numbers. The prices are not.
All three ledgers use the same arithmetic for a token bill: input tokens at the list rate, less the cached share at 10 percent of list, plus output tokens at the list rate, with batch at half price where it applies. The Navigator’s margin-stack tab adds a self-host break-even calculator for the operator side.
The finance team budgeted a document-processing and customer-service workload as linear: one model call per request, on a frontier mid model, bought through a cloud commitment. Six months in, the product team has added a reasoning step and a retrieval loop, and the bill does not match the budget. The address shows why: the workload moved from WS-T1 to WS-TK, and the layer that moved is the one nobody was watching.
The ledger prices the tokens at list, applies the terms the enterprise actually has, and sets the result against the annual commitment. The floor line is what the same tokens would cost on a hosted open-weight mid model, and self-hosted. The gap between the bill and the floor is the rent the enterprise pays at four layers.
The workload as budgeted
What actually happened
The terms
Three things the finance team can now do that it could not do from the invoice. It can name the layer that moved, and ask the product team for the consumption class of each feature before it ships rather than after. It can size the commitment to the class it expects, because an unused commitment is lost and an overrun is billed at list. And it can put the rent on paper: the same tokens would cost a fraction on an open-weight model, and the difference is the price of frontier capability plus the price of buying it through a cloud. Whether that is worth paying is a product question; until the address is written down, it is not a question at all.
A coding assistant sells seats at the market price for seats, $20 a month, and buys tokens at the market price for tokens. Its cost of goods is an agent loop: a fifty-turn coding session replays about a million input tokens and produces about forty thousand output tokens, an input-to-output ratio near 25 to 1. The workload shape is agent-multiplicative, the least forecastable class in the taxonomy.
The ledger prices a session, multiplies by sessions per seat, and sets it against the seat. Then it moves the three buyer-side levers that matter for this address: cache the replayed context, route sub-tasks to the small tier, and buy on a commitment. The heavy-user dial shows the tail: the seat that uses several times the mean, which the usage cap exists to stop.
The product
The model
The levers
At the defaults the seat loses money: a session costs about $1.50 in tokens and twenty of them cost more than the $20 the seat brings in. That is the taxonomy’s reading of the application company’s row: thin and variable, with agent depth setting the gross margin. The way out is not a cheaper chip, because the company does not buy chips. It is the three upper-layer levers, and they compound. Restructure prompts so the stable prefix comes first and the cache hit rate rises from single digits to 80 percent; route the sub-tasks that do not need the frontier model to the small tier; then buy the remainder on a commitment. The ledger shows the seat crossing from loss to a margin that a software business can live with, and it shows the heavy user turning the mean back into a loss. The cap is not a product decision. It is the hedge.
Lever 12 is the one no one provides at scale: converting a variable token cost into a fixed price per outcome. An enterprise wants to pay a set price for each completed contract review, for a year. A dealer that will write that contract has to know what a review costs, how much of that cost can be hedged on the screen, and how much capital it takes to hold the rest.
The address answers the first question and decomposes the other two. A review at the defaults runs about 200,000 input tokens and 8,000 output. The dealer routes part of the work to a frontier mid model at list and part to an open-weight large model it serves on rented or owned H200s. That splits the cost into three legs. A chip leg, the self-hosted share, which moves with the H200 rental rate and can be hedged on the listed indices. A list leg, the frontier share, which moves when the vendor resets its price and has no index. And a quantity leg, tokens per task, which moves when the client’s documents or the dealer’s prompts change shape, and which only architecture and a contractual cap can control.
The task class
The routing
The contract
The stress
The ledger’s first finding is uncomfortable for a desk. At the defaults the chip leg, the only part of the cost that can be hedged on a listed index, is around a fifth of the dealer’s cost. The frontier list leg is bigger and has no screen. The quantity leg is bigger still and has no screen either. So the index hedge, correctly sized, removes a small slice of the stress, and it is the contractual cap on tokens per task that does most of the work. That matches the taxonomy’s reading of lever 12: what it needs is a task-cost reference, a usage record standard and capital to hold the tail. The listed chip-hour future is the smallest of those three, and it is the only one that exists.
A book of fixed-price tasks is short the vendor’s list price, short the client’s prompt discipline and long a small chip-hour position it can hedge. The first two exposures are why the seat vendors cap usage and why no one sells this to enterprises yet. The taxonomy does not make them hedgeable. It makes them nameable, which is the step before a price.
For open-weight work the lever is utilisation. For frontier work it is the contract.
For any self-hosted workload, the cost of a million tokens is the chip-hour price divided by what the chip produces in an hour. That one formula sorts the eleven workload classes into two groups: the ones where you choose a chip and the ones where you choose terms.
Three rules of thumb follow from the September numbers. A newer generation is cheaper per token even at a higher hourly price: on DeepSeek R1 a B200 produces 7 times the tokens of an H100 at 3.2 times the index price, so it is 2.2 times cheaper per token. Self-hosting an open-weight model on a rented eight-chip H200 node, about $864 a day, beats hosted open-weight prices once the node runs above about 13 percent utilisation, roughly 470 million tokens a day; on owned chips the break-even falls to about 5 percent, or 190 million tokens a day. Below those volumes, or for any frontier model, the economic choice is not a chip but a set of terms.
| Workload class | Address | Most economic setup | Indicative cost | When to switch |
|---|---|---|---|---|
| Batch extraction, summarisation, classification at volume | TT-INF-BA · MC-OW-L/M · WS-T1 · LAT-BAT | Owned or reserved B200 running open weights; spot H200 when interruption is tolerable | $0.06 to $0.17 per million tokens self-hosted; $0.60 to $3.96 hosted | Below about 470 million tokens a day per rented node, use a hosted API at batch rates |
| Interactive assistants on open weights | TT-INF-ON · MC-OW-M · WS-T1 · LAT-INT | Hosted open-weight API until volume is steady; then H200 or B200 self-hosting at 100 tokens a second per user | Hosted $0.10 to $1.04 per million input; self-hosted $0.07 to $0.24 | Speed-critical products pay Groq or Cerebras rates for tokens per second, not per dollar |
| Small-model tasks: classification, extraction, embedding, reranking | TT-RET · MC-OW-S/TASK · WS-T1 | L4, L40S or consumer cards; Arm CPU for embeddings at low volume | $0.49 to $1.09 a chip-hour; $0.05 to $0.15 per million tokens hosted | Never a Hopper or Blackwell chip; the memory is wasted |
| Agentic coding and research on frontier models | TT-AGT · MC-FR-L/M · WS-TA · IO-IN · CTX-L | No chip choice. Cheapest terms: no long-context premium, cache reads at 10 percent of input, committed spend, sub-tasks routed to the small tier | Input is 25 tokens per output token; at 80 percent cache hits the effective input rate is about 28 percent of list | When a task class is definable, buy per task from a router or dealer rather than per token |
| Long-document reasoning | TT-INF-ON · MC-FR-L · WS-TK · CTX-L | Flat context pricing or batch mode; open-weight large hosted when quality allows | Frontier $2 to $5 per million input, doubling above 200,000 tokens at two of three vendors | Chunk and retrieve before paying long-context rates |
| Evaluation and regression suites | TT-EVAL · LAT-BAT | Batch API at half price, or spot chips for open weights | Half of list; $0.79 an H100-hour spot | Never interactive rates |
Two rents are bounded, not measured. Both are the largest in the stack.
The taxonomy is only as good as the prices that fill it, and two of the seven layers publish none.
Frontier serving cost. No vendor publishes it, so the frontier rent in step 3 of the margin stack is bounded by open-weight hosting prices, not measured. The best proxy is the price of the largest open-weight model served on Blackwell at scale. Tokens per seat. No application vendor publishes it, so the seat rent in step 4 cannot be measured from outside. A gateway operator, or a large enterprise’s own usage export, is the only source. Tokens per watt across silicon. InferenceX covers Nvidia; the AMD, TPU, Groq and Cerebras figures are vendor claims until someone runs one model across all of them. Index coverage. Compute Desk’s index levels are not public; when they are, they belong beside the Silicon Data and Ornn rows. Training cost. Third-party estimates of frontier runs are modelled, not disclosed, and should carry that label wherever they are reused; DeepSeek V3 at $5.58 million is the one disclosed figure in the snapshot.
A published tokens-per-seat figure from any application vendor would turn the seat rent from a bound into a number, and would probably move lever 12 from “not yet provided” to “priceable”. A frontier vendor publishing serving cost, or a Blackwell-scale open-weight host publishing its unit economics, would do the same for the model rent. Neither is likely soon, and the taxonomy is built to work without them: the bounds are wide, but they are bounds, and a buyer who knows the floor can negotiate against it.
The address is the missing join between the chip-hour index, the token list and the seat.
Every unit of AI compute already has a price in three units that cannot be compared. The seven-layer address makes them comparable, and once they are comparable the rent at each layer becomes a number a buyer can budget against, a vendor can defend and a dealer can quote.
For the finance team, the address turns a surprise on the invoice into a named layer that moved. For the application company, it turns a thin margin into three levers with sizes. For the desk, it decomposes a client’s cost into the slice a listed future can hedge, the slice that needs a private instrument, and the slice that needs capital. In every case the address does not lower the cost by itself. It says where the cost is, which is the thing none of the three prices did.
Three things follow. First, the cost of an output is set in the bottom three layers and is knowable to within a factor of two from public prices; the price of an output is set in the top four and is not. Second, the largest levers belong to the buyer and need nothing from the market except measurement, which is why the Tokenomics Foundation’s work is built around them. Third, the instrument the market lacks is not another chip-hour contract. It is a fixed price per outcome, and the address is the object it would be written on.
What this piece rests on
The taxonomy
- Kinetic Alpha, Compute Consumption Taxonomy, working document, September 28, 2026: seven layers and code tables; margin stack (steps 1 to 4); price snapshot of September 26 to 28, 2026; end-user map (seventeen rows); most economic setup by workload class (eleven rows); optimisation register (twelve levers); open questions. Every table, range and multiple in this piece is taken from it. A spreadsheet companion carries the full snapshot of about ninety rows.
- The five-layer stack (silicon, capacity, serving software, model, routing) and the consumption classes are the Tokenomics Foundation’s. Lever 1’s 34-times figure (one task, four architectures, $3.04 to $0.09) is the foundation’s worked example. Layers six and seven are ours.
Chip-hour prices, $ per chip-hour, read September 26 to 28
- Indices: H100 rental index $2.70 (Silicon Data, SDH100RT, September 27); H100 SXM $2.54, H200 $4.78, B200 $8.04, A100 80 GB $0.95 (Ornn OCPI, September 26); MI300X $2.62 (Silicon Data).
- Neoclouds and marketplaces: H100 SXM $3.99 on demand, B200 $6.69 on demand and $8.87 to $9.86 reserved cluster (Lambda); H100 $3.85 on demand and $0.79 spot, H200 $4.50 on demand and $0.79 spot (Nebius); H100 $3.00 reserved and $4.29 resold (SF Compute); A100 80 GB $1.59, L40S $1.09, L4 $0.49, RTX 4090 $0.74, RTX 5090 $0.99 (RunPod); MI300X $2.39 to $7.86 across six providers (GetDeploying).
- Hyperscalers: H100 capacity block $5.19, B200 $12.36 and GB200 NVL72 $10.58 (AWS); H100 $11.06 and B200 $8.06 on demand (Google Cloud); H100 $12.29 on-demand list (Azure via Vantage); TPU v5e $1.20, v6e $2.70, v7 $12.00 (Google Cloud TPU); CPU $0.045 per vCPU-hour (AWS c7i via Vantage) and $0.01 per Arm core-hour (Oracle Cloud A1).
Token prices, $ per million tokens, input / output
- Frontier: GPT-5.6 Sol 5.00 / 30.00, Terra 2.00 / 12.00, Luna 0.20 / 1.20, cached input at 10 percent (OpenAI); Claude Fable 5.1 and Mythos 5.1 10.00 / 50.00, Opus 5.5 4.00 / 20.00, Sonnet 5 2.00 / 10.00, Haiku 4.5 1.00 / 5.00, cache reads at 10 percent of input, cache writes 25 to 100 percent over input, one rate across the full context (Anthropic); Gemini 3.1 Pro 2.00 / 12.00 rising to 4.00 / 18.00 above 200,000 tokens, 3.5 Flash 1.50 / 9.00, Flash-Lite 0.30 / 2.50 (Google); Grok 4.7 2.00 / 6.00 (xAI). Batch is 50 percent off at OpenAI, Anthropic and Google; OpenAI bills about 2 times input above 272,000 tokens.
- Open weights: DeepSeek V4 Pro 1.32 / 3.96, V4.1 Flash 0.30 / 1.20, Kimi K3 3.00 / 15.00, Qwen3.8 Max 2.00 / 6.00, GLM-5.3 1.40 / 4.40 (Together, Fireworks); DeepSeek V4 Pro 1.30 / 2.60, Llama 3.3 70B 0.10 / 0.32 (DeepInfra); Llama 3.3 70B 0.59 / 0.79, gpt-oss 120B 0.15 / 0.60, gpt-oss 20B 0.075 / 0.30, Llama 3.1 8B 0.05 / 0.08 (Groq); Mistral Large 3 0.50 / 1.50, Small 4 0.15 / 0.60 (Mistral).
Throughput, cost inputs and consumption
- Measured serving: DeepSeek V4 Pro on H200 at 75 / 100 / 150 tokens a second per user gives 5,771 / 5,139 / 2,648 tokens a second per chip and $0.059 / $0.066 / $0.13 a million tokens (SemiAnalysis InferenceX, September 16); DeepSeek R1 on B200 against H100 at 45 tokens a second per user: 5,215 against 740 tokens a second per chip, $0.092 against $0.439 (InferenceX, July); gpt-oss 120B on B200 about 60,000 tokens a second per chip, vendor claim (Nvidia, October 2025).
- Owner cost inputs: colocation $196 per kW per month, North America average, up 6.5 percent on the year (ColoPrice, September 26); US industrial electricity 8.83 cents per kWh, May 2026 (Data Center Scope); H100 $25,000 to $40,000 a chip, B200 $30,000 to $50,000 (IntuitionLabs, September 14).
- Training: DeepSeek V3 $5.58 million and 2.79 million H800-hours, disclosed (arXiv 2412.19437); Grok 4 about $490 million, third-party estimate (Epoch AI); LoRA fine-tune of a 70B model $15 to $30 of GPU time, $5,000 to $15,000 all-in (Stratagem).
- Consumption: a fifty-turn agentic coding session uses about 1,000,000 input and 40,000 output tokens (Vantage, April 15); cache hit rate 7 percent before and 74 to 93 percent after restructuring prompts, a 59 to 70 percent cost cut (ProjectDiscovery, April 10); enterprise generative AI spend $37 billion in 2025, applications 51 percent and infrastructure 49 percent, model APIs $12.5 billion (Menlo Ventures, December 2025); tokens about one quarter of the AI bill (Broadcom ValueOps, September 24).
- Seats: ChatGPT Plus $20 and Pro $200; Claude Pro $20, Team $20 to $100, Enterprise $20 plus usage; Cursor Pro $20, Teams $40; Copilot Pro $10, Max $100 a month (Anthropic, Cursor, GitHub, OpenAI).
Claims register
- $1.07 and $1.53 per H100-hour are the taxonomy’s owner-cost build: $30,000 a chip over 5 years and 8,760 hours ($0.68), 1.0 kW at 1.3 power usage effectiveness and 8.83 cents ($0.11), $196 per kW-month colocation ($0.27); at 70 percent utilisation the same cost over fewer hours. Figure 4 reproduces the arithmetic and lets the inputs move.
- 9 cents to $50 are the ends of the token ladder: measured owned-B200 serving of DeepSeek R1 at owner cost, against the Claude Fable 5.1 list output price. The 543 multiple in the tile is 50 / 0.092. Different models at the two ends; the ladder compares ways of buying a million output tokens, not one model.
- 34 times is the Tokenomics Foundation’s worked example of one task under four architectures, $3.04 to $0.09. It is the foundation’s figure, not ours.
- 8 to 19 times (hosted open-weight price over production cost) and 3 to 500 times (price paid over cost) are the taxonomy’s ranges from steps 2 and 4 of the margin stack.
- 13 percent and 5 percent break-evens are the taxonomy’s: an eight-chip H200 node at $4.50 an hour ($864 a day) against hosted open-weight list, and the same node at owner cost. The token-per-day figures (470 million and 190 million) follow from the 5,139 tokens a second per chip throughput.
- Cache read rates in Figures 7 and 8 follow the vendor table, not the taxonomy’s round “10 percent” rule: 10 percent of input at OpenAI, Google and for Sonnet 5 and Haiku 4.5; 5 percent for Opus 5.5 (0.20 on 4.00); 2.5 percent for Fable 5.1 (0.25 on 10.00). Figure 9 uses Sonnet 5 at 10 percent.
- Figures 7, 8 and 9 are Kinetic Alpha’s own arithmetic on round illustrative inputs and snapshot prices; the commitment discount, the heavy-user multiple, the dealer’s margin and the stresses are assumptions, marked as such on the dials. Figure 9 is stylised: it treats input and output tokens on the self-hosted leg at one cost per token, applies a uniform shift to tokens per task, and assumes the index hedge tracks the H200 rental rate one for one. None of that is a measurement.
- The code example in the working document reads
SI-GPU-H | CF-API | MC-FR-L | TT-INF-ON | WS-AGT | DP-GW | CT-TOK-LIST. Three of those codes are not in its own tables; this piece uses the table codes (CF-SVL,TT-AGT,WS-TA,CT-LIST) throughout. - Related Kinetic Alpha work: The Reserved Contract, Unbundled (layer two), Refiner and Merchant (who owns the chip-to-token margin), The Contract Lost Its Date and The Contract Has a Date. It Needs a Dealer. (what the listed chip-hour future does and does not hedge), The Token Price Index (layer three as an index).