The Agentic Coding Cost Playbook: 6 Changes That Cut My Claude Code Token Bill

Why your bill is a context problem, not a pricing one — and the six-step fix you can run on your own setup this week

In mid-May 2026, Microsoft started pulling its internal Claude Code licenses. Engineers in its Experiences and Devices division had adopted the tool hard, and most of that access ends June 30. The reporting framed it as a cost story, and it is one. Token-based billing turned out to scale with usage in a way per-seat pricing never did, and the bills started outrunning the headcount savings.

Then I read that Uber's CTO, Praveen Neppalli Naga, said the company had exhausted its full 2026 AI budget by April. Four months. And on June 1, GitHub flipped every Copilot plan onto usage-based AI credits. Three of the most sophisticated engineering organizations on earth, all retrofitting financial controls onto something they rolled out fast.

Here is the part most of the coverage gets wrong: your agentic coding bill is not a pricing problem. It is a context problem. The price per token has barely moved. What moved is how much context you feed the model on every single step, multiplied across long-running sessions and parallel agents that never stop reading.

I run 23 agents across a nine-worktree setup. I watched my own number climb the same way these companies did, and then I spent two weeks tearing it apart. This is the six-change playbook that came out of it. Every change is something you can run on your own setup, and none of them ask you to give up a single agent.

The bill is a context problem, not a pricing problem

Start with the math, because the math is the whole argument. Claude Opus 4.8 runs five dollars per million input tokens and twenty-five per million output. That sounds cheap until you remember what a coding agent actually does. It does not send one prompt. It plans, reads files, calls tools, re-reads the same files when it loses the thread, gets the tool output back, reasons, and comes back tomorrow to do it again. Every one of those steps ships the accumulated context back through the meter.

Agent costs are non-linear with usage. A session that runs for an hour does not cost twice an hour-long session from last week. It costs more, because the context window fills, and a full window is an expensive window on every subsequent turn.

The reflex when costs spike is to reach for a cheaper model or a bigger context window. The bigger window is the trap. A one-million-token window does not lower your bill. It raises the ceiling on how high the bill can go before anything visibly breaks.

Anthropic's own engineering writing on context describes this directly: as the number of tokens in the window grows, the model's ability to accurately recall information from that window degrades. They call it context rot, and it shows up across every model regardless of window size. So the big window costs you twice. You pay for the tokens, and you pay again in worse answers that trigger more turns to fix.

Treat tokens the way a manufacturer treats raw material. They are cost of goods sold, not a flat subscription. Once you see the bill as COGS instead of a seat license, every decision changes. You stop asking "which plan am I on" and start asking "how much material am I burning per unit of work." That single reframe is what the next five changes operationalize.

First, instrument the bill before you touch anything

I ran blind for months. I knew the number at the end of the month, the way you know your weight only when you step on the scale, and I had no idea which agent or which session was eating it. You cannot cut what you cannot see, and the dashboard your provider gives you is an aggregate. Aggregates hide the culprit.

The first change is the least glamorous and the highest leverage: log token spend per agent, per session, per worktree, before you optimize anything. You want a local record you control, separate from the billing portal, so you can slice it by which workflow actually spent the money.

#!/usr/bin/env bash
# token-ledger.sh — append a per-session token record to a local log.
# Run as a wrapper or from a session-end hook. Fields: stamp, worktree, agent, in, out.

LOG="${HOME}/.agent-costs/ledger.csv"
mkdir -p "$(dirname "$LOG")"
[ -f "$LOG" ] || echo "ts,worktree,agent,tokens_in,tokens_out" > "$LOG"

WORKTREE="$(basename "$(git rev-parse --show-toplevel 2>/dev/null || echo standalone)")"
AGENT="${1:-default}"
IN="${2:-0}"      # pull from your session summary / SDK usage object
## OUT="${3:-0}"

printf '%s,%s,%s,%s,%s\n' "$(date -u +%FT%TZ)" "$WORKTREE" "$AGENT" "$IN" "$OUT" >> "$LOG"

Then a thirty-second roll-up tells you the truth the portal won't:

# Cost by worktree this billing cycle, Opus 4.8 rates ($5/M in, $25/M out).
awk -F, 'NR>1 {
  inT[$2]+=$4; outT[$2]+=$5
} END {
  for (w in inT)
    printf "%-20s $%.2f\n", w, inT[w]/1e6*5 + outT[w]/1e6*25
}' ~/.agent-costs/ledger.csv | sort -t'$' -k2 -nr

