Software economics and Korea inbound research, from Seoul.

Horizontal bar chart of tool definition tokens per request: 55,000 for the Anthropic five-server example, 12,491 for Chrome DevTools MCP with 63 tools and 233 for its slim mode

MCP Tool Definitions Cost 55,000 Tokens Before Your Agent Works (2026)

30-Second Verdict — Direct Answer

MCP tool definitions are billed and stored on every request. Anthropic’s own documentation puts a five-server setup at about 55,000 definition tokens before Claude does any work, and says tool-choice accuracy drops past 30 to 50 tools. Counted from the servers’ published references, chrome-devtools-mcp exposes 63 tools worth 12,491 tokens, while its –slim flag keeps 3 tools worth 233.

What your MCP servers spend before the first message

interactive

Defaults are measured, not guessed: chrome-devtools-mcp 1.13.0 exposes 63 tools whose published definitions total 12,491 tokens (198 per tool). Change the numbers to match your own servers.

servers
tools
tok
USD/MTok
req/day
tok
Definitions per request—Counted before your system prompt and before the user’s first line.
Share of the window—Only definitions; history and tool results stack on top.
Cost per month, uncached—Every request pays for the whole definition list as input.
Cost per month, cached prefix—Cache hits bill at 5 percent of the input rate on Sonnet 5.5 and Opus 5.5.
Cost per month, after tool search—Anthropic’s stated cut is over 85 percent, loading 3 to 5 tools per request.

Definitions per tool come from the vendors’ generated tool references, tokenised with cl100k_base as a proxy for the model’s own tokeniser. Treat the result as a model, not a bill: your system prompt, history and tool results sit on top of it.

The first time I counted tool definitions instead of guessing at them, the number was four times my estimate. That is the whole problem in one line: the tools your agent carries are invisible in the interface, absent from the invoice line that says input tokens, and charged anyway, request after request, before your model reads a single line of your code. What surprised me was not the total. It was the per-tool average, and how much of it came from descriptions nobody had read.

What Anthropic says about its own tool list

The vendors have started saying the quiet part out loud. Anthropic's platform documentation on the tool search tool contains a sentence that reads like a confession from the people who built the format:

A typical multiserver setup (GitHub, Slack, Sentry, Grafana, and Splunk) can consume ~55k tokens in definitions before Claude does any work. Tool search typically reduces this by over 85 percent, loading only the 3–5 tools Claude needs for a given request.

Anthropic, Tool search tool documentation, read 17 November 2026

The same page names the second cost, which no calculator shows. "Claude's ability to pick the right tool degrades once you exceed 30–50 available tools." That is not a token bill. It is a correctness bill, and it arrives as a retry, a wrong file edit, or a browser session that opens the wrong page.

The mechanism is stated plainly in the context window guide: "Everything in the request counts toward the context window: the system prompt, every message in messages (including tool results, images, and documents), and your tool definitions." Definitions are input tokens. They are billed as input tokens. Prompt caching changes the price of those tokens, not whether they sit in the window.

What 63 tools cost, counted rather than estimated

Anthropic's figure covers servers nobody can inspect from outside. Browser servers publish their tool lists, so they can be counted exactly. I took the generated tool reference that chrome-devtools-mcp 1.13.0 ships in its repository, serialised each tool's name, description and parameter list the way a client sends it, and tokenised the result with cl100k_base as a stand-in for the model's own tokeniser. Playwright MCP publishes the same thing in its README, generated by its own build script.

Server and modeToolsDefinition tokensPer toolHow it was established
chrome-devtools-mcp 1.13.0, default6312,491198Counted from the vendor's generated tool reference
chrome-devtools-mcp 1.13.0, --slim323378Counted from the vendor's slim reference
playwright-mcp, default253,525141Counted from the README's generated tool section
playwright-mcp, every capability pack728,039112Same README, opt-in sections included
Five-server stack (GitHub, Slack, Sentry, Grafana, Splunk)not publishedabout 55,000—Anthropic's stated figure, not counted here
Table 1. Definition cost per request. The first four rows were counted on 17 November 2026 from the vendors' generated tool references, tokenised with cl100k_base; the last row is Anthropic's own published example.
Horizontal bar chart of tool definition tokens per request: 55,000 for the Anthropic five-server example, 12,491 for Chrome DevTools MCP with 63 tools, 8,039 for Playwright MCP with every capability, 3,525 for its default 25 tools and 233 for Chrome DevTools slim mode
Figure 1. Definition tokens per request. The hatched bar is Anthropic's published figure for a five-server stack; the other four were counted from the servers' generated references on 17 November 2026.

The spread inside one server is the part worth noticing. Chrome DevTools MCP averages 198 tokens per tool, Playwright 141, and the slim set 78. Description length drives it, not parameter count, which is why a two-tool family can outweigh a ten-tool family in the next table.

Where the 12,491 tokens sit

Not every tool costs the same, and not every tool earns its place in a coding session. Sorted by family, the distribution is lopsided in a way that suggests an afternoon of pruning would pay for itself.

