Why Your AI Agent Burns Tokens So Fast (5 Habits That Triple the Bill)
Your AI agent burns tokens fast mostly because of a few habits, not the model: dragging one endless session, re-reading everything, and running expensive models on cheap work. Each new turn pays to re-read the whole conversation, so long sessions cost more per turn as they grow. Fresh sessions, files, and cheap models for mechanical work cut the bill without cutting quality.
Most people meet a big bill and assume they picked the wrong model or that the price is simply high. Usually the model is fine. The waste is in how the session is run, and the same work can cost a fraction of what it did once you change three or four habits. That is good news: habits are free to change, and you do not have to trade away any output quality to do it.
Where do the tokens actually go?
Most of the tokens go into re-reading accumulated conversation and re-loading context that a file or a fresh session would handle for far less. Every turn, the agent has to take in everything that came before it so it can respond in context. That means the cost of a turn is not fixed: it grows with how much conversation the turn has to re-read. Ten turns of piled-up context can cost far more than ten times the cost of a single early turn, because the last turns are each re-reading a mountain the first turns never had to.
This is the single mechanic behind most surprise bills. A session that drags on for hours is not just doing more work; it is paying more per unit of work, because every new step re-reads a transcript that only gets longer. The dragged-out session gets more expensive as it goes, and the expensive part is not the new thinking but the re-reading of old thinking.
The other half of the story is that not all context costs the same. Context the tool can cache and reuse is much cheaper than fresh context read cold. A stable set of instructions or a file that stays the same across turns can be served from cache; a conversation that keeps changing cannot. So two agents doing identical work can have very different bills purely based on how much of their context is reused rather than freshly re-read. For a fuller breakdown of the numbers, see what it actually costs to run an AI agent.
Which habits cut the bill without cutting quality?
Here are the five habits that do most of the damage, and the fix for each. None of these lowers the quality of the output; they lower the amount of re-reading you pay for to get it.
You drag one giant session instead of starting fresh after a finished block of work. A single marathon conversation re-reads its own growing history on every turn, so the tail of the session is the most expensive part of it. The fix is to end the session once a block of work is genuinely done and start a fresh one for the next block. A new session begins with a small, clean context instead of hauling the whole day behind it, and the per-turn cost resets.
You run one expensive model for everything, including mechanical work. Sweeping text, gathering data, filling checklists, and other rote jobs do not need your most capable model, but they cost the same per token when you run them on it. The fix is to route mechanical work to a cheaper model and reserve the expensive one for judgment. When you fan work out to subagents, set the model explicitly for each one and never let it inherit the pricey session model by default.
You keep the whole history in the conversation instead of in files. If the only record of what happened lives in the transcript, every future turn has to re-read that transcript to stay informed, and you pay for it again and again. The fix is to keep state in plain text files. A new session reloads a compact state file in a couple of minutes and knows where things stand, instead of re-reading a long history to reconstruct it. Cheaper context, and more reliable too. This is the same file habit that keeps an agent from forgetting between sessions.
You fan work out to parallel agents to look busy, not because the work is independent. Running several agents on a task one agent could handle does not speed anything up; it just multiplies the bill, because each agent loads its own context and does its own reading. The fix is to fan out only when the subtasks are genuinely independent and each needs real work. Parallelism is a tool for truly separable jobs, not a way to make an agent look industrious.
You re-read the whole codebase or history when a targeted read would answer the question. Pulling an entire repository or a full transcript into context to answer one narrow question is one of the fastest ways to burn tokens for nothing. The fix is to read only what the question needs. A targeted search or a single-file read answers most questions for a fraction of the cost of loading everything, and the answer is usually sharper because there is less noise around it.
Put together, these five habits explain most of the gap between a lean agent and one that burns through a budget. The theme running through all of them is the same: stop paying to re-read what you already know. If model prices themselves shift under you, our radar tracks model price changes so the routing choices in habit two stay current.
FAQ
Is one long session cheaper than restarting?
Usually no. A long session re-reads a growing context on every turn, so the later turns each pay to re-read everything that came before them. A fresh session that reloads a small state file starts from a clean, cheap context and is often less expensive overall, while being just as informed about where things stand. The instinct that restarting wastes work is backwards once files hold the state.
Do files really save tokens?
Yes. A compact state file lets a new session reconstruct what it needs in a couple of minutes instead of re-reading a long transcript turn after turn. That is both cheaper, because you load a small file once rather than a growing history repeatedly, and more reliable, because a written summary is clearer than whatever the agent would infer from re-reading raw conversation. Files turn expensive re-reading into a cheap one-time load.
When is parallel fan-out worth the tokens?
When the subtasks are genuinely independent and each one needs real work. Splitting a separable job across agents can finish it faster and is worth the extra context each agent loads. Running several agents to look busy on a task one agent could do just multiplies the bill without buying speed or quality. Ask whether the pieces are truly independent before you fan out; if they are not, keep it to one agent.