Claude Code agent teams vs subagents: which one costs more tokens?

A subagent pays a fixed cost once: its own system prompt loads fresh, it does the work, and only a summary comes back to your session. A teammate in an agent team doesn't get that discount - it's a full, independent Claude Code session that keeps paying context on every turn it takes, running in parallel with however many teammates you spawned, for as long as it stays alive. The cost docs put the gap at roughly 7x more tokens than a standard session, specifically for teammates working in plan mode. Which one costs you more depends less on which mechanism you reach for than on how long you leave it running.

What actually spins up when you ask for a team vs. a subagent

A subagent call is one node: Claude Code's own sub-agent documentation describes it starting with a fresh, isolated context window that doesn't inherit your conversation history, the skills you've already invoked, or the files you've already read. What it does get - paid in full, once - is its own system prompt, the task message describing the work, the CLAUDE.md hierarchy, and a git status snapshot. It does the work, returns a summary, and its context is gone. Nothing about it keeps running after that.

An agent team is a different shape entirely. The agent-teams documentation is specific: one session becomes the team lead, and each teammate is a separate Claude Code instance with its own context window - "fully independent," in the docs' own words, not a scoped-down worker. A teammate loads the same project context a regular session would (CLAUDE.md, MCP servers, skills) plus the spawn prompt from the lead, but not the lead's conversation history. Teammates don't just report back, either: they message each other directly through a per-agent mailbox, and any agent with the Task tools can claim work off a shared task list. That's the real difference a "vs" title glosses over - a subagent is one call that closes, and a team is a set of sessions that keep talking to each other until someone tells them to stop.

Agent teams are also experimental and off by default. They need CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 set in settings.json or your shell environment, and even with that flag on, spawning a teammate requires an interactive session - non-interactive mode (-p, or the Agent SDK) never spawns one. A subagent Claude names in that mode still runs as an ordinary subagent, flag or no flag.

Why agent teams cost about 7x more than a single session

The 7x figure isn't a benchmark this article ran - it's a number straight from Anthropic's published cost guidance, and it doesn't sit on the agent-teams page most search results for this query cite. It's on Claude Code's cost-management docs, under "Manage agent team costs": "Agent teams use approximately 7x more tokens than standard sessions when teammates run in plan mode, because each teammate maintains its own context window and runs as a separate Claude instance."

The mechanism behind that number is the same one that makes any long Claude Code session expensive: prompt caching means your full context gets re-sent and re-billed at the cache-read rate on every turn, so a session that's been open for hours costs more than its actual message count suggests. A subagent sidesteps that entirely - it pays its context once and is discarded before that compounding has anywhere to build up. A teammate doesn't get to skip it. Each one is a real session accumulating its own turn-by-turn context cost, and you've got as many of those running concurrently as you have teammates. The same docs page is direct about the practical levers: use Sonnet for teammates rather than Opus, keep teams small since "token usage is roughly proportional to team size," keep spawn prompts focused since everything in them adds to a teammate's context from the first turn, and shut a teammate down the moment its work is done - "each active teammate continues consuming tokens until it exits or the session ends."

The token math: subagent calls vs. an N-teammate team, worked

These two numbers measure different things - a subagent's is a fixed cost per call, a team's is a multiplier on a whole session's total - so they don't collapse into one combined figure. Put side by side for the same job, the difference in kind is the point:

The smaller number worth noticing is the coordination tax before either mechanism does any real work. Anthropic's example prompt for spawning three teammates and its own example of delegating to a subagent are both real text from the current docs - running them through this project's estimateTokens function (packages/optimizer-cli/src/tokens.mjs, the same chars/4 heuristic behind every number on this site) gives an honest before-a-single-token-of-work-happens comparison:

$ node -e '
const { estimateTokens } = await import("./packages/optimizer-cli/src/tokens.mjs");
const teamSpawn = "I am designing a CLI tool that helps developers track TODO comments across their codebase. Spawn three teammates to explore this from different angles: one on UX, one on technical architecture, one playing devils advocate.";
const subagentDelegate = "Research the authentication, database, and API modules in parallel using separate subagents";
console.log("team spawn prompt:", estimateTokens(teamSpawn), "tokens");
console.log("subagent delegation line:", estimateTokens(subagentDelegate), "tokens");
'
team spawn prompt: 56 tokens
subagent delegation line: 23 tokens

Neither number is large on its own. What it shows is that a team costs more from the very first instruction, before you've factored in that three teammates are about to each load CLAUDE.md, your MCP servers, and skills independently - the same fixed session-start tax your main session already paid once.

