Claude Code Subagents Were 48% of My Bill. Their Output Was 0.9%

I thought my expensive Claude Code habit was long sessions. I was half right. When I finally broke down a month of usage, Claude Code subagents cost 48% of my entire bill, and the tokens they wrote back to me were 0.9% of the total.

Almost all of the money went into reading, not writing. Each subagent starts with roughly 51K tokens of context, and it re-reads that context on every single request it makes.

This is the autopsy, the mechanism behind it, and the rules I now run with.

I parsed the session transcripts Claude Code writes locally and grouped usage by session and by whether the message came from the main thread or a subagent. Each assistant message carries a usage block, so the breakdown is just arithmetic.

Here's the shape of the script. Field names are what I saw in my version; check yours.

import json, glob, os
from collections import defaultdict

totals = defaultdict(lambda: defaultdict(int))

for path in glob.glob(os.path.expanduser("~/.claude/projects/**/*.jsonl"), recursive=True):
    with open(path) as f:
        for line in f:
            try:
                row = json.loads(line)
            except json.JSONDecodeError:
                continue
            msg = row.get("message") or {}
            usage = msg.get("usage")
            if not usage:
                continue
            bucket = "subagent" if row.get("isSidechain") else "main"
            for k in ("input_tokens", "cache_creation_input_tokens",
                      "cache_read_input_tokens", "output_tokens"):
                totals[bucket][k] += usage.get(k, 0) or 0

for bucket, t in totals.items():
    print(bucket, dict(t))

Then I multiplied each token class by its rate for the model that produced it. I'm not printing prices here because they change and yours depend on your plan. The shares are what matter.

The result on my machine:

The first line surprised me. The third one annoyed me.

Because an agent is not one request. It's a loop, and every iteration of the loop re-sends the whole context window.

A subagent that reads three files, greps twice, edits one file and reports back makes maybe eight model requests. Each of those requests includes:

Items 1 through 4 are the fixed tax. In my setup that tax was about 51K tokens. The subagent pays it on request one, request two, request eight. Then item 6 grows on top.

Quick napkin math, using my own 51K baseline:

Prompt caching makes those re-reads much cheaper than fresh input. Cheaper is not free. When you multiply a discounted number by fifteen agents and twenty turns, it's still the biggest line on the bill.

Because agent work is read-heavy by nature. A subagent reads 30 files to write a 400-word summary. It reads a test log to decide "yes, it passes." The useful artifact is tiny; the evidence it had to look at is huge, and the preamble is repeated on top.

That 0.9% number reframed how I think about "expensive models." I used to worry about verbose answers. Verbosity was a rounding error. Context size times request count was the whole game.

Three habits, all mine:

One agent per tiny unit. I'd fan out "one agent per file" for a 25-file audit. Each agent paid the 51K entry fee to look at one file of maybe 2K tokens. The preamble outweighed the actual work by an order of magnitude.

Every agent on the big model with full effort. Mechanical jobs like "extract every env var name from these files" don't need deep reasoning. I was paying top-tier rates for grep with extra steps.

A fat global context. My global CLAUDE.md, memory index, MCP servers and skill listings all ride along into every subagent. A line I added once for a niche workflow got re-read tens of thousands of times by agents that never needed it.

Yes, for the same reason. A main session is also an agent loop, and the conversation keeps growing.

On my machine, 45 sessions that crossed $100 accounted for 79% of all spend. Inside the main thread, requests above 400K tokens were 54% of the cost. Once a session is that large, every "ok, now also fix the typo" pays to re-send the whole history.

The painful part: most of that history was irrelevant to the next step. I'd switched topics twice, and the session was still carrying a failed refactor from two hours earlier.

These are the rules I now run with. They're written into my global instructions so Claude follows them without me nagging.

1. Cap agents per run. My default ceiling is 20 subagents per workflow. Going over requires saying the count and the reason before launch. Just having to justify it kills most over-fanned plans.

2. Batch small units into one agent. Instead of 25 agents for 25 files, I give one agent 5 to 8 files. The 51K entry fee gets split across real work. Cost scales with agent count, not file count.

3. Route mechanical work to cheaper effort. Collection, extraction and formatting run at low effort. Review, verification and synthesis inherit the main session's model and effort. Judgment is where the reasoning budget belongs.

4. Trim the fixed preamble. I moved project-specific rules out of the global CLAUDE.md into each repo's own file, and I start quick runs with an empty MCP config. Every token removed from the preamble is saved once per request per agent.

5. Hand off before 400K. When the topic changes or context passes 400K tokens, Claude writes a short handoff memo (what's done, what's next, which files) and I start a new session. A 500-token memo replaces hundreds of thousands of tokens of stale history.

6. Don't delegate single lookups. If I already know the file and the symbol, a direct read beats spawning an agent. Subagents earn their keep when they'd otherwise dump dozens of files into my main context.

I haven't run a clean before/after month under these rules, so I'm not going to claim a savings percentage. My usage mix also skews toward big audits and research fan-outs; if you mostly do single-file edits, your subagent share will be far lower.

What I'm confident about is the mechanism. It isn't specific to my setup. Any agent loop re-sends its context every turn, and any fan-out multiplies that by the number of agents.

Claude Code subagents were 48% of my bill because every subagent started with about 51K tokens of fixed context (system prompt, tool schemas, CLAUDE.md, memory, skill listings) and re-sent all of it on every request in its loop, while the text they actually produced was only 0.9% of tokens. Cost grows with agents × requests × context size, so the fix is structural: fewer agents doing more work each, cheaper effort for mechanical jobs, a leaner global context, and fresh sessions before context balloons past 400K tokens.

Written by the developer behind Preterview, an interview prep platform.