MCP servers are the hot new plumbing for Claude Code. Drop in a GitHub server and your agent can open pull requests. Add a filesystem server and it reads your repo structure. The demos look magical. What nobody demos is the receipt.
The cost is not in the API calls the tools make. It is in the tools themselves.
Every time you register an MCP server, you are not just adding a capability. You are adding a block of text to your context window, and that block gets billed on every single turn. Whether the agent uses the tool or not, you pay for its existence. The meter starts running the moment the server connects.
Paying Rent on Tools You Never Touch
Here is the mechanic that gets glossed over. Each tool definition in an MCP server ships with a name, a description, and a JSON schema telling the model what arguments the tool expects. That entire payload gets injected into the system context at the start of every turn. The model needs to see the full catalog so it can decide whether to call a tool, but you are the one footing the bill for that visibility.
The overhead per tool is not trivial. In practice, a single tool definition consumes between 80 and 150 tokens. That means a modest server exposing ten tools quietly eats 800 to 1,500 tokens before you have typed a single sentence. You are not paying for compute. You are paying for the privilege of having the option.
I ran the numbers across a standard 20-turn session to see exactly how this compounds.
With no MCP servers loaded, the overhead is zero. The context window contains only your conversation.
Load a custom minimal server with three tightly scoped tools, and the tax is 180 tokens per turn. Across 20 turns, that is 3,600 tokens gone. Not a disaster, but real money.
The popular filesystem server, which exposes seven tools, pushes that to 640 tokens per turn. Over the same session, you have burned 12,800 tokens just maintaining the connection. You have not read a file yet. You have not listed a directory. You have merely kept the server on the menu.
Then there is the GitHub server. With 26 tools registered, it dumps 3,100 tokens into every turn. After 20 back-and-forth messages, the overhead totals 62,000 tokens. At Sonnet 4 pricing, that is $0.19 in pure context tax. You paid nineteen cents for overhead before the agent even considered creating an issue.
That figure feels small in isolation. It is not.
The Overnight Agent Problem
Where this stings is in long-running autonomous loops. If you are using Claude Code as an agent that iterates on its own, that per-turn tax multiplies brutally. An agent running overnight across 2,000 turns with the GitHub server loaded does not pay 62,000 tokens in overhead. It pays 6.2 million.
That is $18.60 spent on literally nothing productive. The agent might have slept through the night without touching a single GitHub tool. It might have worked entirely inside local files. You still get charged for all 26 GitHub tool definitions on every one of those 2,000 turns because they were registered in the session.
The critical point to internalize is that you pay for registered tools, not called tools. The model does not check which tools it actually uses and then discount your bill. If the server is connected, its full manifest is re-introduced into context each cycle. This is a per-turn tax on potential, not on action.
For developers running iterative coding agents, test harnesses, or batch review jobs, this is a silent budget killer. A human conversation of 20 turns is light. An agentic loop of 200 or 2,000 turns is where the math turns punitive.
How to Keep Costs Under Control
MCP is genuinely useful. You should use it. But treat it like a utility you switch on for the job at hand, not a permanent fixture you bolt onto every session.
Scope Configs to the Project and Task
Do not load every server into your global Claude Code configuration by default. Build project-scoped MCP configs that match the work you are actually doing. If you are refactoring a local module, you probably need the filesystem server and nothing else. If you are triaging issues, load the GitHub server for that specific task and disconnect it when you switch back to local development.
Think of it like leaving apps open on your phone. One or two is fine. Twenty running in the background drains the battery for no reason.
Prefer Servers with Fewer Tools
Not all MCP servers are designed with the same discipline. Some expose a lean interface of two or three focused actions. Others ship a sprawling catalog of 25 or 30 tools, many of which you will never invoke. A server with three tools might cost you 180 tokens per turn. One with 26 tools can cost 3,100. That is a 17x jump in overhead for a capability gap that may not matter to you.
Before installing a server, look at its tool manifest. If it registers a dozen overlapping operations and you only need one, consider whether you can configure it down, fork it, or write a slimmer wrapper. Every tool definition you can strip out is a direct and permanent token saving on every future turn.
Trim Tool Descriptions
The 80 to 150 token range per tool is not a law of nature. It is a function of how verbose the descriptions and schemas are. A bloated 400-token description eats five times the context of an 80-token description, and that fivefold penalty applies on every single turn.
Audit the servers you rely on. If a tool description reads like marketing copy, rewrite it. Cut adjectives. Cut examples that do not clarify the schema. Tighten the JSON. The model needs to understand what the tool does, but it does not need a paragraph of preamble. Treat tool definitions like code: the shorter and clearer, the better.
The Real Takeaway
MCP extends what Claude Code can reach. It does not extend your context window for free. The overhead is deterministic, recurring, and entirely disconnected from whether the tools see action.
Load only the servers your current task demands. Disconnect them when you are done. Audit tool counts and description lengths like you would audit any other dependency. The rule is simple: if the tool is not adding value in this specific session, it should not be adding tokens to your bill.
Source measurements and methodology: I added MCP servers to Claude Code — here’s what they cost in tokens
Join the GyaanSetu AI learning community for more engineering breakdowns: t.me/GyaanSetuAi