Tool familyToolsDefinition tokens
Memory (heap snapshots)142,745
Debugging (console, scripts, CSS, logpoints)102,192
Input automation (click, type, drag, upload)101,292
Network mocks2929
Navigation6769
Emulation2713
Seven smaller families (performance, PWA, WebAuthn, network, third-party, extensions, WebMCP)192,851
Total, tool entries6311,431
Table 2. The 63 tool entries account for 11,431 tokens; the reference's own headings and front matter bring the file to 12,491. Counted 17 November 2026.
Horizontal bar chart of definition tokens by tool family in Chrome DevTools MCP: 2,745 for 14 memory tools, 2,192 for debugging, 1,292 for input automation, and smaller blocks for eleven other families
Figure 2. Where the 12,491 tokens sit. The heap-snapshot family is the largest block and the one a typical coding session never calls.

Fourteen heap-snapshot tools cost 2,745 tokens, more than every navigation, emulation and performance tool combined. Two network-mock tools cost 929, which is 465 tokens each and 20 percent more than the entire six-tool navigation family. At 300 requests a day, dropping the heap family alone is an annual saving of about 592 USD, and the breakeven for the afternoon it takes is measured in weeks. Neither family is wrong to exist. They are wrong to ride along on the request where the agent is asked to fix a contrast ratio.

The bill arrives on every request, not once a day

Here the arithmetic becomes concrete. At 300 requests a day on Claude Sonnet 5.5, with input at 2 USD per million tokens, every 1,000 definition tokens costs about 18 USD a month. Ten thousand tokens cost 180. That unit rate makes the comparison easy to hold in your head.

Definitions per requestUncached, per monthCached prefix, per monthAfter tool search, per monthShare of a 200k window
233 (DevTools --slim)$4.19$0.21$0.630.1%
3,525 (Playwright default)$63.45$3.17$9.521.8%
12,491 (DevTools default)$224.84$11.24$33.736.2%
55,000 (Anthropic's five-server example)$990.00$49.50$148.5027.5%
Table 3. Cost at 300 requests a day on Claude Sonnet 5.5 (2 USD per million input tokens, cache hits at 0.10 USD per million). Tool search is modelled at a 15 percent residual, the low end of Anthropic's "over 85 percent" cut.

Caching is the lever most teams reach for first, and it works: the same definitions at 5 percent of the input rate turn 224.84 USD into 11.24 USD. The cost difference is real money, and it is also a trap, because caching does nothing about the window. A cached prefix still occupies its 12,491 tokens. When the agent fills that window with file reads and tool results, the definitions are the part it cannot evict.

The accuracy bill is larger than the token bill

Anthropic's 30-to-50 guidance is the number to keep. Chrome DevTools MCP ships 63 tools in its default mode, which is 1.3 times past the top of that range before a second server joins. Playwright's default lands at 25, inside the range, and its full capability set at 72, outside it.

A wrong tool choice is more expensive than a definition list. It burns a request, then a retry, then the conversation history that explains what went wrong. In agent work the failure compounds: the model re-reads the same files, re-runs the same command, and pays the definition list again on every attempt.

Where 63 tool definitions go, and the switch for each case

diagram
Decision flow for tool definition budgets: 10 or fewer tools keep and cache, 11 to 30 prune per task, 31 or more defer or slim, with counted definition tokens for Chrome DevTools MCP and Playwright MCP
Figure 3. Decision path for a tool list that grew past 30 definitions, with the counted cost of each measured setup at the bottom.

The switches the vendors already shipped

Both browser-server vendors noticed the same thing, and each shipped a different answer. Google added a slim mode to Chrome DevTools MCP. Microsoft's Playwright MCP README now argues that its own CLI is the better fit for coding agents, and states the reason in token terms: "CLI invocations are more token-efficient: they avoid loading large tool schemas and verbose accessibility trees into the model context."

The Chrome DevTools configuration reference describes its flag in one line: "--slim exposes a 'slim' set of 3 tools covering navigation, script execution and screenshots only. Useful for basic browser tasks." The same reference documents narrower knobs, including a screenshot size cap that notes image tokens scale with dimensions rather than encoded bytes.

Anthropic's answer sits on the API side. Mark tools with defer_loading: true, add a tool search tool to the request, and the definitions stay in your catalogue until Claude asks for them. The API returns up to five matching tools per search by default and expands them into full definitions at that point. Anthropic puts the reduction at over 85 percent, and the search tool is supported from Claude Sonnet 4.6 onward, including Sonnet 5.5, Opus 5.5 and Haiku 5.5, but not on Opus 4.1 and earlier.

Two switches that keep the definitions out

copy-ready

Both blocks are copied from vendor pages read on 17 November 2026: the --slim flag from Chrome DevTools MCP's configuration reference, and deferred loading from Anthropic's tool search documentation.

mcp client config
{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": [
        "-y",
        "chrome-devtools-mcp@latest",
        "--slim"
      ]
    }
  }
}
messages.create (Python)
response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=2048,
    messages=[{"role": "user", "content": "What is the weather in Seoul?"}],
    tools=[
        {"type": "tool_search_tool_regex_20251119",
         "name": "tool_search_tool_regex"},
        {
            "name": "get_weather",
            "description": "Get the weather at a specific location",
            "input_schema": {
                "type": "object",
                "properties": {"location": {"type": "string"}},
                "required": ["location"],
            },
            "defer_loading": True,
        },
    ],
)

