What 285,000 Agent Tool Calls Actually Cost
“How much does it cost to run an AI agent?” is the question every team asks once the prototype works and the bill arrives. Most of the answers online are ranges — “$5K to $180K,” “5–10× hidden cost” — because most people writing them are estimating.
We don’t have to estimate. We run Agentic Control Plane — a gateway that sits between AI clients and the tools they call, and meters and prices every call. So instead of a range, here’s a teardown of 285,814 governed tool calls across 96 workspaces (2026-07 snapshot — this is a living dataset; every chart below is regenerated from the raw export by a checked-in script), and where the money actually went.
The short version: the tool calls are nearly free, the bill is the agentic loop — a feature of the harness wrapped around the model, not the model itself — and one frontier model drove 77% of the spend across 30% of the calls — and the cheapest model did 40% of the calls for 0.2% of the bill. Where the volume is is not where the money is.
Every number below is from our own workspaces — dogfood, not customer data. Governance starts at home. No sampling this time: the full corpus, every governed call, priced at API rates (most of the frontier-model traffic is caller-billed subscription usage — the split is in the methods note at the end).
1. The tools are (almost) free
Across the full corpus, 93% of calls never touch a model — they read files, grep, edit, run git. Here’s the top of the histogram, with the calls that cost money in green:
llm.chat.Notice how little of that chart is green. Reading a file, running grep, listing a directory — that’s I/O. It shows up in your logs, it’s where the volume is, and it’s where most “agent observability” tools point their dashboards. But it’s not the bill: the grey bars cost approximately nothing, and one green bar — the coding-agent proxy — carries nearly the entire $2,743 by itself. If you’re counting tool calls to estimate cost, you’re counting the wrong thing.
2. The bill is the model calls — and it’s wildly concentrated
Strip away the free I/O and you’re left with the model calls: $2,742.65 over 19,506 calls. Break that down by model and the cost story falls out immediately:
| Model | Calls | Spend (@ API rates) | Per call |
|---|---|---|---|
| Claude Fable 5 | 5,929 | $2,098.48 | 35.4¢ |
| Claude Opus 4.8 | 2,808 | $608.03 | 21.7¢ |
| Gemini 2.5 Pro | 2,849 | $24.64 | 0.86¢ |
| Gemini 2.5 Flash | 7,752 | $5.87 | 0.08¢ |
The top row is the story. Fable 5 was 30% of model calls and 77% of the spend — and with Opus, the frontier tier is 45% of calls carrying 98.7% of the bill. Meanwhile Flash did 40% of the model calls for 0.2% of the spend. Per call, Fable costs 467× a Flash call. When we first published this teardown in April the frontier model of the month was Sonnet at 7.6% of calls and 80% of spend; the models changed, the concentration didn’t — it sharpened.
This is the part estimates miss. Agent cost isn’t a flat per-call number you can multiply out. It’s a distribution with a long, expensive tail — and a handful of calls on a frontier model is that tail.
3. The money is in the loop, not the leaves
Group the same spend by what the model call was doing, and the concentration sharpens:
| Surface | Calls | Spend |
|---|---|---|
| Coding-agent loop (via proxy) | 8,826 | $2,711.59 |
Product-agent loop (llm.chat) |
6,144 | $19.53 |
Scheduled-agent loop (agent_run) |
3,878 | $8.54 |
| Context management | 332 | $2.19 |
| Everything else (leaves) | 326 | $0.80 |
97% of the spend is the agentic loop — $2,668 of $2,743, tagged call-by-call as loop vs leaf at the gateway. Not the single useful answer at the end — the loop that gets there. An agent doesn’t make one model call; it makes a chain of them, and on most turns it re-reads the growing context (the system prompt, the tool results, the running transcript) before deciding the next tool. That re-reading is the loop tax, and it’s why a 12-turn agent on an expensive model costs what it does.
This is the distinction we tag on every call as callKind: loop (the model orchestrating tools, turn by turn) vs leaf (a single sub-task call). The loop is where the bill lives. If you only ever see a flat token total, you can’t tell the two apart — and the loop is exactly the part you can do something about.
4. You can’t optimize what you can’t attribute
The lever here is obvious once you can see the split: route the loop to a cheaper model, keep the expensive one for the leaves that actually need it. Sonnet on the orchestration loop is the single most expensive choice in this dataset; the same loop on Flash or Haiku is an order of magnitude cheaper, and for a lot of orchestration turns it’s good enough.
But you can only pull that lever if your cost data is attributed — per agent, per call, loop vs leaf. A monthly invoice from your model provider can’t tell you which agent’s loop is the problem, or whether the spend is the orchestration or the work. That’s the gap ACP closes: every governed call carries its model, its callKind, its estimated cost, and the agent it belongs to, so “where does our agent budget go?” is a query, not a quarterly surprise.
The same data also answers the question the invoice can’t: your agent’s cost is a distribution, not a number. Run the same agent fifty times and the cost varies with how many loop turns it took — which is why we surface per-run cost variability (p50/p95, the tail multiple) next to the average. The average hides the runs that hurt.
What to take from this
If you remember three numbers from 285,814 metered calls:
- 93% of calls are free tool I/O. Counting tool calls tells you about activity, not cost.
- One model was 77% of the bill across 30% of the calls — and the frontier tier was 99% across 45%. Model choice on the loop is the biggest lever you have.
- 97% of spend is the loop, not the leaf. Optimize the orchestration, not the final answer.
None of this is exotic. It’s just what falls out when you can see and price every call instead of estimating — which is the whole reason the gateway exists. If you want the same teardown for your own agents, sign in and the cost X-ray is live in your dashboard; or read what an agentic control plane is for how the metering works.
Every number in this post came from our own internal workspaces, not customer data. The corpus grows every week; these figures are a 2026-07-12 snapshot of the full corpus (no sampling), regenerated by a checked-in script from the raw export. Spend is priced at API rates; $34.71 of it was workspace-billed and the rest is caller-billed (BYO subscription) traffic metered through the proxy — the two are never summed anywhere except this teardown’s “what would this cost” framing, where API-rate pricing is the point. An earlier version of this post (April 2026, 210,840 calls) told the same story with Sonnet 4.5 in the leading role.