When the extra spend is worth it, and when a subagent wins

The docs name four situations where the extra tokens are typically worth it, and they share one property: the work genuinely benefits from teammates disagreeing with each other, not just running in parallel.

• Research and review, where teammates investigate different angles and then challenge each other's findings
• New modules or features that different teammates can each own without touching the same files
• Debugging with competing hypotheses, where parallel investigators actively try to disprove each other's theories
• Cross-layer changes spanning frontend, backend, and tests, each owned by a different teammate

A subagent wins everywhere else, and especially in three specific cases the docs are explicit about: sequential work or heavy file overlap (teammates editing the same file just overwrite each other), anything that needs to run headlessly (CI, a scheduled task, the Agent SDK - teams simply don't spawn there), and a task where only the final result matters, since a subagent's summary-back model is cheaper by design when you don't need the intermediate back-and-forth. When a subagent is worth its own overhead covers that second question - delegation vs. keeping the work in your main thread - in more depth; this article is specifically about what happens once you've already decided to delegate.

Where the two mechanisms actually overlap

They're not always a fork in the road. You can point a teammate at an existing subagent definition by name when spawning it - the definition's tools allowlist and model apply, and its body gets appended to the teammate's system prompt as extra instructions. That lets you define a role once, such as a security-reviewer, and reuse it as either a plain delegated subagent or a full teammate depending on whether the task needs peer coordination.

The overlap cuts the other way too, and it's the part that can quietly inflate a bill. Once agent teams are enabled, Claude sometimes names a subagent on its own so it can message it later - and while the flag is on, a named subagent launches as a teammate automatically, even in a delegation you never framed as team work. If a workflow that used to spawn ordinary subagents starts costing noticeably more after you turn agent teams on, this is the first thing to check. Setting CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=0 restores the old behavior: a named subagent goes back to running as an ordinary subagent, reporting its result back the moment it completes.

When none of this applies to you

If you've never set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS, agent teams are off, full stop - the feature is disabled by default, and none of the cost math above is happening in your sessions regardless of what you've read about them. And if your Claude Code usage is entirely headless - CI runs, scheduled tasks, an Agent SDK integration - this comparison doesn't apply either: teammates require an interactive session to spawn, so a named subagent in -p mode runs as a subagent no matter what the flag says. Fan-out has its own separate ceiling worth knowing regardless of which mechanism you use - Claude Code caps concurrent subagents by default, and a team is capped in its own way too: no nested teams, and no promoting a teammate to lead mid-session.

FAQ

• Do agent teams really cost more tokens than subagents? Generally yes. A subagent pays a fixed, one-time system-prompt cost and discards its context after reporting a summary. A team's teammates are full sessions that keep billing context on every turn - Anthropic puts that at roughly 7x a standard session's tokens when teammates work in plan mode, and the multiple scales further with team size and how long teammates stay active.
• Are agent teams on by default? No. They're experimental and disabled until you set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in settings.json or your shell environment.
• Can I use agent teams in a headless script or CI job? No. Spawning a teammate requires an interactive session. In non-interactive mode (-p, or the Agent SDK), Claude never spawns a team even with the flag enabled - a named subagent there just runs as an ordinary subagent.
• Can a subagent turn into a teammate without me asking for a team? Yes. Claude sometimes names a subagent on its own so it can be messaged later, and while agent teams are enabled, a named subagent launches as a teammate automatically. Set the environment variable back to 0 to stop it.
• What's the cheapest way to parallelize work if I don't need teammates talking to each other? Plain subagents. They pay a small fixed cost per call and discard their context after returning a summary, instead of running as independent sessions that keep billing until shut down.
• Do teammates inherit my conversation history the way a forked subagent does? No. A teammate loads fresh project context - CLAUDE.md, MCP servers, skills - plus the lead's spawn prompt, but not the lead's conversation history. Only a context: fork subagent inherits the full parent conversation.

None of this replaces checking your own setup: if agent teams are part of your workflow, the free scan reads your real Claude Code session history and shows what your subagent and teammate calls are actually costing you, not a modeled 7x. And if the honest answer for your task is "just delegate," the subagent cost calculator prices out whether spawning N subagents beats doing the same work in one session before you reach for either mechanism.

Made by Neo

UsageCut by ClockedCode - not affiliated with Anthropic. The figures on this page are measured on real Claude Code sessions and labeled measured or estimated where it matters.