Introduction
AI token economics is the study of what a language model costs per unit of work, and in 2026 the honest answer depends on who is paying. I pay $100 a month for a Claude Max subscription. When I priced 30 days of my own Claude Code use at Anthropic's public API rates, the same tokens came to $2,462.
That gap is not a billing quirk. Subscriptions are sold below the API price of the tokens they deliver, while every product you build on an LLM pays the full API rate. This article is for CTOs and founders who budget AI features: we show the measurement, explain why the subsidy exists, and describe the techniques we use in our own projects to keep token bills small, including MDMA, our open-source answer to the cost of generative UI.
What AI Token Economics Means in 2026
A token is the unit LLMs read and write, roughly three quarters of an English word. Every API call is billed on several token types, and each one has its own price. Treating "tokens" as one number is the most common reason AI budgets miss.
On Anthropic's pricing page, Claude Opus 5.5 costs $4 per million input tokens and $20 per million output tokens. A cache read of a prompt prefix the model has already seen costs $0.20 per million, while writing that prefix into the cache costs $5 (5-minute lifetime) or $8 (1-hour lifetime). So the cost per token can differ by a factor of 100 within one request, depending on whether the token is new, cached or generated.
This is why token economics is mostly about structure, not volume. Two AI agents that process the same text can differ tenfold in price if one of them reuses a stable prefix and the other rebuilds its context from scratch on every call.
AI Tokenomics Is Not Crypto Tokenomics
Search for token economics and most results are about cryptocurrency: supply schedules, staking rewards and the price of a coin. Crypto tokenomics describes a digital currency and the economy built around it. A token in AI is something else: a unit of text or image data that an LLM reads or writes, metered and billed like electricity.
AI tokenomics borrows the word but asks a business question: what does each unit of model consumption cost, who pays for it, and what value comes back? Here the supply is inference capacity, the price is set per million input and output tokens, and the subsidies are real, as the next sections show.
I Measured My Own Claude Code Cost: $100 Plan vs $2,462 on the API
Claude Code stores a transcript of every session on disk, and each model response in it carries a usage record. We read every transcript from the machine, removed duplicated entries (one API response can be logged several times), and multiplied each token type by its public API price for the model that produced it.
The 30-day result
The window covers 17 October to 15 November 2026: 25 active days, 23,358 API calls, and 5.8 billion tokens. Claude Opus 5.5 handled almost all of it (89% of the cost), with Sonnet 5.5 and Fable 5.1 used for some sub-tasks.
| Token type | Tokens (millions) | API cost | Share of cost |
|---|---|---|---|
| Cache reads | 5,668.8 | $1,143 | 46% |
| Cache writes, 1-hour | 91.7 | $768 | 31% |
| Output (incl. reasoning) | 18.7 | $396 | 16% |
| Cache writes, 5-minute | 37.8 | $156 | 6% |
| Uncached input | 0.1 | $1 | 0% |
| Total | 5,817 | $2,462 | 100% |
The Claude Code cost at API rates was about 25 times the subscription price. A typical active day was worth $96 of API tokens, and the busiest day reached $200, which is two months of the subscription in a single day. Put another way, the plan delivered tokens at about $0.017 per million, while the blended API price of the same mix was $0.42 per million.
What the numbers reveal
Three findings matter more than the headline ratio:
- Cache reads are 97% of all tokens but under half of the bill. An agentic coding tool resends its whole context on every step, and caching is the only thing that makes this affordable. Without cache pricing, the same month would have cost about $24,300 at the full input rate.
- Cache writes are the hidden cost. The 1-hour writes are under 2% of tokens, yet they are almost a third of the bill. Any change that breaks the cached prefix (a new file in context, a reordered tool list) is paid for again at a premium.
- Output is small but expensive. Under 0.5% of tokens, 16% of the cost, because output costs five times the input rate and reasoning tokens are billed as output.
Two caveats keep the comparison honest. The figure is a lower bound, because it covers only Claude Code on one computer, not chat in the browser. And API list price is not what the compute costs Anthropic: Martin Alderson estimates the real cost of serving a heavy user at about a tenth of the retail API price. What we measured is API-equivalent value, which is exactly the price your product would pay.
Why Subscription Tokens Are Subsidised
The subscription works for Anthropic because most subscribers use far less than their limits, and because its own tools are built to hit the cache. Heavy users are the exception the business model absorbs. The token economics show up clearly in three public facts.
First, the scale. According to SemiAnalysis research reported by The Register, Claude subscriptions use about 42% of Anthropic's inference compute but bring in about 10% of its revenue. The same research found Anthropic plans give roughly five times the API-equivalent value of OpenAI's, so the subsidy is a competitive weapon, not an accident.
Second, the limits. In July 2025 Anthropic introduced weekly rate limits for Claude Code, saying they would affect fewer than 5% of subscribers. A subsidy that needs a weekly cap is a subsidy the provider is actively managing.
Third, the boundary. In April 2026 Anthropic stopped covering third-party agent tools such as OpenClaw under subscriptions. The stated reason is the one our data shows: first-party tools maximise prompt cache hit rates, and other harnesses do not, which makes the same work much more expensive to serve.
What the subsidy means for your product
A subscription is priced for one person working with a model. It is not a licence to run your product's traffic, and the moment your users talk to a model through your application, every token is billed at API rates. The question in our Claude Max vs API comparison is not which one is cheaper. It is that they are different products with different economics.
So budget AI spend at API prices, never at the price of your own team's subscriptions. Treat the current subscription value as a temporary window: prices and limits have changed several times in two years, and the direction has been toward tighter caps, not looser ones. A product whose margin depends on today's token prices has no margin.
Token Spend Is a FinOps Problem
Once AI features reach production, token spend behaves the way cloud spend did a decade ago: it grows with usage, it is spread across teams, and nobody owns the total. Cloud FinOps answered that with visibility, allocation and accountability, and the same practice now applies to AI spend. As AI adoption moves from pilots to production, the LLM bill becomes a line in the infrastructure budget, and finance will ask the same questions it asks about any other cloud cost.
Measure unit economics, not the monthly invoice
A monthly invoice tells you what you spent, not whether it was worth it. Unit economics does: divide token spend by the unit your business sells. Cost per request is the starting point, but cost per outcome is the number that decides AI ROI, because one outcome often takes several calls.
In FitPal, our AI calorie counter, one user message took about 2.4 LLM calls on average before caching, because the assistant runs a tool loop. So the cost per message was about $0.0082, while the average call cost well under half of that. For the accounting platform described below, the cost per unit is a processed document, which is why we quote it per document and never per call.
Allocate AI spend to users and features
Cost allocation is where AI cost management usually breaks first: one API key, one invoice, and no idea which feature burns the budget. In FitPal we log every call with the user, the prompt, completion and cached token counts and the actual cost in USD, so token consumption can be grouped per user, per day and per call. The admin panel shows that AI cost per user before anyone has to ask.
Our CMS agent adds a second axis. Each role, such as writer, SEO auditor or quick tasks, has its own default LLM, and each brand can override it, so the price of a task can change per brand without a deploy. The next section shows how that routing cuts the bill.
Forecast the budget from the token mix
Forecasting starts with the token mix, not the token count. My own month was 97% cache reads by volume, yet cache writes and output made up more than half of the cost, so a forecast built on one average price per token would be wrong in both directions.
Model consumption also shifts with every release. Reasoning models add reasoning tokens that are billed as output, and agentic workflows multiply the calls per task. Build the budget from measured input and output tokens per task, multiply by expected volume, and keep headroom for the next model change.
Governance: set limits before you need them
Governance means every AI workload has an owner, a budget and a hard limit. FitPal enforces three layers: a daily ceiling of $3 and 200 requests per user, AI credits tied to real cost (since 9 November 2026, one credit equals $0.001 of model spend), and a cap of eight LLM rounds per reply. One runaway agent loop cannot burn a month of budget in an afternoon.
The paths that need no LLM cost users no credits, so the cheapest path for us is also free for them. In an enterprise, the same controls work per department or per client, which turns AI spend into something finance can plan. This is financial accountability for AI initiatives: the business value of a feature is only clear once its cost is.
How We Cut Token Costs in Our Own Projects
Our approach to token optimization follows one rule: cut token consumption before you negotiate token prices. We build and run AI features for clients and for our own products, and the four techniques below come from that code, not from a vendor checklist. If you are still estimating the build itself, our breakdown of AI development cost covers that side; this section is about run cost.
Cache the stable prefix, never the user data
In FitPal, the system prompt is split into static rules and dynamic context, and the rules carry a cache breakpoint. User data never goes into the static part, because one personal detail there would break the cache for everyone. A second breakpoint on the last user message lets each round of the tool loop reuse what the previous round sent.
The cache also depends on who serves the model. FitPal calls Claude through OpenRouter, and when requests landed on Amazon Bedrock we measured zero cache hits in November 2026, so the provider order now puts Google Vertex first and keeps Bedrock only as a fallback. Even the clock matters: the current time sits in the dynamic context, so we freeze it once per reply, because a minute changing between two tool rounds would invalidate the cached history.
We measured the effect in production on 9 November 2026. Before caching, one active user cost about $0.0082 per message, with roughly 30,000 input tokens per model call. After the change, a cached round with 23,559 of 28,537 input tokens served from cache cost $0.00096, about three times less than an uncached round. Our practical guide to prompt caching explains the breakpoint placement and when the 1-hour lifetime pays off.
Caching is not universal, though. In a document-processing platform we built for an accounting client, the fixed instruction is only a few hundred tokens and the document text is new every time, so caching saves only 5 to 10% of input. There, the savings had to come from somewhere else.
Send fewer tokens in the first place
That same platform shows how much the input format matters. The first version sent raw OCR geometry to the model, about 95,000 tokens for a one-page invoice. Sending clean reading-order text instead cut it to about 3,000 tokens in and 300 out. Priced on 85 real documents, this fix and two other configuration changes (a cheaper OCR mode and a smaller model) take the projected cost per document from $0.35 to about $0.006, and a tiered design targets about $0.004.
FitPal applies the same discipline to conversation history. Only the three newest turns are sent in full, and older turns lose their tool calls and tool results. Tool outputs above about 8,000 tokens are replaced with a hint to narrow the query, images travel only with the last two user messages, and documentation for UI components the app never uses is trimmed from the prompt, which saves about 2,500 tokens on every call.
Route each task to the cheapest model that holds quality
Our CMS agent does not run every task on one LLM. Each role has its own default: a strong reasoning model for SEO audits, a fast and cheap one for meta descriptions and keywords, and a Flash-class model for writing, with every role configurable per brand. Paying top-tier prices only where the extra quality changes the outcome is the single biggest lever on LLM token cost after caching. The full pattern, including failover, is in our article on how we built an LLM router.
Answer without a model when you can
The cheapest token is the one never sent. FitPal handles common actions such as logging a submitted meal, recording a weight or showing the remaining calories for the day through deterministic code paths that make no model call at all. Messages that look like pasted code or SQL get a fixed reply, also without a model call.
FitPal skips whole model rounds too. After the model logs a meal from a form, the confirmation comes from a template instead of a second round, and a monthly report starts with 30 days of data already fetched and summarised in code, so the model writes the answer instead of calling tools to collect numbers. Data sources are ordered by price: our own food catalogue first, the free Open Food Facts database second, and a paid web search only after the user approves it on a consent card, one search per approval.
In MDMA, the validator first runs its six automatic fix strategies, which cost nothing, and only the errors that remain go to an LLM fixer. Our agent loops also carry hard caps on iterations and tool calls (in FitPal, eight model rounds per reply), a pattern we described in our guide to building an AI agent.
Matt Sadowski
CEO of Mobile Reality
Cut What Your AI Agent Costs per Task
We instrument AI agents to show what every task costs, then lower the bill without lowering quality.
Per-call USD pricing rolled up per task and per conversation.
Context trimming, so each call carries only what the step needs.
Role-based model routing and prompt caching designed for your providers.
Fallbacks that never retry errors that will fail again.
AI automation measured before and after every change.
MDMA: Generative UI Designed for the Token Bill
Generative UI, where a model answers with forms, tables and approval steps instead of plain text, is one of the most token-hungry patterns in AI products. Most formats ask the LLM to produce verbose JSON and to read a long specification on every request. MDMA (Markdown Document with Mounted Applications) is our open-source answer: the model writes Markdown with small embedded YAML blocks, and the app renders them as interactive components.
What the benchmark measured
We tested five formats with each project's own published prompt and validator: 1,647 generations across Claude Opus 5, GPT-5.6-terra and Gemma 4 26B, with five repeats per scenario. The full benchmark report is public, together with the code.
| Format | System prompt (tokens) | Mean output on Opus 5 (tokens) | Renders every time on Gemma 4 26B |
|---|---|---|---|
| MDMA | 5,910 | 1,666 | 94.4% |
| OpenUI Lang | 6,978 | 2,125 | 50.0% |
| json-render | 8,466 | 4,019 | 38.9% |
| A2UI | 16,085 | 3,892 | 44.4% |
The system prompt is paid on every request, so MDMA's prompt being about a third the size of A2UI's is a permanent saving, not a one-off. On Opus 5, MDMA output was less than half the size of json-render or A2UI, and only 4.4% of MDMA answers hit the 8,192-token output ceiling, against 12.2% for json-render and 52.2% for AGenUI. A truncated answer is a fully paid answer you cannot use.
The last column matters most for cost. MDMA kept the same 94.4% "renders in all five repeats" rate on a small open-weight model as on Opus 5, while the other formats lost between 39 and 44 percentage points. A format that only works on a frontier model locks you into frontier prices, and as the report puts it, "cheap output nobody can render is not cheap." Our comparison of A2UI and MDMA covers the format differences in detail.
Two more design choices that save tokens
MDMA data sources let the model write only a reference, such as a source name and parameters, while the application fetches the rows for a table or chart. The data never passes through the model's output, so a 500-row table costs the same as a 5-row one.
We also fine-tuned our own model, MobileReality/mdma-gemma4-26b-dsl-unsloth-v1, on a compact one-line intent language. On our 95-case holdout evaluation it produced a valid document every time, using on average about 670 prompt tokens and 135 output tokens per document. We have not yet published a cost per request for it, so we do not claim a dollar saving; the token counts are the measured part.
Conclusion
AI token economics comes down to one uncomfortable fact: the price you see in your own subscription is not the price your product will pay. My $100 Claude plan delivered $2,462 of API-equivalent tokens in 30 days, and any feature you ship will pay the second number, not the first.
- Subscription tokens are subsidised, and providers already manage that subsidy with weekly limits and tool restrictions. Budget products at API rates.
- Most of an agent's tokens are cached context. Cache hit rate and cache write discipline decide the bill more than the model's list price.
- Cut tokens before you cut prices: clean inputs, trimmed history, deterministic paths and iteration caps often save more than switching models.
- Treat AI tokenomics as a FinOps discipline: measure cost per outcome, allocate token spend to users and features, and set hard limits before launch.
- Route each task to the cheapest model that passes your quality bar.
- Output format is a cost decision. MDMA uses smaller prompts and shorter outputs, and stays reliable on small models, which keeps generative UI affordable.
If you want to know what your AI feature will cost at API prices before your users find out for you, start by logging the usage of every call by token type. Then talk to us about where the tokens go.
Frequently Asked Questions
What is AI token economics and how is it different from crypto tokenomics?
AI token economics measures what a language model costs per unit of work, analyzing how different token types—such as new input, cached context, and generated output—impact the bottom line. Unlike crypto tokenomics, which focuses on blockchain supply schedules, staking incentives, and token trading prices, AI tokenomics treats tokens as metered units of text or image processing billed like electricity. It answers fundamental product questions: what each interaction costs to compute, who pays for it, and whether the feature delivers positive unit economics.
Why was the API cost for the same Claude Code usage 25x higher than the $100 subscription?
Across 30 days and 5.8 billion tokens of real-world Claude Code usage, public API rates amounted to $2,462 compared to the fixed $100 Claude Max plan. The subscription delivered tokens at an effective price of roughly $0.017 per million, whereas the blended retail API price of that same workload was $0.42 per million. This discrepancy exists because personal subscriptions package heavily subsidized inference designed for human workflows, whereas applications interacting with an LLM via the API must pay full commercial rates for every token.
Which token types cost the most in an agentic coding workflow?
In our 30-day benchmark, cache reads accounted for 97% of all tokens but represented under half of the bill (46% at $1,143), proving that caching is essential for agentic workflows to remain viable. The largest hidden expense was 1-hour cache writes, which made up less than 2% of total tokens yet generated nearly a third of the bill ($768) because breaking the cache prefix incurs premium write rates. Generated output—including reasoning tokens—accounted for only 0.3% of token volume but drove 16% of total spend ($396) due to higher per-token generation pricing.
Why are subscription tokens cheaper than API tokens?
Subscription pricing operates on an aggregate model where the provider absorbs heavy power users because the vast majority of subscribers remain far below their limits. Providers also strictly control their own client harnesses to maximize prompt cache hit rates, drastically lowering the raw compute required to run agent sessions. Because subscriptions are subsidized loss leaders intended for individual developers rather than automated multi-user apps, building product margins around subscription prices creates an unsustainable business model.
How can I reduce token costs in my own AI features?
The most effective strategy is reducing token consumption before attempting to negotiate prices: cache stable system prompts, clean input data, and trim conversation history. In our AI product FitPal, placing prompt cache breakpoints cut the cost of an active message round from $0.0082 down to $0.00096, while routing common user intents through deterministic code paths avoided model calls entirely. Teams should also route simpler subtasks to lighter models and adopt lean data formats like our open-source MDMA, which slashes prompt and generation overhead compared to verbose JSON formats.
More on AI Cost, Small Models and Evaluation
What an AI system costs, which model it runs on, and how you prove it still works are one decision, not three. These articles cover the build and run cost, model choice and the evaluation that makes switching safe:
- LLM Router: How We Route Models by Cost, Quality and Failure
- Prompt Caching: A Practical Guide for Claude, OpenAI, Gemini
- Self-Hosted LLM Guide: Hardware, Tools and When It Pays Off
- SLM vs LLM: Key Differences and When Small Models Win
- Fine-Tuning LLMs: A Guide From Our Gemma 4 Case Study
- AI Development Cost in 2026: What Drives It and Real Ranges
- LLM Evaluation in Practice: How We Test Across 32 Models
- Context Is King: How to Serve It With Context Engineering
- Structured LLM Output Without JSON Schemas | MDMA
- Build AI Agents with 75+ Deployments Cutting Costs 60% in 2026
Want to know whether a smaller or self-hosted model could handle part of your workload? Our custom AI model development team starts with an evaluation on your own cases.
