Your AI bill is going up. The line items can’t tell you why, and that gap is where the money goes.
Every team running AI in production is paying a tax. It does not arrive on an invoice with that name. It is not a line item that anyone approved. It is the distance between what you spend on models and agents and what those models and agents actually accomplish, and right now, almost no one can measure it.
The spending is easy to see. The bill shows up, the number is larger than last month, and someone asks why. The answer that comes back is usually some version of “we are using it more.” Usage is up, so cost is up. That is true, and it is also where the conversation ends, because the tools that report the spend cannot break it down into anything finer than usage.
That is the tax. Not the spending itself. The part of the spend you cannot account for.
We have watched this movie before
The last time a new kind of compute got cheap and easy to provision, the same thing happened. Cloud made it trivial to spin up a server, and then trivial to forget you had. Companies woke up a few years into their migration to discover idle instances no one owned, databases provisioned for ten times their load, and environments left running over a weekend that cost more than the feature they were testing. The bill had outrun the value, quietly, for quarters. An entire discipline, FinOps, grew up to answer the one question the invoice could not: which of this spend actually bought us something.
AI is sitting in the pre-FinOps moment of its own cost curve. Tokens are the new compute. Agents are the new always-on service. And the bill aggregates all of it into a number that goes up and to the right, with no way to attribute any slice of it to a result. We know how this part of the story goes. Cost visibility always lags cost growth, and the gap between them is where the waste lives.
The waste is not where you are looking
Most cost work in AI right now optimizes the obvious. Pick a cheaper model. Add a cache. Trim the prompt. These are real, and they are also marginal, because they treat the spending as an infrastructure problem. The structural waste is somewhere else entirely: the system is paying to make poor decisions.
Top-down view of a spiral staircase forming concentric circles, an agent paying to think in circles
It looks like this in practice:
- An agent that loops, re-retrieving and re-deciding, burning tokens to relitigate a choice it should have made cleanly the first time.
- A frontier model called for a task a small one would have handled, because no one drew the line and the default is “use the good one.”
- Retrieval that pulls in context the model never uses, paid for on the way in and again as it dilutes the next decision.
- A silent failure that passes every eval, ships a confident wrong answer, and bills you for the compute that produced it plus the work to clean it up.
Each of these is a decision the system made badly. You paid for the decision, and then you paid again for the consequence. None of it shows up as waste, because every individual step succeeded. The agent that thinks in circles still returns a correct answer. It just rented the model a few extra times to get there.
Why the tax stays invisible
The reason this is so hard to see is structural, not a tooling oversight someone will patch next quarter. The bill aggregates by usage because usage is the only thing it can observe. Your observability stack has the same blind spot one level up: it records the steps a system took, not the choices behind them. A trace of an agent thinking in circles does not look like waste. It looks like a longer trace, every line a success.
I have written before about this gap between what we can see in these systems and what we can explain: execution is observable, decisions are not. Cost is the version of that gap that a finance team feels directly. You cannot bill waste to a line item from a trace because the trace shows more steps, not worse decisions. The money leaks at the level of the decision, and nothing in the standard stack is pointed there.
Cost is a behavioral problem wearing an infrastructure costume
This is the reframe that matters. The instinct is to treat AI spend as an infrastructure problem, something you solve by right-sizing models and caching harder. But the expensive part is not the infrastructure. It is the behavior. It is how the system decides.
A team can have immaculate infrastructure hygiene and still bleed money, because the agent is making marginal, unstable decisions all day long, and every marginal decision is a unit of wasted spend. The highest-leverage cost lever most teams have is not a cheaper model. It is an agent that makes fewer bad decisions. Spend is downstream of decision quality, and almost no one is measuring decision quality, so almost no one is managing the spend that flows from it.
The tax compounds, which is why it matters now
A year ago, most teams ran a model behind a single call. Today, they run agents, and agents make many decisions per task, each one a place to pay to think in circles. The more autonomous the system, the more decisions it makes without you watching, and the larger the surface area of the tax. It scales with exactly the thing every roadmap is racing toward.
And it stays quiet the whole way up, because no single output looks wrong. The answers keep landing. The bill keeps creeping. By the time the number is big enough to trigger a review, the waste has been compounding for quarters, the same way the idle cloud instances did, and for the same reason: the spend was never attributable to a result, so no one could see the part that bought nothing.
What this asks of teams building now
The teams that come out of this phase ahead will be the ones that make the tax visible. Not a cheaper bill, a legible one: the ability to point at a workflow and say this is what it cost and this is what it bought, and to find the decisions in between that the system paid for and got nothing from.
That starts with naming the thing. Call it the hidden AI tax, because that is how it behaves: levied on every workflow, itemized on none, and paid in full whether or not anyone is watching. The problem underneath has not changed since the first time I wrote about it. Teams can trace every step their AI took and still cannot explain the decision: why it chose what it did, whether the choice was sound, or where it quietly wasted money getting there.
The bill tells you that you spent. It does not tell you what you bought. Closing the distance between those two sentences is the work of the next few years, and the teams that do it first will spend a lot less to get a lot more.