A month of real AI spend is usually not one giant bill, it is a pile of small decisions: which model you picked, how many tokens you burned, and whether output or reasoning did the damage. The useful number is not just price, it is the pattern, because that tells you where to optimize and where to stop worrying.
Why community spend is more useful than model price charts
Price lists are tidy. Real usage is messy. A coding agent can look cheap on paper and still rack up cost if it keeps re-reading context, retrying failed calls, or generating long outputs. That is why the AI Cost Index exists, and why raw model prices only tell part of the story.
When you look at community spend, you are really asking three questions:
- Which models are people actually using for day-to-day work?
- How much of the bill comes from input tokens versus output tokens?
- Where does the cost spike happen, the model choice, the workflow, or the task itself?
That last one matters most. A model with a low input price can still be expensive if your agent sends giant prompts every few seconds. A pricier model can be the cheaper choice if it finishes the task in fewer turns. Community-level spend exposes those tradeoffs better than a single benchmark ever will.
What the current price spread tells us
Here is the part developers should care about: the spread between models is huge, but the spread in actual spend is often even bigger because usage patterns are uneven.
| Model or basket | Input price per 1M tokens | Output price per 1M tokens | What it suggests in practice |
|---|---|---|---|
| AI Cost Index, Frontier basket | $4.64 blended, 3:1 input:output | Useful for tracking the top end without anchoring on one vendor | |
| AI Cost Index, Budget basket | $0.74 blended, 3:1 input:output | Good baseline for cheaper, high-volume workflows | |
| gpt-4o-mini | $0.15 | $0.6 | Very low input cost, output still matters if your agent rambles |
| deepseek-chat | $0.28 | $0.42 | Balanced low-cost option when you need lots of calls |
| claude-sonnet-4-5 | $3 | $15 | Mid-to-high cost, but often used where quality can reduce retries |
| claude-opus-4-1 | $15 | $75 | Expensive enough that long context and long answers deserve scrutiny |
The table is not a verdict. It is a warning label. The cheapest model on the list is not always the cheapest workflow, and the most expensive model is not always the worst value. That is why the value-for-money view is more useful than a raw price leaderboard.
A worked example: one coding session, real token math
Let’s do the arithmetic the way billing actually works. Assume a coding agent makes a request with 120,000 input tokens and gets back 30,000 output tokens. That is a 4:1 input-to-output ratio, which is common enough in agentic workflows that keep sending context back into the model.
If you run that session on gpt-4o-mini, the cost is:
Input: 120,000 / 1,000,000 × $0.15 = $0.018
Output: 30,000 / 1,000,000 × $0.6 = $0.018
Total: $0.036Same token counts on claude-sonnet-4-5:
Input: 120,000 / 1,000,000 × $3 = $0.36
Output: 30,000 / 1,000,000 × $15 = $0.45
Total: $0.81And on claude-opus-4-1:
Input: 120,000 / 1,000,000 × $15 = $1.80
Output: 30,000 / 1,000,000 × $75 = $2.25
Total: $4.05The math is simple, but the lesson is not. The same session can cost pennies or dollars depending on the model. If that session runs dozens of times a day across a team, the monthly difference becomes obvious fast. That is also why quoting per-token prices is dangerous unless you keep the per 1M tokens unit explicit, because the arithmetic is what matters, not the headline number.
Where community spend usually concentrates
In practice, most spend clusters around a few behaviors:
- Long context reuse, where the agent keeps shipping the whole repo state back into the prompt.
- Retry loops, where the model fails, then gets asked again with even more context.
- Verbose output, especially when a model explains every step instead of just completing the task.
- Mixed-model stacks, where cheap models handle most work and expensive models only touch edge cases.
That last pattern is where the real savings often live. Teams that route routine work to cheaper models and reserve premium models for hard problems usually get a much better spend curve than teams that send everything to one frontier model. If you want a broader market view, the State of AI page is the cleaner way to see how the ecosystem is moving without pretending every workload is the same.
There is also a subtle point here: community spend is not just about model choice, it is about workload composition. A repo-wide refactor, an API integration, and a debugging session all produce very different token shapes. If you only look at monthly totals, you miss the reason the bill changed.
How to think about a monthly budget without guessing
If you are setting a budget for an AI-heavy month, start with workflow buckets, not a single number. For example:
- Routine coding assistance, usually lower-cost and high frequency.
- Deep debugging or architecture work, lower frequency but higher token usage.
- Agent retries and tool calls, often the hidden multiplier.
Then ask which bucket deserves the premium model. Many teams overpay because they use the strongest model for every prompt, even when a cheaper one would finish the job. Others underpay and waste time on retries, which can erase the savings. The point is to make the tradeoff visible, not ideological.
One practical rule: if your workflow is dominated by short prompts and short answers, the budget basket can be enough. If your workflow depends on fewer, more reliable completions, the frontier basket may actually be the better economic choice. That is the kind of nuance a monthly spend view is supposed to reveal.
How to track this without hand-parsing invoices
You do not need to reconstruct spend from billing exports. Run npx mytokentracker and it reads the usage logs coding agents already keep locally, then prints a 30-day cost table at API prices. No account is needed for that local view, and usage data never leaves your machine.
If you want a synced dashboard, create a free account and run npx mytokentracker init. It asks for the API token, uploads history, then syncs every 30 minutes. It works with Claude Code, Codex, GitHub Copilot CLI, Antigravity, OpenCode, Amp, Qwen Code and more. Only daily totals per agent and model are uploaded, never prompts, code, or file names.
MyTokenTracker also captures cost, input/output/cache/reasoning tokens, latency, and success, broken down by provider, model, platform, and use-case. For developers who want the raw numbers, the open data and API are there too, under CC BY 4.0. If you want to inspect model pricing directly, the live model catalog is the place to start.
FAQ
Is community spend a better signal than model price?
Usually yes, because it reflects actual behavior. A cheap model with bloated prompts can cost more than a premium model used efficiently. Community spend shows how people really use the tools, not just how vendors price them.
Why do blended baskets matter?
Because many real workloads are not pure input or pure output. The AI Cost Index uses blended 3:1 input:output baskets to approximate common usage patterns, which is often closer to reality than a single line-item price.
What should I watch first, tokens or dollars?
Watch both, but start with tokens by type. Input, output, cache, and reasoning tokens tell you why the bill moved. Dollars tell you whether that movement matters enough to change your workflow.
If you want to see what your own tools are really costing, start with installing MyTokenTracker.