37 MCP Tools Cost 8,038 Tokens Before You Type
Context feels short in a session that does nothing yet. The tool schemas were charged before the first message.
📜 Table of Contents
Four official MCP servers, installed and idle, cost 8,038 tokens of tool schema before the first user message. That is 4.0 percent of a 200k context window spent on JSON describing capabilities nobody has asked for yet.
The number is measured, not estimated. On 22 November 2026 I spawned each server over stdio, sent an initialize handshake and a tools/list request, and counted the tokens of the returned tool array. Protocol version 2026-07-28. Token counts came from the GPT-4o tokenizer (o200k_base); another tokenizer will land within a few percent, and the ratio between servers does not move at all.
| server | tools | tokens of schema | tokens per tool |
|---|---|---|---|
| filesystem | 14 | 2,879 | 206 |
| memory | 9 | 2,448 | 272 |
| sequential-thinking | 1 | 1,003 | 1,003 |
| everything | 13 | 1,708 | 131 |
| total | 37 | 8,038 | 217 |
Read the last column first. A tool schema averages 217 tokens, and one server charges 1,003 for a single tool. Nothing here is broken code. This is what a typed, documented tool interface costs in tokens, and every server you install adds to a bill that is charged on every single turn.
Why one tool costs as much as nine
The sequential-thinking server exposes exactly one tool, sequentialthinking, and its schema is 1,003 tokens. Of that, 565 tokens are the description alone, before any parameter is described. The description explains when to use the tool, how to chain thoughts, how to revise, how to branch.
That is a design decision, and arguably a good one for accuracy. It is also 0.5 percent of a 200k window for one tool that most sessions never call. The memory server, with nine tools, fills 2,448 tokens and its heaviest single entry, create_entities, is 358 tokens.
Scheme size tracks prose, not capability count. A tool with three parameters and a paragraph of guidance outweighs a tool with twelve parameters and one line each.
The deprecated tool nobody deleted
The filesystem server ships 14 tools. Two of them read a file: read_file, whose title in the live schema is Read File (Deprecated), and read_text_file, the replacement. The deprecated one alone costs 294 tokens, the largest single schema in that server.
Compatibility keeps it there, and for a server used by thousands of installations that is defensible. For your own install it is 294 tokens per turn of pure legacy surface, and models occasionally still pick it. The cheap fix is to delete the tools you have replaced, in your fork or through the filtering your client supports, and re-measure.
Compare that with skills metadata
The 19 reference skills in anthropics/skills total 1,290 tokens of description, an average of 68 each. So the memory server alone, nine tools, costs about 1.9 times what nineteen skills cost while idle.
| surface | count | idle tokens | average |
|---|---|---|---|
| MCP tool schemas (4 servers) | 37 tools | 8,038 | 217 |
| skill metadata (reference repo) | 19 skills | 1,290 | 68 |
This is the whole argument for progressive disclosure in one row. A tool must be fully described up front, because the model has to know its arguments before deciding to call it. A skill only needs a name and a sentence, because the body can wait until the decision is made.
What 4 percent becomes at twenty servers
Eight thousand tokens is survivable. The trouble is that installs do not stop at four:
| servers at this average | idle schema tokens | share of 200k | share of 128k |
|---|---|---|---|
| 4 | 8,038 | 4.0% | 6.3% |
| 10 | 20,095 | 10.0% | 15.7% |
| 20 | 40,190 | 20.1% | 31.4% |
Twenty servers is not a strawman. A working setup with filesystem, git, database, browser, search, tickets, calendar, docs, memory and three internal services gets there quickly, and each one was installed for a good reason on the day it was installed.
At that point a fifth of the window is spent describing what could be done rather than doing it, and the models that handle long contexts best are also the ones where a cheap prompt cache makes the repeat cost bearable, which is a different bill from the one you think you are paying.
Measure your own stack in ten minutes
The measurement is a stdio JSON-RPC conversation, nothing more. Save this as list.js, run node list.js PACKAGE [ARGS], and it prints the tool array as JSON:
const { spawn } = require("child_process");
const pkg = process.argv[2];
const extra = process.argv.slice(3);
const child = spawn("npx", ["-y", pkg, ...extra], { stdio: ["pipe", "pipe", "pipe"] });
let buf = "", tools = null;
const send = (o) => child.stdin.write(JSON.stringify(o) + "\n");
child.stdout.on("data", (d) => {
buf += d.toString();
let i;
while ((i = buf.indexOf("\n")) >= 0) {
const line = buf.slice(0, i).trim();
buf = buf.slice(i + 1);
if (!line) continue;
let m;
try { m = JSON.parse(line); } catch (e) { continue; }
if (m.id === 1) {
send({ jsonrpc: "2.0", method: "notifications/initialized" });
send({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} });
} else if (m.id === 2) {
tools = m.result.tools || [];
process.stdout.write(JSON.stringify(tools));
child.kill("SIGKILL");
process.exit(0);
}
}
});
send({ jsonrpc: "2.0", id: 1, method: "initialize",
params: { protocolVersion: "2026-07-28", capabilities: {},
clientInfo: { name: "schema-measure", version: "0.1" } } });
setTimeout(() => process.exit(1), 90000);
Then count. With a tokenizer in Python or JavaScript, count the characters of the serialized array and convert, or count tokens directly:
node list.js @modelcontextprotocol/server-filesystem /tmp > fs.json
node -e "const t=require('gpt-tokenizer/model/gpt-4o');const fs=require('fs');
console.log(t.encode(JSON.stringify(JSON.parse(fs.readFileSync('fs.json')))).length)"
Two numbers matter: the total, and the largest single schema. The total tells you what is always loaded. The largest one tells you where to cut first, which is almost never the tool you use least.
Five ways to cut the bill, cheapest first
1. Delete replaced tools. The deprecated read_file in the filesystem server is 294 tokens per turn. Removing superseded tools is a config change, not a rewrite.
2. Install per session, not per account. Clients that let you enable a server for one conversation only, rather than globally, turn a permanent 2,000-token charge into a charge on the sessions that need it.
3. Move procedures to a skill. If a server exists mainly to enforce an order, step A then B then C, that is a skill with a script, and the idle cost drops to about 68 tokens of description.
4. Trim descriptions. The sequential-thinking description is 565 tokens. It is the best-written description I measured and also the most expensive. Long descriptions buy selection accuracy, so cut them only where the tool is unambiguous.
5. Re-measure after each change. A number you did not measure twice is a guess. The script above takes a minute per server.
What this does not mean
It does not mean MCP is expensive, or that skills replace it. A tool schema buys something a skill cannot: a typed contract the runtime can validate before executing anything. When the action touches money, files or production, that contract is worth 200 tokens a turn.
The mistake is paying it for things that are not actions. A 300-token schema to return a paragraph of house style is a schema doing a skill job. That is where the 4 percent goes, and it goes quietly, one convenient server at a time.
FAQ
Are these numbers vendor-published? No. They are counted from live tools/list output on 22 November 2026, on Node 22.22.0, against the npm packages named in the table. Anyone can rerun the script above and get the same integers.
Does the protocol version change the count? No. The handshake version affects negotiation, not the shape of the schema the server advertises.
Which tokenizer should I use? Whichever your model uses. Across tokenizers the absolute count moves by a few percent and the ranking of servers does not, so the comparison table is stable even if your number differs from mine.
Is prompt caching not making this free? Caching makes repeated prefixes cheaper per request, and it does not make them free: cache writes are billed, cache reads are billed at a lower rate, and eviction resets the discount. Schema you never needed is cheaper still.
Do resources and prompts cost the same? No. Resources and prompts are listed, not fully described, so a server with ten resources costs far less at rest than a server with ten tools. That asymmetry is the reason the spec separates them.
Related: what has to be inside a SKILL.md, self-hosted agent memory, per-key budget caps in LiteLLM.
Written by our editorial team; tools listed here are tested or verified against public sources. Links point to official sites or GitHub repos for reference only — no paid placements.