I will not print my old monthly number. It embarrassed me once already. What I will tell you is that the instant I could sort spend by worktree, two of my nine were responsible for most of it, and neither was the one I would have guessed. Visibility moved the decision from "spend less, somehow" to "fix these two things, specifically."

Make the cache actually hit

Prompt caching is the highest-return change after instrumentation, and most people think they have it on when they don't. Caching lets you mark a stable prefix of your context so it isn't reprocessed at full price every turn. The catch is that the cache keys on an exact prefix match. Anything that changes the front of your context silently breaks the cache, and you go back to paying full freight without a single error message to warn you.

The usual cache killers, in the order I hit them:

### 1. A timestamp or session ID injected at the TOP of the system prompt.
   → The prefix changes every call. Cache never hits. Move volatile data to the end.

### 2. Reordering tool definitions between calls.
   → Tool list is part of the cached prefix. Keep ordering stable and deterministic.

### 3. Editing CLAUDE.md mid-session.
   → Changes the prefix. Expected when you mean it; expensive when you don't.

4. Per-turn preambles ("It is now 14:32, the user said…").
   → Push dynamic context to the tail, keep the head frozen.

The fix is a discipline, not a feature toggle. Freeze the head of your context: system prompt, tool definitions, project conventions. Put everything that changes per turn at the tail. Anthropic's engineering team has written about caching as a measurable lever, not a vibe, and the way you confirm it is by watching cached-read tokens climb as a share of input on your ledger. If that share is near zero, your cache is not hitting, and you are leaving the single biggest discount on the table.

Route the model to the work

This is the change that took the largest single bite out of my bill, and it is almost embarrassing in its simplicity. Not every step of agentic work needs your most expensive model. Finding a file does not need Opus 4.8. Triaging which of forty files is relevant does not need it. Summarizing a tool output does not need it. Hard, multi-file reasoning does.

So stop sending the cheap work to the expensive model. Route by task class.

Task Class — Model Tier — Why

🗂 File Search, Retrieval, “Where do we do X?” Haiku 4.5 Fast, cheap, accuracy is sufficient for locating information

🏷 Triage, Classification, Tool Output Summaries Haiku 4.5 High-volume work with minimal reasoning requirements

✍️ First-Pass Drafts & Boilerplat Mid Tier Good enough to generate an initial version for refinement

🏗 Multi-File Refactors, Ambiguous Debugging, Architecture Opus 4.8 Complex reasoning is where premium tokens actually earn their cost

✅ Final Review Before Merge Opus 4.8 The last place to optimize for cost instead of quality

The volume asymmetry is the whole point. In a long session, the cheap, high-frequency calls vastly outnumber the hard ones. Moving that majority off the frontier model is where the money is. The hard reasoning stays on Opus 4.8, because that is the work that justifies the rate, and nothing about this makes your agent dumber. It makes it stop paying genius rates for clerical labor.

If you run local models, the cheap tier is where they earn their keep. A small local model handling retrieval and triage offloads the highest-volume calls entirely off your metered budget. That is the one move that turns a fixed cloud bill into a variable one you can push down with hardware you already own.

Stop paying to re-read your codebase

Here is a failure mode you have definitely paid for without noticing. Halfway through a task, the agent re-reads the same four-hundred-line file it read twenty minutes ago, because the original read scrolled out of useful context and nothing kept it around. Every re-read is full freight, and a long session does this constantly.

Two disciplines stop it. First, offload context to files instead of carrying everything in the window. The agent should write what it learned to disk and read back the small relevant slice, not haul the entire history in-band on every turn. Second, compact aggressively. When the window fills, summarize the earlier history into a tight digest and continue from that, rather than dragging raw transcript forward.

This is also where your project file earns its place. A CLAUDE.md or AGENTS.md written as a procedure, not as prose, is a permanent offload of your conventions. The agent reads it once at the head of the context, the cache holds it, and it stops re-deriving how your codebase works on every task. The mistake I made for too long was writing that file for a human reader, full of background and explanation. The agent doesn't need the background. It needs the decision.

