We started nine Model Context Protocol servers on 3 September 2026, asked each one for its tool list over the wire, and counted the tokens in the answer. The nine servers returned 116 tools and 38,900 tokens of definitions — 19.4% of a 200,000-token context window, spent before the model has read a single word from the user.
That is the whole finding, and it is not the one we went looking for. We expected the story to be name collisions: two servers both offering search, the model picking wrong. There were zero exact collisions across all 116 tools. The cost is not confusion. The cost is JSON Schema, and one server pays 45% of the bill.
Every tool a server exposes is text the model pays for on every uncached turn, whether or not it gets called. We measured the real cost by starting nine servers and capturing what they actually send. The median tool costs 215 tokens; the heaviest single tool costs 1,282. A stack that looks like nine reasonable choices adds up to a fifth of a 200k window before anything happens. The expensive part is not the number of servers. It is that JSON Schema is verbose and nobody is looking at it.
For each server we spawned the process, completed the MCP initialize handshake, sent tools/list, and captured the raw JSON array it returned. Then we counted tokens on that array with o200k_base — the encoding used by the current GPT-4o and GPT-5 family — without reformatting, trimming or pretty-printing it. The number is what the server sends, not what we think it should send.
const { encode } = require('gpt-tokenizer/encoding/o200k_base');const tools = JSON.parse(fs.readFileSync(`out/${server}.json`, 'utf8'));
js
const total = encode(JSON.stringify(tools)).length;const descTok = tools.reduce((a,t) => a + encode(t.description || '').length, 0);const schema = tools.reduce((a,t) => a + encode(JSON.stringify(t.inputSchema||{})).length, 0);
Nine servers completed the handshake: the reference filesystem, memory, sequentialthinking and everything servers, plus Playwright, Notion, MongoDB, Context7 and Exa. Three more — Sentry, Stripe and Supabase — did not finish tools/list inside a 45-second budget without live credentials, so they are absent from the totals and from every number below.
Here is the actual output:
Two things jump out. The first is that tool count predicts cost badly: MongoDB exposes three more tools than Notion and costs 55% less, because Notion’s parameter schemas are enormous. The second is Sequential Thinking, which exposes exactly one tool and spends 1,003 tokens doing it — 2.6% of the entire nine-server stack for a single entry point.
The heaviest individual tool in the sample is Notion’s API-update-page-markdown at 1,282 tokens. The median tool across all 116 is 215. Nine median tools cost you 1% of a 200k window.
Because a description is a sentence and a schema is a tree. Notion spends 2.5% of its tokens telling the model what its tools do and 93.6% telling it what shape the arguments take — nested objects, enums, oneOf branches, per-field descriptions, format hints. Across the nine servers the pattern holds almost everywhere: only the reference filesystem server, at 26.6% description, spends a meaningful share of its budget on prose.
That inverts the usual advice. Teams trim tool descriptions to save context; the descriptions were never the problem. Which half of your tool definitions have you actually read recently — the sentences, or the schemas underneath them?
Take the rate Google published on 2 September 2026 for Gemini 3.8 Flash: $0.75 per million input tokens, introductory, through 31 December 2026. A 38,900-token preamble is $0.0292 per uncached turn. A thousand turns is $29.18. A service doing a thousand agent turns a day for a month spends $875.25 on text that never changes.
On 1 January 2027 that rate becomes $1.50 per million. The same unchanged preamble becomes $58.35 per thousand turns, and $1,750.50 for the same month. Prompt caching cuts this sharply — it is exactly the kind of fixed prefix caching exists for — but caching is a thing you have to turn on and keep warm, and the default is paying twice as much for it in four months.
Our hypothesis going in was lexical: with 116 tools from nine independent vendors, some names must clash, and a clash is where an agent picks the wrong tool. Zero exact duplicates. Not one name appeared twice.
What we found instead was semantic overlap that no dedupe check would catch. Twelve tool names across three servers contain “get”. Eight across three contain “list”. Six across six different servers contain “search” — Exa’s web search, MongoDB’s search-knowledge, the filesystem's search_files, Memory's search_nodes, Notion's API-post-search and the reference server's own. Every one of those is a legitimate, well-named tool in its own namespace. A model choosing between six things called "search" is not being failed by naming; it is being asked a question the names cannot answer.
We did not measure selection accuracy, and we are not claiming these overlaps cause wrong calls. We are saying the collision check people reach for would return clean, and the ambiguity would still be there.
The strongest version of the objection: 38,900 tokens buys 116 real capabilities, a 200k window is enormous, prompt caching makes the marginal cost of a stable prefix close to zero, and an engineer who spends an afternoon shaving schemas has optimised the wrong thing. Context is cheap and getting cheaper; capability is what you are actually buying.
Most of that is right, and the caching point is the strongest part of it — a fixed preamble is the ideal cache prefix, and a warm cache turns the dollar figures above into a rounding error. We are not arguing for fewer tools.
The argument is narrower: this cost is invisible and unattributed. Nobody chose to spend 45% of their tool budget on one integration; it arrived when someone added Notion, and no dashboard shows it. Context pressure gets diagnosed at the other end, when a long conversation starts dropping detail, and 38,900 tokens of preamble is 38,900 tokens of history you are not keeping. A cost you cannot see is not cheap, it is just unmeasured — and the same reasoning that makes caching a good answer also assumes someone has looked at the prefix at least once.
Three things, cheapest first:
One more, from the run itself: the first attempt to count anything failed outright. The standard tiktoken library fetches its encoding file over the network on first use, and that fetch was blocked in our environment, so the count runs on the gpt-tokenizer npm package instead, which ships o200k_base inline. Same encoding, same numbers. But a measurement that depends on a network fetch at runtime is a measurement that can silently fail to happen, and we would rather say that than quietly swap the tool.
In our 3 September 2026 measurement, nine servers exposing 116 tools cost 38,900 tokens using the o200k_base encoding, a median of 215 tokens per tool. Individual servers ranged from 486 tokens for Exa’s two tools to 17,500 for Notion’s 24. Tool count is a poor predictor: MongoDB exposed more tools than Notion and cost 55% less.
We did not measure selection accuracy, so we cannot answer the confusion half. We can answer the cost half: every server’s definitions are re-sent on every uncached turn, so nine servers consumed 19.4% of a 200,000-token window before the conversation started. The overlap we found was semantic — six servers each offering something called “search” — rather than duplicate names.
The input schema, not the description. Notion spent 93.6% of its 17,500 tokens on JSON Schema and 2.5% on the descriptions that tell the model what each tool is for. Only the reference filesystem server spent a substantial share on prose, at 26.6%. Trimming descriptions to save context optimises the small half.
Spawn each server, complete the MCP initialize handshake, send tools/list, and count tokens on the raw JSON array it returns. We used the gpt-tokenizer package with the o200k_base encoding, about 40 lines of Node in total. Measure the wire response rather than a documented tool list: versions move, flags change what is exposed, and the running process is the only thing the model actually sees.
One question, answerable from your own config: run the count on your stack — is your biggest single line item the server you expected, or the one you added six months ago and forgot to filter?
Written by Decoding AI. We publish one original measurement a day — we run the test, state the method and the date, and print the number even when it is the one we did not want.
How Much Context Do MCP Servers Actually Cost? We Measured 38,900 Tokens was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.