The Economics of AI Tokens

Every modern language model is billed in a unit that did not exist as a consumer price a decade ago. A token is not a word, not a character, and not a standard measure of intelligence. It is a slice of text chosen by a tokenizer the vendor trained on its own data, then sold back to the market as if it were a barrel of oil. The comparison is imperfect. The economic effect is identical. Once an industry settles on a unit, the unit becomes the battlefield.

As of 1 September 2026, list prices for production APIs span more than two orders of magnitude. Hosted Llama 4 Maverick is offered near $0.15 per million input tokens. Claude Fable 5 charges $10 on the way in and $50 on the way out. OpenAI's flagship GPT-5.6 Sol sits at a promotional $4 and $20. Grok 4.6 is $2 and $6 with a 500,000-token window. Gemini 3.7 Flash is on an introductory $0.75 and $3.75 through year end.

Those numbers look comparable because every vendor prints the same label: dollars per million tokens. They are not the same commodity.

To make the comparison properly, the Round Table loaded the whole rate card into a graph: six vendors, sixteen production models, every published input, cached-input and output rate. The figures below are Cypher queries against that graph rather than eyeballed table reads. Where the graph disagrees with the industry shorthand, the graph is shown.

How tokens work

A large language model does not read English. It reads integers.

Before a prompt reaches the network, a tokenizer splits the raw bytes into a sequence of IDs drawn from a fixed vocabulary. Each ID is a token. The network embeds those IDs as vectors, runs attention across the sequence, then emits one new ID at a time. The decoder maps them back into characters. Billing attaches to both halves of that loop: every ID that goes in, and every ID that comes out.

Almost every production tokenizer descends from byte-pair encoding, the compression algorithm Philip Gage published in 1994 and Rico Sennrich and colleagues adapted for neural machine translation in 2016. Training starts with the 256 raw bytes. The algorithm repeatedly merges the most frequent adjacent pair into a new symbol until the vocabulary reaches a target size, typically 32,000 to 256,000 entries. Common English words collapse into a single ID. Rare names, code identifiers and non-Latin scripts stay split into fragments. Anything the vocabulary has never seen still encodes, because byte-level models can always fall back to raw bytes.

Google's SentencePiece library, released by Taku Kudo and John Richardson in 2018, takes a related path. It treats the input as a raw stream and encodes whitespace as an ordinary character. That design is kinder to Chinese, Japanese and Thai, which do not put spaces between words. Gemini still lives in that tradition. OpenAI's GPT-4o and GPT-5.6 families use tiktoken with the o200k_base encoding, a byte-level BPE vocabulary of roughly 200,000 tokens. Llama 2 used a 32,000-token SentencePiece model. From Llama 3 onward Meta switched to a tiktoken-style BPE of 128,256 tokens, and Llama 4's real vocabulary sits near 202,000.

Anthropic does not publish Claude's encoder, and independent counters treat it as a proprietary BPE. That matters less than it sounds, because Anthropic exposes a count_tokens endpoint that returns the exact count the biller will use. For Claude, the vendor tokenizer is an API call, not an estimate. Any team budgeting Claude traffic off a character heuristic is guessing when it does not have to.

One point of vocabulary hygiene, because it drives real invoice surprises. The Claude tokenizer that raised token counts arrived with Opus 4.7, and Opus 4.8 and Fable 5 inherit it unchanged. Migrating between those three moves counts barely at all. Migrating up from Opus 4.6, Sonnet, Haiku or anything older is where the step change lands, and it runs as high as 1.35 times the same prose. Re-baseline on the model you are leaving, not on the one you are joining.

The industry rule of thumb is stable enough to be useful and wrong enough to be dangerous: one token is about four characters of English, or about three-quarters of a word. A thousand tokens is roughly 750 English words. Code, JSON, tables, URLs, base64 and CJK text all break the heuristic. Korean and Japanese can cost three to five times as many tokens as the same idea in English.

Context windows are denominated in tokens too. A one-million-token window is a budget shared by the system prompt, retrieved documents, tool traces, the user turn, hidden reasoning and the answer. Fill it with a poorly tokenized language or with raw HTML and the usable English capacity collapses. Context marketing and context economics are different conversations.

Does one token equal one token?

No. A token is a private unit. Two vendors can both charge per million tokens while packing different amounts of meaning into each unit, spending different amounts of compute to emit each unit, and attaching different side meters to the same request.

