Your Agent's Identity Costs 104 Tokens

Plan and Explore are different agents. Different names, different system prompts, different jobs — one designs implementations, the other searches code. They are permitted exactly the same tools.

Booted on the same task, they cost 14,336 and 14,232 tokens. A difference of 104.

The previous post measured that a subagent costs about 34,000 tokens before it reads a file, and left that number whole. This one takes it apart. The short version: almost none of it is the agent, and most of what is left is two tools.

First, a correction

That post decomposed a set of one-tool-call runs into “34,040 fixed plus 132 per file” and called 34,040 a fixed charge for existing. Extrapolating to zero files is not the same as measuring zero work, and the difference is now measurable. A general-purpose subagent asked only to reply OK, using no tool at all, costs 31,484 tokens.

So the real split is 31,484 to boot and 2,688 for the first tool-calling turn. The earlier figure was boot plus one turn wearing a label that said boot. Every number below is a zero-tool-call measurement.¹

How you decompose a number you can only read as one integer

The harness reports subagent_tokens as a single aggregate — no split into input, output, cache read or cache creation. You cannot inspect it. You can only vary one thing and subtract.

The built-in agent types turn out to be a ready-made factorial design, because two pairs of them differ in exactly one variable:

flowchart TB
subgraph P1["7 resident tools — identical"]
  E["Explore"]
  PL["Plan"]
end
subgraph P2["11 resident tools — identical"]
  G["general-purpose"]
  C["claude"]
end
P1 -->|"subtract across:<br/>isolates 4 tool schemas"| P2
E -.->|"subtract within:<br/>isolates system prompt"| PL
G -.->|"subtract within:<br/>isolates system prompt"| C

Every run below is the same prompt — reply with exactly the two characters: OK, do not use any tool — on Haiku 4.5, in background mode, against this repository.¹ CLAUDE.md drops out of the accounting entirely on this machine, because the user-level file is 0 bytes and the project has none.

Run twice, the same type lands in the same place: Explore measured 14,232 and 14,230, general-purpose 31,484 and 31,499. Spreads of 2 and 15 tokens — 0.01% and 0.05%. This meter is effectively deterministic, which is what makes subtraction legitimate.

The agent is not the cost

Plan and Explore differ by 104 tokens, 0.73%. claude and general-purpose differ by 130, 0.41%.

Those are the entire measurable cost of being a different agent — a different name, a different description, a different system prompt telling the model what it is for. Whatever else the choice of agent type does for output quality, it is not what you are paying for at boot.

Move across the pairs instead and the picture inverts. general-purpose boots 17,252 tokens heavier than Explore.

Explore is documented as “all tools except” a list of nine. But five of those nine — ArtifactComments, ArtifactData, ArtifactCheck, ExitPlanMode, NotebookEdit — are not resident in general-purpose either, so excluding them costs nothing. I asked each type to enumerate what it could actually call without loading anything first:

So the 17,252 is not nine tools. It is four: Agent, Artifact, Edit, Write. An average of 4,313 tokens each, which is three times what a tool costs at the other end of the table.

Tools are not priced alike

Two points fix a line. statusline-setup carries 2 resident tools for 6,467 tokens; Explore carries 7 for 14,232. That is 1,553 tokens per tool with an intercept of 3,361 — the part that is neither tools nor agent identity: the harness scaffolding, the environment block, the git status, the names of the deferred tools.

Extend that line to 11 tools and it predicts 20,444. general-purpose actually costs 31,484.

An excess of 11,040 tokens over four tools that the line says should have cost 6,212. Edit and Write are ordinary file-editing tools and there is no reason to think they are outliers. Agent and Artifact are the two with long, prose-heavy descriptions — the ones that document a whole subsystem rather than a function signature.

I can bound them as a pair and not separate them, because no built-in agent type on this machine carries one without the other. That limit is real and I am not going to paper over it. What the measurement does establish is that tool schemas are not fungible, and that a per-tool average is the wrong unit for budgeting a fleet.

What the harness already does about this

The same enumeration returns a second number: general-purpose and Explore each reported 117 deferred tools — 8 built-in and 109 MCP tools, from seven servers connected to this session. Deferred means the agent knows the name and must call ToolSearch to fetch the schema before it can call the tool.

