The Token Tax of Tool Use and Agents

Last updated 19 September 2026. This page explains llm tool use cost and agent token cost as an operational problem: why tool-calling agents burn more than chat, how tool call tokens accumulate across rounds, and which levers actually move the bill. Tool-schema encoding, prompt-caching multipliers, and product surfaces (Cowork, Claude Code, Messages API) evolve — confirm live behavior in Anthropic’s docs and your own usage meters. Where API list prices appear for orientation (Haiku 4.5 $1/$5, Sonnet 5 $2/$10, Opus 4.5+ / Opus 5 $5/$25 per MTok in/out), they were checked against Anthropic’s published Claude API pricing on that date. [VERIFY: 2026-09-19]

Not affiliated with Anthropic. Claude Token Optimization is an independent site and audit service. Claude® and related product names are trademarks of Anthropic PBC. Plan prices, model rates, and usage limits change; always confirm on Anthropic’s own docs. [VERIFY: 2026-09-19]

Searches for llm tool use cost, agent token cost, tool call tokens, and “why did my agent empty the bar” usually want the same answer: chat feels cheap because you type most of what enters the window; agents feel expensive because the model schedules tool rounds you never typed — and each round re-pays schemas, history, and results.

This spoke sits under the Optimize hub. Pair it with model routing (cheap model for planning), Claude Code token cuts, the Cowork cost hub, and subagents. Soft CTA to a written review at the end — no dollar price on this page.

Why agents cost more than chat

In chat, volume is mostly visible: system prompt, conversation history, your paste, the reply. You feel the window grow because you are typing most of what enters it. In an agent loop — Cowork, Claude Code, or a Messages API tool-use run — the model becomes the scheduler. It may call tools, observe results, plan the next step, and retry. Token volume becomes invisible until Settings > Usage or the API bill turns red.

Five structural taxes show up almost every time someone asks why agent token cost dwarfs a similar chat session:

1. Tool schemas sit in context every turn — names, descriptions, parameter JSON Schema. Unused tools still cost listing overhead.
2. Tool results are re-injected — every observation (file dump, search hit, API payload, screenshot text) re-enters the window for later turns.
3. Multi-step loops multiply rounds — one goal becomes N model calls, each carrying growing history.
4. Parallel subagents multiply windows — each worker has its own context and often its own tool set.
5. Retries bill as real work — failed tool calls, wrong-direction repairs, and “try again” loops stay in history until you clear or bound them.

None of this means agents are a bad buy. It means the unit of work is no longer “one reply.” The unit is tool rounds × tokens per round. If you only watch output length, you will always under-predict spend. That is Stage 1–2 of the LLM cost framework (Measure → Attribute) applied to agents.

Anatomy of one tool round (where tokens go)

Treat a single agent step as a billable package. Exact encoding differs by product and API version — confirm in Anthropic’s tool-use docs — but the cost shape is stable: [VERIFY: 2026-09-19]

Prompt caching can blunt the standing-prefix and stable-schema tax when the prefix is identical across turns — see prompt caching pricing. Caching does not erase growing history or fat tool results. If every round appends a 40k-token file dump, you still pay for that dump on the turns that include it.

How to measure: log tool rounds × tokens

You cannot manage what you do not attribute. Before buying a bigger plan, instrument one representative run (a Cowork task, a Claude Code ticket, or an API agent job) and log:

• Rounds — count of model calls in the loop until Done or abort.
• Input / output tokens per round — from API usage objects or product usage views where available. [VERIFY: 2026-09-19]
• Tools exposed vs tools used — schema tax vs actual calls.
• Result sizes — tokens (or chars) per tool observation before summarization.
• Retry / repair share — rounds that did not advance the Definition of Done.

A minimal scorecard for one finished task:

Attribute at the task level, not the day level. A day-total that says “Max felt tight” does not tell you whether schemas, dumps, or fan-out did the damage. Put agent tasks next to chat tasks in the same weekly review you use for team tracking. For how tokens are counted at all, start with how Claude tokens work. To estimate cost before you ship a loop, open the calculator once you know average rounds and tokens per round.

Practical logging tips: tag each run with a task id; record model id per round; store tool name + result char count even when the full payload is discarded; mark rounds as progress vs retry. After ten tasks you will see whether tool call tokens are dominated by schema tax, observation dumps, or repair thrash — three different fixes.

Six levers that cut tool-use token tax

Order matters. Cut standing waste before you route models; route before you buy capacity. These levers map to Stage 3 (Reduce) in the cost framework and complement the general cut token usage playbook.

1. Fewer tools per turn

Expose only the tools the current phase needs. A research phase does not need write/deploy tools; a repair phase does not need the entire MCP catalog. Wide “just in case” tool lists are silent kilo-tokens on every round — even when the model never calls them. Claude Code and Cowork surfaces that attach many servers or plugins pay this tax first; see Claude Code token hygiene.

A simple rule: if a tool was not called in the last N successful runs of this workflow, drop it from the default set and load it only on an escalate path. Phase-gated toolsets beat one mega-catalog almost every time we inspect agent traces.

2. Shorter schemas and descriptions

Tool descriptions are prompts. Long essays in description fields, duplicated parameter docs, and unused enum forests add up. Prefer crisp contracts: what the tool does, required args, failure modes. Keep examples out of the schema when they belong in a one-time system note — or behind a cacheable prefix.

3. Summarize tool output before re-injection

Raw tool results are the usual killer. Prefer: extract the fields the next step needs; truncate file reads to relevant spans; convert huge JSON to a short table; drop stack traces after the first actionable frame. If the model needs the full artifact later, store it outside the window and pass a handle — do not keep pasting the blob. This single habit often beats model downgrades for agent spend.