Start with the headline spread.

Figure 1. List output price per million tokens, sixteen production models, log scale. The spread is 167 times. KXCO token graph, list prices 1 September 2026.

Claude Fable 5 output costs 167 times Llama 4 Scout output. On input the spread is 100 times, from $10.00 down to $0.10. That is one product category, one unit of account, and a price range wider than most commodity markets tolerate. It survives because the unit is not standardised and buyers cannot easily arbitrage it.

Vocabularies differ. The sentence "Artificial intelligence is transforming industries." is not guaranteed to produce the same ID count on GPT-5.6, Claude Opus 5, Gemini 3.1 Pro, Grok 4.6 and Llama 4. Differences of five to fifteen percent on ordinary English are common, and on code, markup and non-English prose the spread is larger. Comparing a one-million-token Gemini window with a one-million-token Claude window as if they held the same novel is an approximation, not a fact.

Input and output are different products under one name. Generating a token requires a full forward pass and a sample from the vocabulary. Reading a token is cheaper, and cached reading is cheaper still.

Figure 2. The output multiple: how many times more a vendor charges to write a token than to read one. Range 2x to 8.33x, mean 4.62x.

The multiple runs from 2 times to 8.33 times, averaging 4.62 across the board. The commonly quoted three-to-six band is too narrow at both ends. Grok 4.3 charges twice as much to write as to read. Gemini 3.5 Flash-Lite charges 8.33 times. Grok 4.6 is the gentlest flagship at 3 times, which is the commercial point of the model: at equal input price to GPT-5.6 Terra or Claude Sonnet 5, it charges half or less on generation.

The multiple only matters weighed against your own output share. A verbose model on a low multiple loses to a terse model on a high one.

Reasoning tokens are a third category the chat interface hides. A model set to high effort may emit thousands or tens of thousands of intermediate tokens before the visible answer appears, and those are billed at the output rate. A short final paragraph can cost as much as a long essay. OpenAI's reasoning-effort controls, Anthropic's effort tiers, Google's thinking levels and DeepSeek's thinking toggle all convert "try harder" into a meter that runs whether or not the user sees the scratch work. On the current Claude models the older fixed thinking-budget parameter is gone entirely, replaced by adaptive thinking with an effort setting from low to max, so effort is the dial that moves the bill.

Cached input is a fourth token. Every major vendor discounts repeated prefixes: system prompts, tool schemas, retrieved corpora that do not change from call to call. The shorthand is that cache hits price at ten percent of fresh input. That is the modal number, not the universal one.

Figure 3. Prompt-cache discount on repeated input, thirteen models that publish a cache rate, beside each output multiple. Grok 4.6 is the shallowest at 75 percent.

Nine of the thirteen models that publish a cache rate sit at exactly 90 percent off. DeepSeek goes further, discounting a repeated prefix by about 96 percent, which is why a stable system prompt on DeepSeek is very nearly free. And xAI is the outlier in the other direction: Grok 4.3 gives 84 percent, Grok 4.6 only 75 percent, the shallowest cache on the board.

That produces the sharpest single trade in the table. Grok 4.6 pairs the best flagship output multiple with the worst cache discount. Which of those two facts dominates is decided entirely by the shape of your traffic. Long stable prefix and short answers, and the weak cache costs you more than the cheap output saves. Short prompts and long generated answers, and Grok 4.6 is the cheapest flagship on the board. The rate card cannot tell you which you are. Your logs can.

Anthropic prices the same discount from the other side: a cache write costs a premium, 1.25 times the fresh input rate, and every subsequent hit is 90 percent off. On Fable 5 that is $12.50 to write and $1.00 to read against a $10.00 list. The write premium pays for itself on the second call.

Long-context surcharges split the unit by position. Gemini 3.1 Pro doubles input above 200,000 tokens and lifts output from $12 to $18. GPT-5.6 Sol moves from $4 and $20 to $8 and $30. Grok 4.6's fast variant is a straight doubling. DeepSeek splits the calendar instead of the window: weekday peak hours cost twice off-peak, and weekends are off-peak all day. The token did not change. The clock and the cursor did.

The practical test. If two invoices both say 1.2 million tokens, ask four questions before comparing them. Which tokenizer? Input, cached, reasoning or output? Was the request above a context-surcharge threshold? Was it peak or batch? Until those are answered, one token does not equal one token.

