LEARN / AI TOKENOMICS

AI Tokenomics: what tokens actually cost

Every interaction with a large language model is metered in tokens. Most people never look at the meter. This guide explains how the meter works — without hype, and without pretending the numbers are scarier or kinder than they are.

What is a token?

A token is the unit LLMs read and write. It is not a word and not a character — it is a chunk from the model's vocabulary. In English prose, one token averages about 4 characters, so 1,000 tokens is roughly 750 words. Code tokenizes denser (more symbols, more tokens per character), and languages with accents or non-Latin scripts often cost more tokens for the same meaning. Every model family uses its own tokenizer, which is why all cross-model counts — including ours — are estimates.

Input tokens vs output tokens

Providers bill input (what you send: prompt, context, documents, history) and output (what the model generates) at different rates. Output is typically 4-8x more expensive than input, because generating text costs more compute than reading it. Practical consequence: asking a model to rewrite an entire file is billed at output rates, while asking for a diff produces a fraction of the output tokens for the same fix.

Cost per million tokens — current snapshot

Public list prices, USD per 1M tokens, snapshot 2026-07-10. Prices change; always check your provider.

Note the spread: the same million tokens costs $0.28 or $5.00 on input depending on the model. Model choice is the single biggest lever on your bill.

Cached tokens

Most major providers offer prompt caching: if you re-send the same prefix (a long system prompt, a document, a codebase), cached input is billed at a heavy discount — often around an order of magnitude cheaper than fresh input. If your workflow re-sends a large static context on every call and you are not using caching, you are paying full price for the same bytes, repeatedly. Check your provider's caching docs; the details (TTL, minimum size, write costs) vary.

Why long context quietly compounds

Chat interfaces feel stateful, but the model is not. On every turn, the application re-sends the conversation history as input tokens. A conversation's cost therefore grows with its length squared-ish: turn 40 pays for turns 1 through 39 again. This is why “one long chat for everything” is one of the most expensive habits in the Burn Index, and why starting a fresh conversation is often the cheapest optimization available.

Agents multiply everything

An agent is a loop: read context → think → call a tool → read the result → think again. Each iteration re-sends context and generates reasoning tokens you may never read. A task that takes one prompt in a chat can take 15-40 model calls as an agent run. Agents are not evil — they do real work — but their burn rate is structurally higher, and they fail expensively: a retry loop on a failing test bills every attempt. Cap iterations, scope tasks, and read your agent's token reports the way you read your cloud bill. Which is to say: at all.

Ten ways to burn fewer tokens

1. Match the model to the task. Cheap models handle most classification, extraction and routine drafting.
2. Ask for diffs, patches or bullet answers — output is the expensive direction.
3. Start new conversations instead of dragging one chat across topics.
4. Use prompt caching for any large static context you re-send.
5. Cut ritual: greetings, apologies and “act as a world-class expert” add cost, not quality.
6. State the task once, precisely, instead of three times vaguely.
7. Cap agent iterations and give agents narrow, verifiable goals.
8. Send the relevant excerpt, not the whole document or repo.
9. Fix the prompt instead of regenerating and hoping.
10. Measure. Run your recurring prompts through the calculator and multiply by your monthly volume. Then decide if it is fine. (It might be fine.)

FAQ