.svg)
The tokens are 2% of it. The rest is the human finishing the job.
Budget for one model call and you'll be wrong by roughly seven times, because an agent re-sends its whole conversation on every turn. But that's not the number that decides anything. Once you count the tasks a human still has to finish, model tokens are about 2% of what the agent really costs you. Raising the share of work it completes on its own is worth more than any token optimisation you will ever ship.
Ask five sources what an AI agent costs to run and you'll get answers two orders of magnitude apart. That isn't sloppiness. They're measuring different things and none of them says which.
This guide fixes that. It separates the three costs that get mashed together, shows the mechanism that makes agents expensive in a way single-call products aren't, and works through one real task shape end to end with published rates.
Every price here was read from the vendor's own pricing page on 31 August 2026. The arithmetic is reproducible: the formula is in the article, so you can run it on your own numbers rather than trusting ours. If you're scoping AI agent development right now, this is the model we use on the call.
What Actually Drives an AI Agent's Cost
Three separate ledgers, and almost every published estimate mixes at least two.
Build cost is a scoping conversation and we cover it in our breakdown of what an AI MVP actually costs. This article is about ledgers two and three, because those are the ones that decide whether the thing you built is worth keeping.
Why Do Published AI Agent Costs Disagree So Much?
Because they answer different questions and label them the same way.
| Source | What it says | What it's actually measuring |
|---|---|---|
| CloudZero | Agent cost is dominated by infrastructure and orchestration, not the model | Enterprise FinOps, agents already at scale |
| Tekrevol | AI agent development from roughly five figures upward | Build cost, quoted as an agency project |
| Codebridge | Frames the metric as cost per successful task | Run cost, with a failure rate applied |
| Kunal Ganglani | Hundreds of dollars a month for a working agent | Run cost, low volume, single agent |
| Cowork | Token economics with optimisation guidance | Run cost, token layer only |
Sources: CloudZero, Tekrevol, Codebridge, Kunal Ganglani, Cowork.
None of them is wrong. A build quote and a monthly token bill genuinely are different numbers. The problem is that a founder reading three of these in an afternoon comes away thinking the range is $150 to $20,000 a month for the same thing, which makes the figure useless for planning.
So ignore the ranges. Learn the mechanism instead, because the mechanism is the same whoever you buy from.
Why an Agent Costs More Than the Number You Budgeted
Here's the part that catches people, and it has nothing to do with model choice.
A chatbot answers once. An agent works in a loop: think, call a tool, read the result, think again. And on every single turn it re-sends the entire conversation so far, because the model has no memory between calls. Turn six pays for turns one through five all over again.
That makes token consumption grow with the square of the turn count, not linearly.
Total input tokens = turns × (system prompt + user request) + (output per turn + tool result per turn) × turns × (turns − 1) ÷ 2
The second term is the one that hurts. Double your turns and it quadruples.
Work it through on a six-turn loop with a 1,800-token system prompt, a 400-token request, and 880 tokens of output plus tool result per turn:
- What you'd budget for one call: 2,200 input tokens
- What the loop actually sends: 26,400 input tokens
That's twelve times the input for six turns of work. This is the single most useful thing to understand about agent economics, and it's why "we'll just use a cheaper model" so often fails to move the bill.
If you want an analogy for it: imagine briefing a contractor who forgets everything the moment they leave the room. Every time you want the next step, you re-read them the entire brief, plus everything they've told you so far, plus every document they've looked at. The sixth conversation is not six times the first one. It's much worse, and the gap widens with every step you add.
Two practical consequences follow, and both are worth checking on your own system today. First, your cost is far more sensitive to turn count than to model choice, so an agent that wanders costs real money even when it eventually gets the right answer. Second, anything you put in the conversation early is something you pay for on every subsequent turn, which is why a 3,000-token system prompt is a much bigger decision in an agent than it is in a chatbot.
What Do the Models Cost in 2026?
Published list rates, read on 31 August 2026. Recheck before you budget.
| Model | Input | Cached input | Output | Cache read multiple |
|---|---|---|---|---|
| Claude Haiku 4.5 | $1.00 | $0.10 | $5.00 | 0.1x |
| Claude Sonnet 5 | $2.00 | $0.20 | $10.00 | 0.1x |
| Claude Opus 5 | $5.00 | $0.50 | $25.00 | 0.1x |
| gpt-5.6-luna | $0.20 | $0.02 | $1.20 | 0.1x |
| gpt-5.6-terra | $2.00 | $0.20 | $12.00 | 0.1x |
| gpt-4.1-mini | $0.40 | $0.10 | $1.60 | 0.25x |
Sources: OpenAI API pricing and Anthropic pricing, both per million tokens, checked 31 August 2026.
The cached column is the one to read carefully. A cache hit costs a tenth of standard input on most current models, and an agent loop is almost entirely re-sent context. That makes caching the highest-leverage token optimisation available, and it's frequently left switched off.
A Worked Example: One Support Agent
Same task shape as above. A customer emails about an order, the agent looks up the order, checks shipping, reads the returns policy, and drafts a reply. Six turns, Claude Haiku 4.5.
| Scenario | Input tokens | Output tokens | Per task | At 20,000 tasks |
|---|---|---|---|---|
| What you budget, one call | 2,200 | 450 | $0.0044 | $89 |
| What the loop actually costs | 26,400 | 1,350 | $0.0331 | $663 |
| Caching the system prompt only | 18,750 | 1,350 | $0.0255 | $510 |
| Full prefix caching | 10,230 | 1,350 | $0.0170 | $340 |
Three things fall out of it.
The loop costs 7.5 times the number you would have budgeted. Not six times, which is the turn count, because of the quadratic term.
Caching just the system prompt gets you 23% back. Full prefix caching, where each turn reads the previous turn's context from cache, gets you 49%. That's a configuration change, not an architecture change, and it's the single cheapest win on this list.
And even uncached, at twenty thousand tasks a month, the whole model bill is $663. Hold that number. It matters in a minute.
The Line Items Nobody Budgets
Tokens for the conversation are the part people model. These are the parts they don't.
- Tool definitions, on every request. Anthropic publishes the counts: declaring the browser toolset adds roughly 6,600 input tokens per request, and computer use about 4,500. On a ten-turn loop that's 66,000 tokens of schema before the agent does anything. Six cents a task on Haiku, and you get no output for it.
- Failed and abandoned runs. An agent that loops, gives up, and returns nothing still bills for every turn it took getting there. Budget your retry rate explicitly or it lands in your bill unlabelled.
- Server-side tools. Web search runs $10 per 1,000 calls on both major providers. File search adds $2.50 per 1,000 calls plus storage. These are metered separately from tokens and are easy to miss until the invoice.
- Session runtime. Managed agent runtimes bill for wall-clock time on top of tokens. Anthropic's managed agents meter session runtime at $0.08 per session-hour while the session is running. Long-lived agents pay for waiting.
- Observability. Logging every turn, every tool call, and every input for a system you need to debug is real storage and real ingest cost. It is also non-negotiable, so put it in the model rather than discovering it.
None of these are large individually. Together they routinely add 20% to 40% on top of the conversation tokens, and because they arrive on different invoices from different vendors, most teams never see them as one number. If you take one habit from this article, make it this: build a single monthly figure that includes every line above, and check it against the value the agent produced.
Cost Per Resolved Outcome: The Only Number That Matters
Now the part that reorders everything above.
Your agent does not resolve every task. Some it completes, some it escalates, some it gets wrong and a person catches later. The cost that matters isn't per run, it's per outcome you actually got.
Take a support agent resolving 65% of tickets on its own, which is what CollageDepot's pipeline reports across 5,000-plus emails a month in four languages. The other 35% reach a person. Say six minutes of handling at a $22 loaded hourly rate.
| Per 100 tasks | Amount |
|---|---|
| Agent runs, all 100 | $1.70 |
| Escalations to a human | 35, at $2.20 each |
| Human handling | $77.00 |
| Total | $78.70 |
| Same work, all human | $220.00 |
| Saving | 64% |
Look at the first row against the total. The model tokens are 2.2% of what this agent costs to operate. Ninety-eight per cent is the human finishing what it couldn't.
Which means the lever everyone writes about is the wrong lever.
Spend your engineering time on the failure modes, not the token count. Better retrieval, better tool descriptions, clearer escalation rules, and a tighter evaluation set all raise resolution. Switching to a cheaper model saves you cents and often costs you points of resolution, which is a bad trade at these ratios.
Does that flip at some point? Yes, and it's worth knowing where. If your tasks are long, your model is expensive, or almost nothing escalates, tokens become a meaningful share of the total and optimising them starts to pay. A research agent burning 200,000 tokens a run on a frontier model is a different animal from the support agent above. Run the same two lines on your own numbers before you decide which problem you have, because the answer changes what your next sprint should contain.
There's also a reporting point buried in here. When you present agent ROI internally, the token bill is the number people ask for and the wrong number to lead with. Lead with cost per resolved outcome against the cost of the same work done manually. That comparison survives scrutiny. A monthly API total does not, because nobody in the room knows what to compare it to.
The review model changes the maths
One caveat that matters when you compare agents. Two agents with identical token costs can have completely different economics depending on how the output is used.
CollageDepot's agent resolves autonomously and escalates the rest, so it removes human time from 65% of tickets. Our Greenfield Systems agent works differently: it turns complex manufacturing enquiries into engineer-ready technical handoffs, and every output stays subject to human review. Its 85% figure is an internal test result for producing a correct, review-ready match, not a claim about autonomous production performance.
That design saves drafting time, not review time. It's the right call for technical intake where a wrong product match is expensive, and it produces a smaller but much safer saving. Decide which shape you're building before you model the return, because the two numbers are not comparable.
Want this modelled on your actual workflow?
Send us the task, the tools it needs, and roughly how often a human has to step in. We'll run the loop maths and tell you what it costs per resolved outcome, including when the honest answer is that it isn't worth automating.
Book a free agent cost review ↗Six Ways to Cut Agent Cost Without Breaking It
In order of return per hour of work.
- Turn on prompt caching properly. Half the token bill in the worked example, for a configuration change. Cache the system prompt and tool definitions at minimum, and the growing prefix if your provider supports it.
- Cut turns before you cut model quality. Every turn removed takes a slice of the quadratic term with it. Merging two tool calls into one saves more than it looks like it should.
- Trim tool definitions. Fewer tools, shorter descriptions, tighter schemas. You pay for the whole toolbox on every single request whether the agent uses it or not.
- Cap the loop. A hard turn limit with a clean escalation is cheaper than an agent that spirals. It's also better for the user than a long wait ending in nothing.
- Route by difficulty. Send the easy majority to a small model and reserve the expensive one for cases that need it. This only works if you have an evaluation set that proves the small model holds.
- Batch what isn't interactive. Both providers discount asynchronous processing by 50%. Anything that doesn't need an answer in seconds should not be paying interactive rates.
When an AI Agent Is Too Expensive to Justify
The section we'd rather not write, and the one that saves people the most money.
- Your volume is too low for the fixed cost to amortise. A few hundred tasks a month rarely repays the build and the maintenance, however good the per-task figure looks. The tokens were never the expensive part.
- The task doesn't actually need reasoning at runtime. If the decision is a set of rules somebody could write down, write them down. A deterministic workflow is cheaper, faster, testable, and doesn't fail in new ways each week.
- A human has to check everything anyway. If review is mandatory and full, you're paying for tokens to produce a first draft. Sometimes that's worth it. Often the honest saving is much smaller than the pitch suggested.
- Your resolution rate is stuck below about 50%. At that point the human ledger dominates so completely that the agent is adding cost and latency for a marginal gain. Fix the underlying data or the workflow first.
We build agents for a living and we still open scoping calls with these four, because an agent that gets switched off in month three costs more than the one we didn't build.
The test we'd give you if you're deciding alone: work out what the task costs you today, in human minutes multiplied by a loaded hourly rate. Then estimate what share of it an agent would genuinely finish without help, and be pessimistic, because your first version will be worse than your demo. If those two numbers don't leave a comfortable gap, you don't have an automation problem yet. You have a process worth documenting properly first, and that's cheaper.
How to Instrument This Before You Need It
You cannot manage any of the above without per-task data, and retrofitting it is miserable. Log these from day one, on every run.
- Tokens split four ways: uncached input, cached input, output, and which model served it. One combined number tells you nothing actionable.
- Turn count per task, so you can see the quadratic term moving before the invoice does.
- Outcome, not just completion. Resolved, escalated, failed, or abandoned. This is the field that produces cost per resolved outcome, and it's the one teams skip.
- Tool calls, itemised. Which tool, how many tokens came back, and whether it was metered separately.
- Human minutes spent downstream, even as a rough weekly estimate. It's 98% of your cost in the example above and most teams have never measured it once.
Our guide to building production-ready AI agents covers the logging and error-handling side of this in more detail.
Frequently Asked Questions
How much does an AI agent cost to run per task?
On the six-turn support task modelled above, between $0.017 and $0.033 in model tokens depending on caching, on the cheapest capable model. But per-task token cost is a misleading number on its own. Once human escalations are counted, the same agent costs about $0.79 per task all-in, and the tokens are 2% of that.
Why is an agent more expensive than a single model call?
Because it re-sends the entire conversation on every turn. Token use grows with the square of the turn count, so a six-turn loop sends roughly twelve times the input of one call, not six times.
Does using a cheaper model fix a high agent bill?
Rarely, and it often makes things worse. Model price is one term in the equation; turn count and re-sent context are the terms that dominate. A cheaper model that resolves fewer tasks costs you more overall, because escalations are far more expensive than tokens.
How much does prompt caching actually save?
In the worked example, 23% from caching the system prompt alone and 49% from full prefix caching. A cache hit is priced at a tenth of standard input on most current models. It's the highest-return change on the list and it requires no architectural work.
What's a realistic monthly bill for a production agent?
Model tokens for 20,000 tasks a month on a small model land in the low hundreds. What varies by an order of magnitude between companies is everything else: server-side tool calls, session runtime, observability, and the human time on whatever the agent doesn't finish. Model your own resolution rate before you trust anyone's monthly figure, including this one.
Should I build the agent or buy a platform?
Different question with a different answer per workflow, but the cost model here applies either way. Platforms bundle the tokens into a seat or credit price, which hides the loop maths rather than removing it. Ask any vendor what happens to your bill when average turn count goes from four to eight.