How each family bills

The 2026 market is a stack of product lines that look similar in a pricing table and behave differently in production. The sketches below are economic, not architectural.

OpenAI, GPT-5.6 Sol, Terra and Luna. OpenAI still sets the reference rate card finance teams paste into spreadsheets. The 5.6 generation splits a 1.1 million token window across three price points. Sol is the flagship at a promotional $4 and $20 through 21 November 2026, cached input $0.40. Terra is the default production brain at $2 and $12. Luna is the volume tier at $0.20 and $1.20 after an 80 percent cut on 30 July. Long prompts jump a tier. Pay Sol when the task is agentic and failure is expensive, Luna for classification and routing, Terra for the rest.

Anthropic, Claude Fable 5, Opus 5, Sonnet 5 and Haiku 4.5. Anthropic sells quality and a clean cache story. Fable 5 is the scarce top of the book at $10 and $50. Opus 5 is $5 and $25 and is the model most enterprises reach for when they want Claude running tools for a long time. Sonnet 5 launched at an introductory $2 and $10 that Anthropic made permanent in August, cancelling a scheduled move to $3 and $15 on 1 September. Sonnet is the volume Claude, so a 50 percent avoided increase is a real budget event. Haiku 4.5 remains the cheap fast tier at $1 and $5, and is the only model in the range on a 200,000-token window rather than a million. Batch is half. Fast mode on Opus 5 doubles the rate to $10 and $50. The economic tell is verbosity plus thinking: leave max tokens uncapped and effort high and Sonnet will write a memo nobody asked for and bill it at output rates.

Google, Gemini 3.x Pro and Flash. Multimodal context at aggressive Flash pricing. Gemini 3.1 Pro lists at $2 and $12 below 200,000 tokens and $4 and $18 above. Gemini 3.7 Flash is on an introductory $0.75 and $3.75 through 31 December 2026, reverting to $1.50 and $7.50 in 2027 if the card holds. Flash-Lite is the bargain bin for classification, though note from figure 2 that it carries the steepest output multiple in the market. Audio and video have separate meters. The 200,000-token cliff is the operational fact to design around: chunk retrieval so the average request stays under the line, or accept that a long due-diligence pack is a different product at a different price.

xAI, Grok 4.6 and the 4.x stack. Grok 4.6 launched 12 August 2026 at $2 and $6 with a 500,000-token window. Grok 4.3 sits lower at $1.25 and $2.50 with a full million-token window and the lowest output multiple on the board. For output-heavy work, drafting, rewriting, agent traces written back into the log, the multiple matters more than the input sticker. Weigh that against the cache position in figure 3.

DeepSeek, Llama, Qwen and the open-weight floor. The floor is no longer a toy. DeepSeek V4 Pro lists near $0.66 and $1.98 off-peak, doubling in declared peak windows on Beijing time. V4 Flash undercuts that again. Hosted Llama 4 Maverick prints around $0.15 and $0.60, and Scout trades a little capability for a 10 million token window at $0.10 and $0.30. Qwen, GLM, Kimi and MiniMax fill the same band. The catch is operational: peak pricing, regional latency, data-residency policy, and the fact that open weights on somebody else's host is still somebody else's meter. Self-hosting swaps token price for GPU rent, utilisation and engineering time, and only wins when the workload is steady enough to keep the cluster full.

Snapshot: list API prices, early September 2026

USD per million tokens, standard paid API tiers. Cached column is the cache-hit rate where published. Promotional and long-context rows move without notice.

What the whole thing costs on one real request

Rate cards are abstract. Take one support turn and price it across the entire market: 2,000 input tokens of which 1,400 are a stable cached prefix, and 400 visible output tokens.

Figure 4. One identical support turn priced across the market: 2,000 input tokens, 1,400 of them a cached prefix, 400 output tokens. The cached call spans 90 times.

On the cached call the market spans 90 times, from $0.000306 on DeepSeek V4 Flash to $0.0274 on Claude Fable 5. Claude Sonnet 5 lands at $0.0055 and Grok 4.6 at $0.0043.

Now break the two things operators most often break. Lose the cache and turn thinking up so the model emits 8,000 hidden tokens before its 400-token answer. The identical request multiplies by 8.5 to 16.7 times on every model on the board. Fable 5 goes from $0.0274 to $0.44. Sonnet 5 goes from $0.0055 to $0.088.

