Article 2 · AI agent costs
Can the same model cost ten times less?
Yes. The same model can cost ten times less to use. It takes a suitable workload, an applicable billing mechanism and results that still pass the same checks.
How much of your current bill can you change?
If most of the bill pays for repeated context, caching can cut it substantially. If the agent reads entire datasets or copies documents between tools, removing that work can save even more. If most of the bill pays for necessary reasoning and output, savings are smaller.
The model sets the rates. Your workflow sets the quantity.
A completed task’s price depends on billable input, output and reasoning tokens, cache operations, service tier, tool charges and the number of calls.
At a fixed rate, using half as many billable tokens in one category halves that category’s cost. Published cache or batch rates can reduce the charge with the same model.
Measure both tokens and money. Fewer tokens do not automatically mean a proportionally smaller bill, because token categories have different prices.
What providers offer
These terms were checked on 12 October 2026. Each comparison keeps its named model unchanged.
| Mechanism | Published example | What it reduces |
|---|---|---|
| Prompt cache | Claude Sonnet 4.6: cached input $0.30 versus $3 per million tokens | Eligible input reads cost one tenth of ordinary input |
| Prompt cache | Claude Sonnet 5.5: cached input $0.10 versus $2 per million tokens | Eligible input reads cost one twentieth of ordinary input |
| Prompt cache | GPT-6.1 Sol: cache reads at 0.05× uncached input | Eligible input reads cost one twentieth; writes are charged separately |
| Context cache | Gemini 2.5 Flash: text cache reads $0.03 versus $0.30 per million tokens | Eligible text input reads cost one tenth; explicit cache storage adds cost |
| Batch API | OpenAI: 50% lower costs than synchronous processing | Supported asynchronous work, with a 24-hour completion window |
Sources: Anthropic pricing, OpenAI cache model differences, Gemini Developer API pricing and OpenAI Batch API.
Keep your model and apply the terms of its endpoint and invoice. A cloud reseller may have different terms.
A tenfold input discount can produce a fivefold bill reduction
Suppose your baseline bill is $100. Of that, $90 pays for input that will become cache hits; the remaining $10 stays unchanged.
At a cache-read rate of 0.1×, the new cost is $9 + $10 = $19. That is an 81% saving, or about 5.26 times less money. Cache creation and other new charges would increase the $19.
The general calculation is:
Remaining cost fraction = (1 − f) + f × r + h.
Here, f is the fraction of the baseline bill eligible for the change and actually receiving it; r is the new rate divided by the old rate; h is additional overhead divided by the baseline bill. The reduction factor is 1 divided by the remaining cost fraction.
These calculated examples set h to zero: the ceiling before added overhead. The share refers to money, not token count.
| Baseline spend receiving cache hits | At a 0.1× read rate | At a 0.05× read rate |
|---|---|---|
| 50% | 1.82× lower total cost | 1.90× lower total cost |
| 90% | 5.26× lower total cost | 6.90× lower total cost |
| 95% | 6.90× lower total cost | 10.26× lower total cost |
| 99% | 9.17× lower total cost | 16.81× lower total cost |
At a 0.05× read rate, at least about 94.74% of the original bill must receive that rate to reach 10× before overhead. At a 0.1× rate, unchanged output and any extra charges pull the total below 10×.
Cache writes and misses belong in the calculation
Anthropic’s cache documentation specifies a 1.25× input rate for a five-minute write and 2× for a one-hour write. Reuse requires an exact match for the cached segment. Cold and warm requests have different costs. Prompt caching documentation.
For an illustrative repeated prefix with 0.1× reads, one five-minute write followed by nine hits costs 1.25 + 9 × 0.1 = 2.15 units. Reading that prefix ten times without caching costs 10 units. The prefix saving is about 4.65× across those calls, before output and changing input are added.
Gemini’s explicit cache has a storage charge. Its caching documentation covers implicit and explicit caching; use the billing fields for your mechanism. A stored context that is rarely reused can cost more than the reads it saves.
Provider prompt caching keeps the full cached input available to the model. Anthropic states that caching does not affect output generation. Each call still generates its response; this is not a guarantee that repeated runs produce identical wording.
Start with actual cache-hit and write records. If your baseline already receives automatic cache discounts, count only the additional improvement.
A worked example that reaches 14×
Take Claude Sonnet 4.6 at the published standard rates of $3 per million input tokens and $15 per million output tokens. Its batch rates are $1.50 and $7.50 respectively. Source: Anthropic pricing.
Assume a task currently sends 100,000 input tokens and generates 1,000 billed output tokens. Suppose tested data selection reduces the input to 10,000 tokens, preserving every required finding and the output length.
| Calculated scenario | Input | Output | API cost per task |
|---|---|---|---|
| Original, standard API | 100,000 tokens | 1,000 tokens | $0.315 |
| Selected context, standard API | 10,000 tokens | 1,000 tokens | $0.045 |
| Selected context, batch API | 10,000 tokens | 1,000 tokens | $0.0225 |
The context change gives 7× lower token cost. Adding the supported batch rates gives 14×. This calculation assumes one successful call per task, no cache use and no extra tool or execution charges. It is not a measured customer result.
The quality assumption is the experiment: can those 90,000 input tokens be removed without losing necessary evidence? Batch processing suits work that can wait. A request that must answer immediately does not qualify.
Large token reductions have been published. Their scope matters.
In the material behind our first article, Anthropic describes loading tool definitions on demand through code execution. Its example reduces token usage from 150,000 to 2,000, a 98.7% reduction. Code execution with MCP.
That shows a large reduction in the described setup. It does not establish a 98.7% reduction in your entire bill or identical quality across your tasks. Generation, other calls, failures and execution still need accounting.
Another route is to remove duplicate model calls. If ten identical, safely reusable read requests previously triggered ten generations, generating once and reusing the stored result removes nine of those calls. That is response reuse, distinct from the provider’s prompt cache, which still generates a fresh output.
Response reuse requires matching inputs, source versions, access boundaries and freshness. It cannot replace a task that needs new evidence or a fresh generation on every request. Storage and validation still have costs.
What will not make a fixed model ten times cheaper
A faster server does not change the same request’s billed tokens or rates. Streaming changes delivery without reducing generated tokens. Shortening the user’s question may barely matter if a large history and tool catalogue dominate the request.
Likewise, lowering a reasoning budget or cutting off the answer changes the work you ask the model to do. Treat that as a quality experiment. An incomplete answer that needs another paid attempt may increase the cost of finishing.
Do not multiply every advertised saving together. Two methods may remove the same cost, interfere with cache reuse or apply to different billing categories. Recalculate the workflow with the provider’s supported rates.
Find the ceiling before rebuilding the agent
Use a representative trace set and billing records. Separate ordinary input, cached reads, writes or storage, billed output including reasoning where applicable, tool charges and repeated calls. Reconcile the totals without counting overlapping usage fields twice.
Identify the largest share you can change. Use the fraction formula to check whether a tenfold target is plausible before implementing it.
Compare the original and revised workflows on the same model version, generation settings, tasks, source data and acceptance criteria. Record failed attempts and retries. Evaluate cost per accepted task, quality and end-to-end time over repeated runs, including cache warm-up and expiry.
If the unchanged part of the bill is already more than 10%, changes confined to the rest cannot deliver a tenfold reduction. Find a valid saving in that part, or set a target the evidence supports.