4. Cap iterations and define Done-when

Unbounded loops are how one vague brief becomes eighteen rounds. Write a Definition of Done and a hard step cap in the parent brief. Abort to a human when the cap hits instead of “one more try.” The same discipline shows up on Cowork costs and in coding sessions that should /clear between tickets.

5. Route a cheap model for tool planning

Not every round needs Opus. Classification of next tool, extraction from a known schema, and “is this Done?” checks are often Haiku-class work. Keep Sonnet or Opus for hard reasoning and merge-risk code. Document the default map on model routing so ambient Opus does not become the agent’s personality.

6. Cache stable tool definitions

When tool defs and system instructions are identical across turns, prompt caching can make the stable prefix much cheaper on subsequent reads. Structure prompts so volatile content (latest tool result, user delta) sits after the stable block. Confirm current cache write / read multipliers on Anthropic’s pricing docs. [VERIFY: 2026-09-19] Details: prompt caching and what is prompt caching.

Cowork, subagents, and Claude Code: same physics

Product surfaces differ; the tax does not.

• Claude Cowork — desk-style agentic work: many observations per goal, easy to thrash without Done-when.
• Subagents — fan-out helps when workers have narrow briefs and budgets; it multiplies spend when each worker inherits a fat tool catalog and no cap.
• Claude Code — file reads and repair loops are the default research tools; failed patches stay in session until you clear or compact.

Choosing the surface is a cost decision, not only UX — see Cowork vs Claude Code. Shared plan pools mean an afternoon of agent thrash starves chat for everyone on the seat; pair this page with usage limits when the bar is the symptom.

Illustrative before / after (method demo)

No invented customer case studies — a worked method only. Suppose a Messages API agent exposes 20 tools (~6k tokens of schemas), averages 15 rounds, and re-injects ~12k tokens of raw results each round on Sonnet 5 list rates. Rough input load is dominated by schemas + growing history + dumps — not by the user’s one-line goal.

Teams that only swap models without summarizing results often see a smaller bill and the same cliff two days later. Structure first; routing second; capacity last — the same order as eleven ways to cut token usage.

API vs seat-plan metering

On the Claude API, tool rounds show up as ordinary input/output (and cache) tokens on the Messages (or equivalent) usage line — there is typically no separate “tool call fee” beyond the tokens those messages consume. Confirm current billing language in Anthropic’s pricing docs. [VERIFY: 2026-09-19]

On Pro / Max / Team seats, the same loops draw down session and weekly capacity (and usage credits when enabled). Agents feel “suddenly expensive” because one goal is many model calls. Inventory meters honestly: seat Settings > Usage, credits, and Console keys with owners. Unlabeled agent spend is a finding — see what an audit finds.

If you are deciding whether to stay on seats or move a workload to API metering, compare cost per finished task (rounds × tokens × rate) rather than sticker plan price. Heavy agent workflows often look cheaper on API once you can attribute and cap them; light interactive chat often stays happier on seats. Cross-check Pro vs API and cost per task once your round logs exist.

When a written audit is the right next step

Self-serve this page when one lever dominates — for example, you already know raw tool dumps are the problem and you only need a summarization rule. Hand off when several stack: wide tool catalogs, uncapped retries, Opus-everywhere planning, and a weekly bar you cannot attribute to chat vs agents.

A written Claude token audit maps the paste (system prompts, tool schemas, one run transcript), ranks drivers, and returns a Monday change list — soft path, no call required. See audit findings for the pattern catalog and example report for deliverable shape. Price lives only on the audit checkout page so it cannot drift across optimize spokes.

Ready when tool loops are eating the week: start the Claude token audit — paste prompts / run transcripts, get a written report, leave with a Monday plan.

FAQ

Do tool calls cost extra beyond tokens?

Treat tool use as token consumption (schemas, calls, results, follow-up reasoning) unless Anthropic documents a separate surcharge for your product. Confirm on current pricing and tool-use docs. [VERIFY: 2026-09-19]

Why is my agent more expensive than chat for the “same” question?

Chat answers in one or two turns. Agents schedule many tool rounds; each round re-pays schemas and history. The user-visible question is the same; the hidden work is not.

Should I remove all tools to save money?

No. Remove unused tools and shrink results. Tools that prevent five wrong-direction rounds can be net savings. Measure rounds × tokens, not tool count alone.

Do subagents always increase agent token cost?

No. Narrow workers with caps can reduce wall-clock and parent-context bloat. Wide fan-out with shared fat catalogs multiplies spend. Details: subagents.

Where does model routing fit?

After you shorten schemas and results. Routing a fat dump to Haiku still burns the dump. Then assign Haiku / Sonnet / Opus by round type — see model routing.

Is this only for API builders?

No. Cowork and Claude Code users hit the same physics through product UIs. API teams see it in usage objects; seat users see it in Settings > Usage.

Next steps

1. Log one agent task: rounds, tokens/round, tools exposed vs used, retry share.
2. Cut unused tools and summarize the largest tool results.
3. Add Done-when + a hard iteration cap to the parent brief.
4. Route planning / triage rounds per model routing; cache stable defs when prefixes match.
5. Apply surface-specific hygiene on Claude Code and Cowork.
6. If several waste patterns stack, paste for a written audit.

Tool use is how agents create leverage. The token tax is how that leverage shows up on the bill. Measure rounds × tokens, cut schemas and dumps first, then route — so the agent finishes the job without finishing your week.