That is the whole argument in one chart. The gap between the best and worst way to run one request on one model is larger than the gap between most vendors. Model choice is the decision buyers agonise over. Cache architecture and effort control are the decisions that actually move the invoice, and they are entirely within the buyer's gift.

What is expensive to do

The expensive move is almost never using AI. It is using a frontier model as a default verb. Five patterns dominate 2026 invoices.

Unbounded reasoning. High effort is a multiplier on output. A hard coding or maths call can emit 8,000 to 30,000 hidden tokens before a short answer. At $20 or $25 per million that is cents per call and thousands of dollars a day at agent scale. Effort controls exist because the vendors know this.

Long, dirty context. Retrieval that stuffs raw PDFs, HTML and prior chat logs into the window pays twice, once in input tokens and again if the prompt crosses a surcharge threshold. Attention cost grows with sequence length inside the vendor's cluster, which is why the surcharge exists. Clean chunking and tight quoting beat a million-token brag.

Chatty agents with tools. Each tool round trip reprints the history. A twenty-step agent that fails to cache the system prompt and schema re-pays the same 4,000 input tokens twenty times at full freight. Add traces, errors and retries and the input column overtakes output. This is the silent majority of the "why is our bill four times the estimate" tickets.

The wrong language and the wrong file. Non-English support, legal text in Thai or Japanese, and OCR dumps tokenize poorly on English-heavy BPEs. Base64 images inlined as text are a special kind of vandalism. Multimodal endpoints have their own meters.

Premium models on commodity tasks. Classification, PII stripping, language detection and ticket routing do not need Fable 5 or Sol. They need Haiku, Luna, Flash-Lite or an 8B open-weight model. Paying $50 per million output to decide whether an email is urgent is a category error dressed as quality control.

Mistakes to avoid

Most wasted spend is not exotic. It is sloppy operations repeating themselves at machine speed.

• Budgeting with the word heuristic. "We send about 800 words, so that is 1,000 tokens" fails on code reviews, JSON tool calls and bilingual desks. Count with the vendor tokenizer on real traffic before signing a forecast.

• Comparing list prices without a workload mix. A model 20 percent cheaper per output token and 40 percent more verbose loses. Measure tokens per successful task.

• Ignoring cache architecture. If the first 2,000 tokens of every request are identical and you are not getting cache hits, you are donating margin. Check the cache-read counter on the response rather than assuming.

• No max-output cap. Models fill the space you give them. Ask for JSON of a known schema, not a thorough analysis.

• Retry storms. A flaky tool plus an agent that replays the full trace on every attempt turns one failure into a token furnace.

• Leaving thinking on for tasks that do not think. Greeting a user, extracting a date and rewriting a subject line do not need deep reasoning. Default low, escalate by classifier.

• Treating batch and real time as the same SKU. Overnight evaluation, embeddings refreshes and report generation belong on batch or off-peak cards at roughly half price.

• One-model religion. The winning architecture in 2026 is a router. A cheap model classifies intent and difficulty, a mid-tier model does the work, a flagship sees only the residue. Standardising on a single frontier endpoint for political reasons is a tax that never shows up in the model card.

• Forgetting that logs are prompts. Observability stacks that persist every thought token and feed those logs into the next eval set create a second bill and a compliance surface.

Maximising work per token

Maximising tokens is the wrong slogan if it means stuffing the window. The objective is completed work per dollar, subject to latency and quality.

Route before you reason. A Luna, Haiku, Flash-Lite or 8B classifier in front of the expensive model is the highest-return line item in most stacks. Publish the routing rules so nobody silently widens the expensive path.

Make the prefix boring and identical. Cache hit rates of 70 to 90 percent are normal when the system prompt, tool JSON and style guide are byte-identical across calls. A dynamic date, a shuffled tool order or trailing whitespace is enough to miss. Treat the prefix as an API contract. Figure 3 is the reason this is worth engineering time: on most of the board a hit is 90 percent off, and on DeepSeek it is 96.

Retrieve less, quote more tightly. Hybrid search plus a reranker returning three passages beats dumping twenty. Every paragraph you do not send is an input token you do not buy and a distraction the model cannot chase.

Constrain the output shape. Schemas and short instructions cut output tokens more reliably than asking the model to be concise. Against a mean multiple of 4.62, brevity is a direct margin lever.

