I measured something in my own agent workspace recently that changed how I think about what these systems cost. The same 104,000-token file read carried 147 times more re-reading when it happened at turn 3 of a session than when it happened at turn 182.
Same file. Same model. Same price per token. A 147x difference in the re-reading it dragged behind it.
Every time an agent takes a step, the entire conversation so far gets re-sent to the model. So a token's real cost is not its size. It is its size multiplied by every turn that comes after it. Something loaded early in a long session gets re-read hundreds of times. The same thing loaded at the end gets re-read twice. Caching softens this considerably, but it discounts the re-reading rather than removing it. In dollar terms the gap was roughly an order of magnitude at cached rates, and it heads back toward the full 147x any day the cache runs cold.
Most teams I talk to price agent work the way they priced API calls. Tokens in, tokens out, multiply by the rate card. That model is wrong in a way that compounds, because it treats context. An agent system's spend is dominated by what it habitually carries, not by what it produces. In my own workspace, output is about 14 per cent of attributed cost. Everything else is the system carrying its own context, writing it into cache and re-reading it on every step.
Here is why this is an architecture problem and not a procurement problem.
What loads by default is a standing tax. Every instruction file, every tool definition, every piece of always-on context gets paid for on every step of every session. Teams accrete these surfaces the way they accrete config: someone adds a rule, it helps once, it stays forever. Nobody prices it. A workspace that has quietly grown 40 kilobytes of standing instructions has signed a recurring contract nobody reviewed.
When something loads matters as much as whether it loads. The 147x figure is the same read at two positions. Load late, load narrow, and send exploratory reading to a subordinate agent whose context never enters the main session. None of this needs new tooling.
Loops multiply everything. The failure story that convinced me came from a public discussion on an agent runtime. Eleven automated fix rounds, each re-reading 650,000 tokens of context, each round individually reasonable. No single step looked wrong. The loop was the problem, and nothing in the system could see the loop. If your agents retry, chain, or check their own work, whatever they carry is multiplied by the shape of that loop, and per-call visibility will never show it to you.
The decision this argues for is small and unglamorous. Somebody in your organisation should be pricing context budgets the same way somebody does for cloud spend. Pricing, not minimising. The questions they should be able to answer are these. What does our standing surface cost per session, what is our cache hit rate and what happens to the bill on a cache-cold day, which loops can multiply a mistake, and what did each lane of agent work cost last week against its trend.
None of those questions requires a vendor product. A ledger file, a budget per scheduled job, and a weekly look at the trend cover most of it. The workspace where I measured the 147x runs exactly that, and the discipline came after the bill, not before.
The pattern this comes from, with the measurements, is public: Position is price. If your platform team says agent costs are unpredictable, ask whether anyone has looked at what the system habitually re-reads. That part is very predictable. It is just not visible from the invoice.
