In short

  • Most of what my coding agents cost is re-reading context. What the model writes was under 4% of a measured day.
  • The fixes that worked cut what each call carries: no agent waits on a job, sessions compact at 200k tokens, and rules load only when they apply.
  • Checking work with a separate agent cost more than building it, so checks are tests now.
  • The scarcer resource is my time, and most of it goes to steering the agents.

In October, Andrej Karpathy sketched a funnel of who has seen what LLMs can do. Near the top are professionals using frontier agents for code. At the very top, a few thousand people run swarms of agents for weeks, and human review is falling behind.

I run a small copy of that setup: about eight Claude Code sessions at once on one laptop, spawning subagents through the day, on a plan with a weekly allowance that doesn’t roll over. Since September I’ve measured where it goes, from the transcripts Claude Code writes to disk. I count weighted tokens, each kind priced against new input at list price, so a cache read counts a tenth and output five times. It’s a proxy for cost, not the bill.

Most of the cost is re-reading

Every model call re-sends the whole conversation so far. The prompt cache makes that cheap, but it’s still most of the bill. On one measured day, output was under 4% of the spend, and the cache was nearly all the rest. Turning down the model’s effort saves little. The savings come from what each call carries.

Agents that wait rebuild their cache

A subagent’s cache lasts five minutes. One subagent waited 30 hours on a background job, checking it in a shell loop, and each of its 60 wakes rebuilt its whole context. That cost 46M weighted tokens, 5% of the week. The full story is its own post. A hook now refuses that kind of wait, and since it went live none has run past five minutes.

Long sessions re-read the most

Each call carries everything said so far, and with a 1M-token window nothing forces a reset. In September, 89% of my sessions’ input went to calls carrying more than 200k tokens of context.

Since October, sessions compact at 200k. Claude Code summarizes the conversation and continues from the summary. Now 5% of input goes to calls that large.

Subagents spend more on instructions than on work

Every subagent starts with the system prompt, the tool definitions and every instruction file above it in the repo, and re-reads all of it on every call. In one week, re-reading that start-up context was 46% of what subagents spent. The file reads and searches that were the actual work were 15%.

Some of those instructions applied to almost nothing. A rule for drafting email rode along on every call, and about 1 in 100 subagent calls came from an agent that touched email. Seven rules like it now load only when an agent is about to do what they cover.

Checking cost more than building

Karpathy notes that models are strongest where a result can be checked. Where a test can check the work, the building agent runs it and moves on. Where none can, the check costs another agent or me.

For a while, every change got a browser check from a separate agent. A check averaged a third more than building the change, and daily subagent spend went up several times over. Now a change gets tests, and a browser check runs when I ask for one.

Most of my time goes to steering

Tokens are the bill I can measure. My time is the scarcer resource. I replayed three days against my prompt history and sorted each minute by hand. Steering the agents, checking status and passing messages between sessions took 73% to 90% of it. The decisions only I can make took a few minutes each once an agent had them ready.

Karpathy says review falls behind at the top. At my scale review kept up, and dispatch took the time.

What the model writes is the small line on the bill. The week goes to context each call re-reads, checks a test can’t make, and turns that wait on me. If you run agents on Claude Code, the transcripts under ~/.claude/projects/ hold the same numbers for your own setup.