Where does agent spend actually go?
The bill may include information sent to the model as well as the answer it writes. A long task can send some material repeatedly, including earlier messages, file contents and search results. Review those inputs and the number of attempts before deciding that a different model is the only way to reduce costs.
- Resent history: every turn re-bills the whole transcript so far
- Tool results: a fetched page or a large file lands in context and stays
- Retries: a failed tool call bills the turn that broke and the turn that repairs it
- Abandoned runs: a loop that hits a wall still charged for every step it took
How to read published usage prices
| Model | Input | Output | Cached input |
|---|---|---|---|
| Claude Fable 5.1 | $10.00 | $50.00 | $0.25 read |
| Claude Opus 5.5 | $4.00 | $20.00 | $0.20 read |
| Claude Sonnet 5.5 | $2.00 | $10.00 | $0.10 read |
| Claude Haiku 5.5 | $0.10 | $0.50 | $0.01 read |
| GPT-6 Sol | $2.00 | $10.00 | $0.20 |
| GPT-6 Luna | $0.10 | $0.50 | $0.01 |
| Grok 4.7 | $2.00 | $6.00 | $0.50 |
Compare like with like: input is what the model reads, output is what it generates, and cached input is eligible material reused from storage. The table records published rates at its stated date. Check current prices and request conditions before budgeting a live service.
Where to look for avoidable costs
Caching means storing eligible input so it can be reused at a different rate. It is not necessarily free. Some systems require the beginning of a request to match a previous request exactly. Changing a timestamp or instruction near the start can reduce reuse. Ask your developer to inspect actual cache usage rather than assuming a discount.
resp = client.messages.create(
model="claude-sonnet-5",
max_tokens=2000,
cache_control={"type": "ephemeral"},
system=STABLE_PROMPT, # no clocks, no request ids, no random order
messages=history,
)
print(resp.usage.cache_read_input_tokens) # 0 on repeats means it is broken
print(resp.usage.input_tokens) # uncached, billed at full rateHow do you route a task to a cheaper model?
Routing means choosing a model for a particular step. Test a less expensive option for sorting or extracting information, and a more capable option for difficult analysis. Write down why each model is selected and what causes the process to ask for help.
Changing models can affect cache reuse and add work. A cheaper request that needs several retries and a rewrite may cost more overall. Compare complete, reviewed results.
Set spending and retry limits before running
Set limits on spending, runtime and repeated attempts. When a limit is reached, the agent should stop and report what is complete and what remains. Someone can then decide whether to continue.
- A hard cap on turns per run, enforced, not a warning in the prompt
- A cap on tool calls, pages fetched, and files read in one run
- A wall clock limit on every scheduled or background job
- A monthly dollar ceiling on the key, set at the provider console
- Approval before the agent can send, publish, deploy, delete, or spend
budget:
max_turns: 12
max_tool_calls: 40
max_wall_clock_minutes: 15
on_exhausted: stop_and_report_partial
gates:
requires_approval:
- send # email, DM, anything outbound
- publish # site, listing, social
- deploy
- delete
- spend # any paid API or new credentialWhat should you actually measure?
Track the cost per accepted result. Include unsuccessful attempts, tools, review time and corrections. Compare that total with the previous process to decide whether to expand, adjust or stop the automation.
- Cost per accepted output, broken out by workflow
- Correction rate: how often a person rewrites the result
- Share of runs that hit a ceiling instead of finishing
- Cache hit rate on the two or three workflows you run most

Check whether existing subscriptions cover your trial before adding usage-billed access. Where an API is needed, set a budget for that task and require approval before increasing it.
For an illustrative trial, count all attempts needed to prepare ten acceptable reports, including any rejected drafts. Add the model and tool charges, then record the staff time spent checking and fixing the reports. Compare that with preparing the same reports by your current method. This is a way to measure your own process, not a claim that AI will save a particular amount. If the reports become faster to draft but much slower to check, improve the instructions or source material before increasing the workload.
Is a flat subscription cheaper than an API key?
Compare the work and limits included in each option. A subscription may suit interactive use, while an API charges by usage and may support a different workflow. Check current terms and measure representative tasks.
How much does prompt caching really save?
Savings depend on the provider, cache rules and how much eligible input is reused. Check recorded cached usage and the full bill, including output and tools, rather than applying a discount to the whole task.
Do approval gates belong in a cost conversation?
Yes. Approvals can control new paid connections or budget increases, while enforced spending, runtime and retry limits control usage during the task. Use both where appropriate.
Set a budget for the finished task
Track the complete run, including retries and tools, rather than just the token rate. We can help define a bounded first workflow and decide what evidence would justify using a more capable model.