CLAUDE.md cost with parallel agents: the surfaces that multiply, and the two that do not.

The phrase "parallel agents" hides four different cost surfaces in Claude Code, and they bill your CLAUDE.md on three different rules. Most guides on this topic give you one answer for all four. This page is the table that splits them, with the line of Anthropic's docs each row traces back to, and the formula for turning ccmd's single-agent token number into your real parallel-session bill.

1. Four surfaces, three billing rules

When you ask Claude Code to "do this in parallel" you can land on any of four surfaces, each documented on its own page:

• Subagents (built-in or custom) spawned via the Agent tool. Single session, multiple workers, results return to the main agent.
• Agent teams (experimental, opt-in with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1). Multiple full sessions, each a separate Claude instance, with a shared task list and inter-teammate messaging.
• Background agents ( claude --agent or the agent view ). Many independent sessions, monitored from one place.
• Git worktrees. Manual parallel sessions, one terminal per worktree.

Three billing rules cover all four, in increasing severity:

1. No CLAUDE.md cost. Two built-in subagents only: Explore and Plan. They walk the repo or draft an approach in read-only plan mode, and they skip your CLAUDE.md by design.
2. One extra rehydration per call. Every other subagent, built-in or custom. The subagent starts a fresh context window, loads the full memory hierarchy once, runs its task, then returns a summary. The CLAUDE.md cost is tokens × 1, not tokens × turns, because the subagent's own turns are billed against the subagent context, not the parent.
3. Linear scaling, every turn. Agent teammates, background agents, and worktree sessions are all full Claude Code sessions. Each one loads CLAUDE.md at start and every turn of every session re-bills it (subject to prompt caching when prefixes match). This is where the official 7x figure comes from.

2. Surface-by-surface, with the docs sentence for each row

What each parallel surface loads at start, what it costs per turn, and where Anthropic says so:

The two rows that read No are the entire content of the paragraph in the subagent docs under What loads at startup:

"Explore and Plan skip your CLAUDE.mdfiles and the parent session's git status to keep research fast and inexpensive. Every other built-in and custom subagentloads both."

Claude Code docs, Create custom subagents

3. The 7x figure, in context

Anthropic publishes one explicit multiplier for parallel work, on the costs page, in the agent-team section. The full sentence:

Three things are worth reading carefully in that sentence:

• "each teammate maintains its own context window". That includes a fresh load of CLAUDE.md. The agent-teams docs confirm it in plain words: "When spawned, a teammate loads the same project context as a regular session: CLAUDE.md, MCP servers, and skills."
• "plan mode". Plan mode is verbose; teammates explore and propose before implementing. The 7x figure is the upper-end common case, not a guarantee. A 2-teammate team that implements directly costs less; a 5-teammate team that spends most of its time in plan mode can cost more.
• "runs as a separate Claude instance". Prompt caching only hits when the prefix is byte-identical to a previous request on that instance. Teammate caches do not share with each other or with the lead. A 6,000-token CLAUDE.md that prefix-caches well on the lead does not save anything for teammate context windows on turn one.

4. The two exceptions, and why most guides miss them

Explore and Plan are the two built-in subagents Anthropic ships with Claude Code for parallel investigation. Explore reads code; Plan drafts an approach in read-only plan mode. Both are the workhorses of a "let me think before I commit" workflow, and both are deliberately exempt from the CLAUDE.md tax.

The doc sentence that grants the exception sits halfway down the subagent page, under What loads at startup, in the middle of a bullet list. It is one of those product decisions that is buried on purpose: surfaced if you read carefully, ignored if you skim. Most third-party "parallel Claude Code" posts skim. The result is a common assumption, repeated across guides, that everyparallel call multiplies your CLAUDE.md cost. It doesn't. Two named built-ins are the exception, and they happen to be the two you reach for most often in research-heavy work.

The actionable consequence: if your team's habit is to fan out three or four custom subagents for code review or exploration tasks, rewrite those flows to use Explore and Plan instead, when the work is read-only or planning. The token saving per call is the full size of your CLAUDE.md plus your MCP server descriptions plus the parent git status. On a typical 6,000-token CLAUDE.md with two MCP servers, that is several thousand tokens skipped per call, across however many calls you make in a session.

5. The math, applied to ccmd's analyzer

ccmd's analyzer scores one file and assumes one agent. Here is the cost block, verbatim, from src/lib/analyzer.ts:

The variable name says what the comment says: estimatedTokensFireEveryTurn is the file's full token count, billed every turn, for one agent. There is no fan-out variable in the formula. For a single session that is exactly right. For a parallel session you have to add one multiplier yourself.

The formula, expanded:

Note the asymmetry. A teammate is billed per turn, because it is a full session that loads CLAUDE.md on every request the way the parent does. A subagent call is billed once, because the subagent does its work in its own context window and returns a summary; the parent does not pay for the subagent's turns against the parent's rate. Two different billing rules, two different multipliers.

6. A worked session, three parallel patterns

Same starting file, three different parallel patterns, side by side. A 6,000-token CLAUDE.md, a 30-turn long session, the analyzer's $15 per million input constant:

Read the three blocks in order. Single agent is the baseline ccmd prints. Three custom subagents add one extra rehydration of CLAUDE.md each, for a small one-time cost. Three teammates add 90 more turns of 6,000-token re-injection, four times the input token count of the baseline, with a real bill roughly seven times what the analyzer showed for the parent alone. The last two lines are the Explore/Plan escape hatch: same "three parallel workers" story, zero CLAUDE.md added.

7. When the multiplier is worth paying

The point of this page is not to argue against parallel work. The agent-teams docs are direct about where teams earn their cost: research, parallel review, debugging with competing hypotheses, and new features split into independent modules. Anthropic recommends 3-5 teammates for most flows, Sonnet for teammates, and small self-contained tasks. That advice is real. The 7x figure is the cost of that win, not a warning against taking it.

What this page argues is narrower: the multiplier is your CLAUDE.md times your fan-out, and shrinking the multiplicand before fanning out is the highest-leverage optimization you can run. A 4,500-token cut on the file saves 4,500 tokens times every turn of every context window in a parallel session. Across a 3-teammate team that is roughly half a million input tokens per long session, every session, forever. Run the analyzer on ccmd.dev before you spawn the next agent team and you cut the bill at the only point in the stack where one edit affects every parallel surface.

8. Why the existing tools do not catch this

The two surfaces a Claude Code engineer reaches for to look at cost today, and what they each leave on the floor when parallel work is involved:

Retrospective token-cost CLIs like ccusage tell you a session was expensive. They cannot tell you the expensive line was CLAUDE.md re-injected three times because you spawned three teammates instead of two Explore subagents. ccmd reports the per-turn floor; this page gives you the multiplier; the two together turn a vague "why was that session $9" into a line you can edit.