At the measured 1,553 tokens per tool, 109 resident MCP schemas would be roughly 169,000 tokens — more than five times the whole boot, per agent, on every fan-out. That is the bullet the deferral mechanism is dodging, and it is why connecting a seventh MCP server did not quietly quintuple the cost of every subagent.

It also reframes the previous post’s headline. A general-purpose subagent is not expensive because the harness is careless with context. It is expensive despite the harness having already moved 91% of its tools out of the boot.

Narrowing the toolbox can make it heavier

claude-code-guide is the type with the shortest allowlist that still does real work: Glob, Grep, Read, WebFetch, WebSearch. Five tools, and it boots at 12,570 — between the two-tool and seven-tool anchors, roughly where the line says it should be.

Roughly, but 1,444 tokens over. And the enumeration says why. Two of its five resident tools are WebFetch and WebSearch — which are deferred in both Explore and general-purpose. Naming a tool in an allowlist does not merely permit it; it promotes it out of the deferred roster and into the boot.

The deferred count moves too, and hard: 117 for Explore and general-purpose, 30 for claude-code-guide. A narrow allowlist shrinks both lists — but it pulls whatever it names to the expensive side of the line.

So “restrict the tools to save context” is not reliably true. It was true for Explore, which drops four resident schemas and keeps the same 117 deferred. It would be false for an allowlist of three tools that happened to name three deferred ones, which would add to the boot while looking like a restriction. The rule that actually holds is narrower: you save only by removing tools that were resident to begin with, and the only way to know which those are is to ask the agent.

Turns are cheap once you have paid to exist

One more curve, on Explore, varying only how many tool calls the task forces:

Zero calls, 14,232. One call, 16,053. Three calls, 16,455. The first tool-using turn costs 1,821; each additional call costs about 201.

At three tool calls the boot is still 86% of the bill. This is the same asymmetry the previous post found across files, measured across turns instead, and it says the same thing: a subagent you have already paid for is cheap to keep working, and a subagent you spawn to do one small thing is nearly all overhead.

What this does not settle

Agent and Artifact are bounded as a pair. No built-in type here carries one without the other, so 11,040 is their joint excess and I cannot split it. Defining a custom agent with tools: Bash, Artifact would separate them in one run.

Which brings up the thing that cost me an hour. I wrote exactly those custom agent definitions into .claude/agents/ and every spawn failed with Agent type 'probe-floor' not found. The registry is read at session start; files added mid-session are invisible until you restart. The documented tools and disallowedTools fields are the right lever for this — they are simply not a lever you can pull in the session you are measuring. Relatedly, an agent whose allowlist resolves to nothing refuses to launch, so there is no zero-tool floor to measure; 2 tools and 6,467 tokens is as close as this machine gets.

One model, one machine, background mode. Everything here is Haiku 4.5 in background subagents, and the documentation says background agents receive a smaller built-in tool set than foreground ones. The intercept of 3,361 includes a git status block and an environment block that will differ on your repository.

The aggregate is still opaque. subagent_tokens does not split into input, output and cache classes, so none of this converts to money. Every figure here is a token count and a ratio, deliberately.

Takeaways

• Agent identity is ~0.5% of boot. Same tools, different system prompt: Plan − Explore = 104 tokens; claude − general-purpose = 130. Pick agent types for behaviour, never to save context.
• The toolbox is the bill. general-purpose boots 17,252 tokens heavier than Explore, and that gap is four resident tools, not the nine the exclusion list names. Check what an agent type actually loads before assuming a restriction saves anything.
• Tools are not priced alike. A linear fit says 1,553 tokens per tool; Agent and Artifact carry 11,040 tokens of excess between them. Budget by schema weight, not tool count.
• An allowlist promotes as well as restricts. claude-code-guide names WebFetch and WebSearch, which are deferred everywhere else, and pays for them at boot. You save context only by dropping tools that were resident already.
• Deferral is doing the heavy lifting. 11 tools resident, 117 deferred, 109 of them MCP. Resident, those would add roughly 169,000 tokens per agent — 5.4× the entire boot.
• Boot dominates until the work does. Zero, one and three tool calls cost 14,232 / 16,053 / 16,455. Even at three calls, 86% of the bill was paid before the first one.
• Part one’s 34,040 was boot plus one turn. Measured at zero tool calls, the boot is 31,484 and the first tool-using turn is 2,688.

References