The tool search tool itself must stay non-deferred, and the API returns up to 5 matching tools per search by default. The slim set keeps navigate, evaluate and screenshot only, so move the rest to the CLI or to a second server before you switch it on.

The Honest Catch

To be honest, three limits sit under every number above. The token counts come from generated documentation, not from a captured request, so treat them as a faithful model rather than a meter reading; a client that trims descriptions will send less. The 55,000 figure is Anthropic's own example for a stack I cannot inspect, which is why it sits in its own row instead of being averaged with the counted ones. And the tokeniser is a proxy: cl100k_base is not Claude's tokeniser, so expect a few percent of drift either way.

The bigger caveat is capability. Slim mode removes the performance tracing, heap snapshots and Lighthouse tools that make Chrome DevTools MCP worth installing for a debugging session. A team that switches to three tools to save 12,258 tokens and then discovers it cannot record a trace has traded a real capability for a number. Judge the switch by the task the agent actually performs, not by the smallest possible count.

Audit your own setup in five steps

  1. List every MCP server your agent starts with, and the tool count each exposes. A server that starts with 63 tools is a decision someone made, and it can be unmade.
  2. Count the definitions once with the token-counting API or by tokenising the server's published reference. One measurement is enough to set a budget.
  3. Divide by your window. Above 10 percent, plan a change; above 25 percent, stop installing servers until you have made one.
  4. Match the lever to the tools. Browser work goes to --slim or a CLI. A long tail goes behind defer_loading. A stable, small set stays put and gets cached.
  5. Re-measure after each change, and write the number beside the server list, so the next installation argues with a figure instead of a feeling.

For the wider money picture, the site's cost per AI session calculator takes the same token arithmetic across a working day, and the cache-write and context-cliff breakdown explains why a prefix that looks cheap on paper still bills when it is rewritten. If your agent is failing at finding files rather than counting tokens, the deterministic pipeline comparison covers the other half of the problem. For a full stack decision that folds subscriptions, seats and usage into one number, the TCO decision calculator runs the same figures end to end.

Who should skip the trim

If you run a one-person shop and your agent starts one server with eight tools, stop reading and go build. A 2,000-token definition list is 1 percent of a 200,000-token window and 18 USD a month at 300 requests a day; the engineering hour you would spend trimming it is worth more than the saving. The same holds if your window is a million tokens and your stack is small: 55,000 tokens is 5.5 percent of it, and the money case collapses into caching.

The stack to leave alone is the one that is small, stable and genuinely used. The stack to change is the one nobody chose: 63 tools installed because the default config said so, a second browser server added for one screenshot, a memory toolset that has never opened a heap snapshot.

The one-page audit sheet behind this piece is a free PDF further down this page: no email, no credit card required, and risk-free to ignore if your stack is already small.

FAQ

Are MCP tool definitions really billed as input tokens?

Yes. Anthropic counts the system prompt, every message and every tool definition as input, and states that each of them occupies the context window. A definition list of 12,491 tokens is charged on every request that carries it.

Does --slim break the Chrome DevTools MCP setup?

It removes tools, so the sessions that need them break. The slim set keeps navigate, evaluate and screenshot; performance traces, network inspection and heap snapshots are not in it. Keep a full-mode entry in a second client profile, or reach for the CLI when a debugging session needs the long list.

Is tool search available on the model I use?

Anthropic lists it from Claude Sonnet 4.6 and Claude Opus 4.5 onward, including Sonnet 5.5, Opus 5.5 and Haiku 5.5. Opus 4.1 and earlier do not support it. The regex variant takes regex patterns; the BM25 variant takes natural language, up to 500 characters.

Does 55,000 tokens overflow a million-token window?

No. It takes 5.5 percent of a million-token window and 27.5 percent of a 200,000-token one. The reason to care is not overflow, it is price and tool-choice accuracy: the definitions are paid again on every request, and Anthropic says accuracy drops past 30 to 50 tools.

What if I cannot change the server's tool list?

Change the client instead. Deferred loading is set on the tool entry in your request, so a thin proxy or your own tool loop can add it. If the client gives you no such control, split the servers per task: a browser server for browser work, a repository server for code, never both in the same request.

The short version

  • Tool definitions are input tokens, billed on every request and held in the window.
  • Anthropic's five-server example costs about 55,000 tokens before any work; counted, Chrome DevTools MCP's 63 tools cost 12,491.
  • --slim keeps 3 tools and 233 tokens, a 98 percent cut that also removes the debugging tools.
  • At 300 requests a day, 1,000 definition tokens cost about 18 USD a month on Sonnet 5.5; caching cuts it to 5 percent of that, and tool search to roughly 15 percent of the remainder.
  • Past 30 to 50 tools, Anthropic says tool choice degrades, which costs more than the tokens.

Leave a Reply