MCP is the standard way to connect an AI assistant to your tools. I counted what my own setup brings into a session: 721 tools from 19 servers, against 58 in the example Anthropic published.
MCP, the Model Context Protocol, is the open standard that lets an AI assistant use your email, your repository or your database. You have probably met it as a settings page in Claude, Cursor or VS Code: a list of servers with a switch next to each. The switch takes a second. The cost is harder to see, so I counted it on my own machine.
One wrapper instead of many
Before MCP, every pairing of an assistant and a system needed its own integration. Anthropic published the protocol on November 25, 2024, as an open standard. A system is wrapped once, as a server, and every assistant that speaks the protocol can use it. In December 2025 Anthropic donated MCP to the Agentic AI Foundation, a fund under the Linux Foundation, so it now sits with a vendor-neutral body.
How one request works
There are three parts. The model decides which tool to call and runs nothing itself. The client is the application you work in, and it carries the calls. The server is a separate program that knows how to reach one system.
Say I ask for the email with my train tickets.
- The client has already told the model which tools the mail server offers.
- The model picks the search tool and fills in its arguments.
- The client sends the call to the server.
- The server searches the mailbox and returns a list of messages.
- The model reads the list and answers me in plain text.
A local server is an ordinary process that the client starts on your machine. In one of my clients, Antigravity, local servers have often dropped on my machine, and I had to reconnect them. When a tool goes missing, I check the process and the sign-in before I blame the model.
Check the date on anything you read
This article describes specification version 2026-07-28. That release changed how a connection starts. A client used to open a session with a setup exchange before it could do anything. Now there are no sessions: each request carries its own protocol version, and every server must offer a discovery call that lists what it supports. A client and a server built for different versions work together only if one of them supports both.
Many popular explainers still describe the old design or name no version at all. The next release is set for March 30, 2027. If a guide to MCP has no date and no version number, treat it as out of date.
The context bill
To call a tool, the model must know its name, its description and the shape of its arguments. That text goes into the context window before your first question.
Anthropic gave an example in November 2025: five servers with 58 tools used about 55,000 tokens before the conversation started. The GitHub server alone accounted for 35 tools and about 26,000 tokens. [1] The figure is a year old, so I use it only as a per-tool yardstick.
I counted my own setup in Claude Code. One working session has 721 tools available from 19 servers. A single server declares 265 of them.
| Anthropic's example | My session | |
|---|---|---|
| Servers | 5 | 19 |
| Tools | 58 | 721 |
| Tokens if every definition loads | about 55,000 | 200,000 to 680,000, my estimate |
| Tokens that load in practice | all 55,000 in that example | 11,000 to 14,000, my estimate |
The first estimate multiplies 721 tools by a per-tool cost. Anthropic's example works out to between 740 and 950 tokens per tool. A reader who ran the measurement in Claude Code got about 280. That puts the full load between 200,000 and 680,000 tokens. Even the low end fills a 200,000-token window.
The session works because the client defers loading. It puts only tool names into the context and fetches a full definition when the model asks for that tool. The names are not free either. My list runs to 43,000 characters, which I estimate at 11,000 to 14,000 tokens in every conversation.
Check whether your client does this. In Claude Code the /context command shows how much of the window tools occupy. If a client loads every definition up front, a handful of servers takes a quarter of the window, and a setup like mine does not fit.
What the protocol does not decide
In early November 2026 the German hosting company Mittwald disclosed that a breach of 56 customer projects came through an MCP server it operates. It took the server offline. [2] By the company's own account, the server was the entry point. Mittwald has not said what the flaw was.
MCP defines how a tool is declared and called. What a caller is allowed to do with it is up to each server.
That makes every server a question of trust. A mail server reads other people's text and hands it to the model, and that text can contain instructions aimed at the model. A server from an unknown author sees the same data. Its code may be open, but nobody rereads it on every update.
So I have one rule. I connect servers published by the owner of the service, and I do not connect third-party ones that can read or collect my data. In the settings the two kinds look identical.
Where to start
Connect one server to one project. Count the tools it declares and check what they take from your window. Then switch off every server you have not used this week.
I started with 721 tools and a bill I had never looked at. Yours is one command away.
Notes
- Introducing advanced tool use on the Claude Developer Platform, Anthropic, November 24, 2025.
- The Record and Webhosting.today, November 9, 2026.
Sources
- Introducing the Model Context Protocol, Anthropic
- MCP joins the Agentic AI Foundation, MCP blog
- MCP specification 2026-07-28, changelog
- A More Predictable Release Cycle for MCP, MCP blog
- Introducing advanced tool use on the Claude Developer Platform, Anthropic
- Alleged AI-aided cyberattack exploits assistant interface to breach German web host, The Record
- Mittwald Traces a Breach of 56 Customer Projects to Its MCP Server, Webhosting.today
Vladimir Beskorovainyi, Enterprise AI Architect & CTO, author of the Amazon bestseller "Enterprise AI: The KATA Way", founder of Besk Tech (besk.tech)
Top comments (10)
The 721 versus 58 comparison is the right way to make this visible, and what makes it worse than a one-time context load is that it is a per-turn tax. Tool definitions are resent on every turn, so a 20-turn session pays the tool block twenty times - and the cost scales with how long the conversation runs, not with how many tools you actually call.
Two numbers I would measure alongside the token count.
First, how many of the 721 were called in the last 30 days. The unused tail is not free context, it is context that pays rent every turn and returns nothing. The honest budget is the tools that get used plus the cost of carrying the ones that do not, which is exactly what you delete.
Second, tool-selection accuracy as a function of tool count. There is a count past which the model starts choosing a plausible neighbour instead of the right tool, and that failure looks like a model problem rather than a context problem - so it gets attributed to the wrong cause. With 19 servers it is very likely you have several near-duplicates, since almost every server ships its own search and its own fetch. Those are the ones that cost accuracy rather than tokens.
The switch taking a second while the cost is invisible is the exact shape of this problem: every tool you connect is cheap to add and expensive to audit. A per-server row showing tokens contributed and calls made would make the switch an honest decision instead of a one-way ratchet.
Thanks, both measurements are worth doing. I have not counted calls per tool yet, and I expect most of the 721 were never called. The near-duplicate point matches what I see: several servers ship their own search and fetch. On the per-turn cost, prompt caching softens it, but the window is still occupied on every turn. A per-server row with tokens and calls is exactly what I would want in the client.
Prompt caching is the right caveat and it splits the per-turn tax into two costs that need separate budgets. Caching lowers the price of resending the block; it does not lower the occupancy. So on a tight turn cadence 721 tools are cheap in dollars and expensive in window - and it is the window that binds, because a long-context agent needs that room for content rather than for schemas it will not call.
The second thing caching does not fix is cadence. A cache has a lifetime, so a conversation with a gap in it pays full price for the tool block on the next turn, and conversations with humans in them have gaps. The effective saving is therefore a function of how fast turns arrive, which is not something you control at design time - it is a property of how the thing is used.
Which is the argument for the per-server table living in the client rather than in a post: the numbers depend on your own call pattern and they change month to month as servers get added and removed. A static 721 is the right hook to make people look; a row per server with tokens and calls is the thing that makes them act.
On the uncounted calls - I would guess the distribution is worse than "most were never called". It is usually a small number of tools doing nearly all the work and a body of tools that were enabled for one task once. Those are the ones worth deleting, and they are invisible until you count.
Agreed on both. Price and occupancy are separate budgets, and the cache lifetime makes the saving depend on how the tool is used. I will count calls per tool and write up the distribution.
In a fresh Claude Code session in an empty folder, /context showed 36.6k tokens before I'd asked anything, and MCP was a small part of it. Three of my servers connected, with 35 tools. Their definitions took 650 tokens up front and server instructions 717, and the other 9.8k is deferred until the model asks for a tool. The descriptions of the 153 custom agents I have installed took 14.7k, more than all 35 tool definitions would if they loaded in full. Skills took 10k.
Thank you, this is the measurement my post lacks. Your 650 tokens for 35 tool names is about 19 per name, which puts my 721 at roughly 13,000 and inside the range I estimated. Your 280 tokens per full definition is well below the average in Anthropic's example, so my upper estimate is probably too high for a typical setup. And the point about agents and skills outweighing MCP is fair: the bill has more lines than the one I counted.
265 tools from a single server is quite a lot.
Have you tried disabling just that server to measure how much context space you actually get back?
Not yet. My client defers the full definitions, so that server costs me its 265 tool names on every turn. At about 19 tokens per name, the figure from Jackson's measurement above, that is roughly 5,000 tokens. That is an estimate, not a measurement. I will switch the server off, compare /context before and after, and put the number in the follow-up.
pinning the tools in the server url was the biggest single cut for me, the default sent about a dozen tools and i only needed two or three
Thanks, that is a cleaner cut than hiding tools in the client: the tools are never announced at all. I have not checked which of my 19 servers accept a filter like that. I will, starting with the largest one.