Cap thinking by task class. Map tickets to effort levels. Reconciliation and novel code get high. Rewrite, extract and classify get none. Review the distribution monthly, because effort settings drift upward the way cloud instance sizes do.

Use the cheap window for memory. Summarise old turns into running state instead of replaying the transcript. A 400-token episode memory plus the last two turns usually beats a 12,000-token archive on both cost and attention.

Exploit the calendar and the queue. Batch APIs, DeepSeek off-peak and overnight eval jobs are the same idea: move delay-tolerant tokens onto a discounted rail. If a job can wait eight hours it should not pay real-time flagship rates.

Measure tokens per successful outcome. Instrument cache hit rate, reasoning tokens, retries and human edit rate. A model that costs more per million but closes the ticket in one pass is cheaper. Finance should see unit economics at the task level, not the vendor level.

Keep an open-weight escape hatch. Even teams loyal to one closed vendor should have a Llama, Qwen, GLM or DeepSeek path for the bottom 60 percent of traffic. It sets a price ceiling the closed vendors have to respect, and it is the only credible threat in a negotiation.

The market under the meter

Token prices have fallen in steps, not on a curve. OpenAI cut Terra 20 percent and Luna 80 percent on 30 July, then marked Sol down from $5 and $30 to $4 and $20 in late August. Google put Flash on an introductory sale through December. Anthropic chose not to raise Sonnet on 1 September. At the same time the ceiling moved up. Fable 5 at $50 output, and legacy high-effort reasoning SKUs that have printed as high as $180 per million output, are the reminder that "AI got cheap" is a statement about the median task, not the hardest one.

Two structural facts sit under those moves, and both connect this rate card to the physical stack underneath it.

Training and serving a frontier model still burns capital at a scale only a handful of firms can finance, and tokens are how that capital is recovered. The KXCO AI-sector ontology at kxco.ai/ontology-live traces where that capital comes from and where it goes. All six vendors in the table above sit on that map: OpenAI carries 60 typed claims, Anthropic 34, Alphabet and Meta 32 each, xAI 30, DeepSeek 17. OpenAI appears in five of the graph's sixteen circular-capital claims and Anthropic in four, which is the same money arriving as an equity note and leaving as a cloud commitment. A token price is the retail end of that structure. When Nvidia lifts supply commitments from $119 billion to $279 billion in a quarter to lock memory, the cost of the HBM under an inference cluster is being set three years ahead of the rate card that recovers it.

Second, inference is no longer one product. Cache, batch, peak clocks, long-context cliffs and thinking budgets let vendors price-discriminate the way airlines price seats. Sophisticated customers reconstruct the fare basis. Naive customers buy the flex fare every time.

There is also a unit risk finance teams underweight. Because tokens are not standardised, a vendor can cut prices by shipping a tokenizer that emits more IDs for the same prose, or raise effective prices by making the default model more verbose. Neither move touches the published rate. The honest comparison is dollars per evaluated task on a frozen set of prompts, refreshed quarterly. Anything else is theatre.

Close

Tokens are the unit of account for generative AI in 2026, and they are a bad unit in the way all early units are bad. They mix compression, language, compute and product packaging. They let vendors publish one number while selling five different things. They punish the wrong languages and the sloppy prompts. They also, for the first time, give operators a meter they can manage.

The firms that spend less next year without getting worse answers will do unglamorous work. They will count with the real tokenizer. They will cache the prefix. They will route. They will cap thinking. They will keep an open-weight floor under the closed-model ceiling. They will stop asking whether one token equals one token, because it does not, and start asking what a completed task costs.

That is the economics. The rest is a rate card.

Companies mentioned in this article: $MSFT, $GOOGL, $META, $NVDA and $AMZN.

Shayne Heffernan, Ph.D., is the founder of Live Trading News, the KnightsBridge Group, Knightsbridge Law and the KXCO.ai ecosystem spanning post-quantum cryptography, identity, attestation and enterprise ontology. The live AI-sector ontology is at kxco.ai/ontology-live.

Pricing in this report is list API pricing compiled from public trackers on or about 31 August and 1 September 2026, loaded into a graph and queried rather than read by hand. The Anthropic rows were additionally checked against Anthropic's own current model documentation. Vendors change cards without ceremony, so verify against vendor documentation before any purchase or forecast. Nothing here is investment advice.