The MCP Context Tax: Measure It Before Adding a Server
721 tools from 19 servers, 55,000 tokens spent before your first question, and a 4,096-character cap that truncates tool descriptions silently.

You flip on one more MCP server because the switch takes a second, and the next morning your agent forgets things it remembered yesterday. Nothing broke — you just spent a chunk of the context window before typing your first question.
Here is what that spend actually looks like in numbers, how to measure your own server in about 30 lines, and the one Claude Code setting that silently cuts your tool descriptions to a quarter of their length.
An unused tool is still a standing charge
The mechanism is worth stating plainly, because the settings page hides it. A tool does not sit idle until it is called. For the model to know a tool exists, the host sends that tool's full definition — name, description, and the complete JSON schema for its inputs — with every request. Every tool you register is a standing charge on every turn, whether it fires or not.
That text lands in the context window before your first question. Multiply it by the number of servers you left switched on last quarter and the bill stops being theoretical.
What the numbers look like
One developer counted their own Claude Code setup and published the comparison against Anthropic's documented example:
| Anthropic's example | Their session | |
|---|---|---|
| Servers | 5 | 19 |
| Tools | 58 | 721 |
| Tokens if every definition loads | about 55,000 | 200,000 to 680,000 (their estimate) |
| Tokens that load in practice | all 55,000 in that example | 11,000 to 14,000 (their estimate) |
The Anthropic figure comes from a November 2025 example: five servers with 58 tools used about 55,000 tokens before the conversation started, and the GitHub server alone accounted for 35 tools and roughly 26,000 tokens. Worked backwards, that example lands between 740 and 950 tokens per tool. A reader who ran the measurement in Claude Code got about 280. Those two per-tool rates are what produce the wide 200,000-to-680,000 band above — and even the low end fills a 200,000-token window.
One detail in that count deserves its own line: a single server declared 265 of the 721 tools. Server count is a bad proxy for cost. Tool count is the number that matters.
That session still works because the client defers loading — it puts only tool names in the context and fetches a full definition when the model asks for that capability. The names are not free either. The list of names alone runs to 43,000 characters, which they estimate at 11,000 to 14,000 tokens in every conversation.
Measure your own server before it grows
A second developer audited their own two-tool MCP server before adding a third, using a dependency-free script. Token counts depend on the tokenizer, so it estimates two ways — at 4 characters per token and at 3.6 — and reports the serialized size, which is exact:
const tools = [ /* your tool definitions, as your host sends them */ ];
for (const t of tools) {
const s = JSON.stringify(t);
console.log(t.name, "chars=", s.length,
"estTokens@4cpt=", Math.ceil(s.length / 4),
"estTokens@3.6cpt=", Math.ceil(s.length / 3.6));
}
const all = JSON.stringify(tools);
const perTurn = Math.ceil(all.length / 4);
console.log("TOTAL tools=", tools.length, "chars=", all.length,
"estTokensPerTurn@4cpt=", perTurn);
console.log("10-turn cumulative @4cpt=", perTurn * 10);
console.log("Share of a 200k window @4cpt=", (perTurn / 200000 * 100).toFixed(3) + "%");
The useful part is not the estimate, it is the last two lines: per-turn cost multiplied out across a conversation, and the share of the window it claims. A number that looks trivial per turn is the number you pay ten times in a ten-turn session.
If you are a consumer rather than an author of servers, Claude Code exposes the same answer directly: /context shows how much of the window tools occupy.
The 4,096-character trap
Here is the part that bites server authors without saying so. Claude Code caps an MCP tool's description at 4,096 characters when the tool loads upfront, and at 16,384 characters when it sits behind tool search instead. That is a 12,288-character difference — a 4.0x ratio.
Setting alwaysLoad to true on a server cuts every one of its tool descriptions down to the smaller limit, without touching the description text itself. And the truncation is silent: Claude Code cuts a tool description or server instructions that run past whichever limit applies, and the model sees only the text before the cut. There is no error and no warning line in the terminal — just a shorter description than the one your server actually sent.
Three configurations, three different budgets:
| Loading mode | Description limit | How a tool ends up there |
|---|---|---|
| Loads upfront | 4,096 chars | alwaysLoad set to true on the tool or the server, or tool search turned off |
| Loads through tool search (deferred) | 16,384 chars | Default behavior — alwaysLoad left out, tool search on |
auto or auto:N threshold | 4,096, then 16,384 | ENABLE_TOOL_SEARCH set to auto or auto:N — the larger limit applies once tool search turns on |
So if a tool of yours behaves as though the model has not read half its instructions, check the loading mode before you rewrite the prose. Claude Code defers MCP tool definitions by default — tool names and server instructions load first, and a tool's complete definition loads once the model searches for a capability it needs. Forcing alwaysLoad to get a tool noticed is the move that quietly costs you 12,288 characters of explanation.
The cost the context budget does not cover
Token math is the cheap part of this decision. In early November 2026, the German hosting company Mittwald disclosed that a breach of 56 customer projects came through an MCP server it operates, and took the server offline. By the company's own account the server was the entry point; it has not said what the flaw was.
The protocol itself does not arbitrate this. MCP defines how a tool is declared and called — what a caller is allowed to do with it is up to each server. A mail server reads other people's text and hands it to the model, and that text can carry instructions aimed at the model. In the settings page, a first-party server and an unreviewed third-party one look identical.
Worth noting for anyone auditing their stack against a tutorial: the current specification is version 2026-07-28, which removed sessions entirely — each request now carries its own protocol version, and every server must offer a discovery call listing what it supports. Anthropic published the protocol on November 25, 2024 and donated it to the Agentic AI Foundation under the Linux Foundation in December 2025. A guide with no date and no version number is describing a different protocol.
Do this before you add the next server
Run /context in your next session and write down the share your tools occupy. Count the tools, not the servers — one of them may be declaring hundreds. If you ship an MCP server, run the audit script against your own definitions and check whether any description is riding near 4,096 characters under alwaysLoad. Then switch off every server you have not used this week, and keep the connected list to ones published by the owner of the service they reach.
More from DangMua