I have not fully solved the compaction-timing question. Compact too early and you discard detail the agent still needs, which triggers a re-read and costs you the savings. Compact too late and you've already paid for the bloated window. The rule I run today is workload-shaped, not universal, and I am still tuning it. Anyone who tells you they've nailed the universal compaction threshold is selling something.

Put your MCP servers on a diet

I run 23 MCP servers. That is the kind of number that sounds impressive in a setup post and quietly bleeds you in production. Every connected server adds tool definitions to your context, and a chatty server that returns verbose output on every call inflates the input on the next turn. The model also has to read every tool definition to decide which to call, so a sprawling server list taxes you before any work happens.

Three moves put the sprawl on a diet. Allow-list the servers a given agent can actually reach, so a coding agent isn't carrying the definitions for tools it will never use. Batch calls where a server supports it, instead of round-tripping per item. And audit for the servers that dump large outputs into context — the 59-kilobyte response the model has to carry forward — and sandbox or trim those at the tool layer so the window never has to absorb the whole dump.

The honest version of this is a cull. I went through all 23 and asked a single question of each: did this server earn its context cost this month, or is it here because I added it once and forgot? Several were the second thing. A connected server you don't use is not free. It is a line item that shows up on every turn.

What to ship this week

This is the part you copy into your own notes. Six changes, ordered by leverage, time-bound. You can have the first three done by Friday.

1. Instrument first. Drop a per-session token ledger into a session-end hook today. Log worktree, agent, input, and output. Twenty minutes. You ship nothing else until you can see which workflow spends the money.
2. Confirm the cache hits. Freeze the head of your context, move volatile data to the tail, and watch your cached-read share climb on the ledger. If it's near zero, your cache was never hitting.
3. Route by task class. Send search, triage, and summarization to a cheap or local model. Keep refactors and final review on the frontier model. This is the biggest single bite.
4. Offload and compact. Make the agent write learnings to disk and read back slices, and turn on aggressive compaction so it stops re-reading the same files at full price.
5. Diet the MCP servers. Allow-list per agent, batch where you can, trim verbose tool outputs, and cull the servers that didn't earn their context this month.
6. Set a budget you alert on. Pick a monthly ceiling per worktree, alert at 70 percent, and read the ledger on the last working day of each month. The alert is the difference between catching the climb in week two and finding it in the invoice.

Track the delta over one full billing cycle, not one good day. One anomalous week skews the average in both directions. The verdict comes at thirty days.

The savings are real. So was the bill.

Microsoft's own workplace report cited eighty percent productivity gains in the same stretch it was winding down those licenses. Both things are true at once, and that is the entire situation. The output is real. The bill is real. The gap between them is not a reason to stop using agents, and it is not a pricing conspiracy. It is an engineering problem, and engineering problems have fixes.

If you want to start today, run the ledger script against one worktree and sort spend by session. You will find a culprit you didn't expect within the hour. That is the five-minute version of everything above.

This week, take the routing change and apply it to your single most expensive workflow. Move its search and triage calls to a cheap tier and leave the reasoning on the frontier model. Run it for three days and read the ledger. You'll feel the bite.

Over the next month, the larger move is to make cost a first-class signal in how you build, the way you already treat latency or correctness. Put the ledger on a dashboard, set the alerts, and run the monthly audit as a fixed ritual. The configs and the audit templates I run are at wowhow.cloud/tools, but you don't need them. You need a session hook, a sort command, and the willingness to look at the number before the invoice does.

The token price was never the problem. The context you feed the model is the meter, and the meter has been running the whole time.

🔗 Resources

| AI cost crisis reporting (Microsoft / Uber, agentic coding bills) | https://finance.yahoo.com/sectors/technology/articles/ai-cost-crisis-emerges-claude-195612806.html

| GitHub Copilot usage-based AI-credit billing (June 1, 2026) | https://aiagentstore.ai/ai-agent-news/this-week

| Anthropic — Effective context engineering for AI agents (context rot) | https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents

| The cost-engineering toolkit and monthly audit templates | https://wowhow.cloud/tools

This story is published on Generative AI. Connect with us on LinkedIn and follow Zeniteq to stay in the loop with the latest AI stories.

Subscribe to our newsletter and YouTube channel to stay updated with the latest news and updates on generative AI. Let’s shape the future of AI together!