One of the most disorienting things about an AI bill is that every individual call looks trivially cheap, fractions of a cent, and yet the total is large. There is no expensive-looking line to point at. The cost is real, but it is distributed across a volume so high that no single piece of it seems to matter. Understanding this is key to managing it.
The tyranny of volume
A call that costs a fraction of a cent is genuinely cheap in isolation. The bill is large because there are millions of them. When cost is spread across enormous volume, the per-unit price stops being a useful intuition. What matters is the total call count multiplied by the average cost, and at scale even a tiny average produces a big number. The cheapness of each call is exactly why the total is easy to underestimate.
Why cheap calls escape scrutiny
Expensive things get reviewed. Cheap things get waved through. Because each AI call looks negligible, no single call ever triggers a second look, and so inefficiencies that would be caught in a costly line item survive indefinitely in a cheap one. A slightly bloated prompt, an unnecessary retry, an oversized context, none of these are worth noticing on one call, and all of them are worth a lot across millions.
Small inefficiencies multiplied
This is where the real waste lives. An extra few hundred tokens on every call is invisible per call and substantial per month. A retry rate a little higher than it needs to be adds a few percent to volume that nobody feels one call at a time. The economics of high-volume, low-unit-cost systems mean that small per-call inefficiencies become large aggregate costs, precisely because they are too small to notice individually.
Managing by aggregate, not by call
The response is to stop thinking per call and start thinking per aggregate. The questions that matter are: how many calls per task, how many tokens per call, and what is the total volume, not what does one call cost. Optimization at the per-call level feels pointless because each call is already cheap. Optimization at the aggregate level, shaving tokens and calls across the whole volume, is where the savings actually are.
The metric that makes it visible
Cost per outcome is the metric that rescues you from the cheap-call illusion. It groups all the cheap calls that go into one business result and prices the result, not the call. Suddenly you can see that a task taking many calls costs more than one taking few, and you have a number worth optimizing. The individual call was always too cheap to manage. The outcome it rolls up into is not.
A high bill made of cheap calls is not a paradox. It is what high volume does to any per-unit price. The way through is to manage the aggregate and the outcome, because that is the level at which the cost is actually large enough to act on.