What an AI agent actually costs

Every conversation about AI budgets starts in the same place: the price per million tokens. It is a clean, comparable, public number, and it is close to the least useful one on the invoice.

Here is why. Anthropic's own measurements put a single agent at roughly four times the tokens of an ordinary chat exchange, and a multi-agent system at about fifteen times. The gap between model tiers is a factor of a few. The gap between architectures is a factor of fifteen.

A cheaper model inside a wasteful architecture costs more than an expensive model inside a disciplined one. That is the whole argument, and everything below is detail.

The six lines

A real budget has six components. Most published estimates cover the first and stop.

1. Model tokens

The published rates, as of August 2026 — check the current pricing before quoting them, because these move:

Note the shape: output costs five times input across the range. Anything that makes the model write more — verbose formats, unnecessary summaries, thinking you did not need — costs five times more than anything that makes it read more.

The spread from the cheapest to the most capable tier here is five-fold. Hold that number against the fifteen-fold architecture multiplier above.

2. The architecture multiplier

This is the line that decides the invoice, and it is the one nobody prices in advance.

An agent is not a chat call. It reads, calls tools, gets results back, reasons about them, and goes again — and every one of those steps carries the whole accumulated context. Anthropic's figures for that: about 4× chat for a single agent, about 15× for a multi-agent system. Separately, multi-agent implementations run three to ten times the tokens of a single agent on equivalent work.

Those multipliers are not waste — they buy real capability, and roughly 80% of the performance difference in Anthropic's research is explained by exactly this token spend. But they must be in the estimate before you build, not discovered in the first month's bill.

3. What you get back

Two mechanisms return a large share of it, and both depend on the shape of the work rather than on the model.

Caching. Cached input is read at roughly a tenth of the base input price. Writing to the cache costs about 1.25× normal, so it pays for itself from the second request that reuses the same prefix. Anything with a large stable preamble — a system prompt, a reference document, a tool list — is a candidate, and this is usually the single largest saving available without changing anything about the model.

The catch is that caching is a prefix match: change one byte anywhere in the prefix and everything after it is invalidated. A timestamp in the system prompt quietly costs you the entire discount, and nothing warns you.

Batching. Work that does not need an answer now runs at half price through the batch API. Overnight processing, backfills, bulk classification — if nobody is waiting, this is a straight 50% off.

4. Tools and infrastructure

Server-side tools carry their own meters — searches, retrieval, execution time — and the systems the agent calls are the systems you already pay for, now being called far more often. An agent that queries your database on every step is a load-testing exercise you did not schedule.

This line is usually small next to tokens. It is worth naming because it is the one that surprises operations rather than finance.

5. The people who consume the output

Here is where published estimates stop and reality starts.

When Mozilla's agentic pipeline surfaced 271 vulnerabilities in Firefox, more than a hundred people were involved in patching, reviewing, triaging and shipping the result. The pipeline moved the bottleneck from finding flaws to processing them — it did not remove it.

Do the arithmetic on your own case honestly. An agent that generates thirty findings a day where your team can action five has not saved you anything; it has built a queue. Whatever you pay in tokens, the salary line attached to that output is usually larger.

6. Building and maintaining the harness

The last line is the one this site keeps returning to, because it keeps being the deciding one.

An agent whose output nobody can verify produces work, not value. Building the thing that checks it — the referee, the test, the reconciliation, the eval set — is a real engineering cost, and it does not end at launch. Prices move, models change, prompts drift, the process the agent automates gets amended and nobody tells the agent.

Budget for maintenance from the start. An agent is not a purchase; it is a system with an owner.

How to price one before you build it

Run one representative task end to end and read the actual usage. Not an estimate per token — the real number from one real run. Everything else is extrapolation from a figure you have measured.

Multiply by honest volume, then by the architecture you actually need. If the design calls for subagents, apply the multiplier before you commit, not after.

Add the review time it creates. In hours, at a real rate. This is the line most likely to change the answer.

Add the cost of building the checks. If there is no cheap way to tell right from wrong in your process, that is the project — and it belongs in this estimate rather than in a later surprise.

Then ask whether it still works. If the economics only survive at the cheapest tier with the tightest settings, they will not survive production.

The honest summary

Model pricing is public, comparable, and falling. It is also the part of the budget you have least influence over — everyone can rent the same models at the same price this afternoon.

What you control is how many times the work gets thought about, whether the stable context is cached, whether latency-insensitive work runs at half price, and whether the output lands somewhere that can absorb it. Those are decisions, not line items on a vendor's page.

Which is the same conclusion as everywhere else on this site, arriving from the direction of the invoice: the returns are not in the model.

Frequently asked questions