The Study · Economics
There is a specific number that decides whether an MCP server is worth installing, and no “best MCP servers” list prints it: how much context its tool definitions weigh. The lists rank usefulness, downloads, and stars. They stop exactly where the cost begins. So we opened the four biggest of them, took the servers they most agree on, and measured the one number they leave out.
The finding has two halves, and the second is the interesting one. The tax that older writeups warned about, where every server’s full schema burns context at session start, has largely been mitigated in current Claude Code, which defers tool definitions by default. But the weight did not vanish. It moved from startup to first use, and its size per server is exactly what we measured. This is the sibling to our AI coding cost study: that one prices the model, this one prices the plumbing.
The short version #
Tool-definition weight varies by more than 30x across popular servers. In our measurement, a one-tool fetch server’s schema is around 600 estimated tokens; Notion’s 24 tools are around 19,000. Same “install one server,” two orders of magnitude apart.Current Claude Code defers the cost, so at session start it is near zero. We measured total prompt tokens with and without a server attached and the difference sat inside run-to-run noise. The schema is fetched when a tool is used, not when the session opens.So the tax is real but relocated. In a client or mode without deferral, or the moment you actually use several servers in a turn, you pay the full schema sizes in the table below. Read them as the bill that arrives on use.Every number here carries its method and date, and the raw table ships with the piece. The measurement is Claude Code 2.1.204 on macOS, 2026-08-09; token figures are estimated at roughly four characters per token and labelled as estimates, not tokenizer-exact counts.
How we picked the ten #
The candidate list is built transparently, not editorially. We took the four largest public catalogues, the official modelcontextprotocol/servers
repo plus the three biggest community “awesome” lists, and kept the servers they most agree on, cross-checked against what Google autocomplete completes for “best mcp servers for.” Two disclosures the lists themselves invite: punkpeye’s list (around 92,130 stars) describes itself in its own README as the companion to the Glama directory, and appcypher’s list is itself an archived repo. We note both rather than presenting all four as equally live.
“Free” here means no paid key is required to run the server. Two exceptions worth stating: the official GitHub server needs a GitHub account and a personal access token, and Brave’s search server needs an API key whose signup asks for a card it does not charge. Everything else ran with no account at all.
The table: what each server’s tools weigh #
Measured by connecting a client and calling tools/list
, then sizing the returned schema. Tokens are estimated at roughly four characters each and labelled accordingly.
| Server | Tools | Schema (chars) | Est. tokens |
|---|---|---|---|
| Notion | 24 | 76,215 | ~19,050 |
| Firecrawl | 27 | 39,491 | ~9,870 |
| Supabase | 29 | 19,947 | ~4,990 |
| Playwright | 24 | 18,502 | ~4,630 |
| GitHub | 26 | 15,854 | ~3,960 |
| Filesystem | 14 | 12,973 | ~3,240 |
| Memory | 9 | 10,750 | ~2,690 |
| Everything (demo) | 13 | 7,653 | ~1,910 |
| Context7 | 2 | 4,860 | ~1,215 |
| Sequential-thinking | 1 | 4,587 | ~1,150 |
| Puppeteer | 7 | 2,448 | ~610 |
The spread is the story. It does not track tool count cleanly, because verbose descriptions and large input schemas cost more than short ones; Notion’s 24 tools weigh four times Playwright’s 24. The number that matters is not how many tools a server adds, it is how much text those tools’ definitions carry.
When the bill actually arrives #
Here is the -mode finding, measured rather than assumed. We ran a trivial one-turn session in an empty repo and summed the prompt tokens, then did the same with the filesystem server attached. The totals were the same inside run-to-run variance: roughly 25,300 either way, a difference smaller than the noise between two baseline runs.
In Claude Code 2.1.204, attaching a server does not measurably grow the session at startup, because the client defers tool definitions and only their names ride along until a tool is called.
That is the good news and the trap in one. The cost is deferred, not deleted. The moment the agent actually uses a server, the schema loads, and a turn that touches several servers pays their combined weight from the table. In an older client, or one that loads schemas eagerly, you pay it at startup regardless. So the fair way to read the table is as the cost-on-use per server, and the fair way to read the deferral is as a reason to install fewer servers than you think you can afford, because “it is free until I use it” quietly becomes “I used four of them in one turn.”
What is already measured, read carefully #
Two published numbers get quoted a lot in this discussion, and both need their scope kept on.
Anthropic’s engineering post from November 2025 uses an example of tool-definition overhead dropping from about 150,000 tokens to about 2,000 through progressive disclosure. That is an illustration of the mechanism, not a measurement of any specific setup, and it should be cited as the illustration it is. Separately, Scalekit’s 75-run benchmark found that for the GitHub remote server on one task, the MCP agent used about 44,026 tokens against a CLI agent’s 1,365 for the same result. That is a striking gap and it is one server, one task; the seven failures in that run were TCP connect timeouts the authors explicitly call “not an MCP protocol error.” Neither number supports “MCP costs 30x more” as a general law. They support the narrower, sturdier claim this piece is built on: tool definitions have a real, measurable weight, and it is worth knowing per server.
The archive finding #
One thing the download counts surfaced is worth a paragraph. Six of the most-recommended servers, including the widely installed GitHub one at about 125,000 downloads a week, are archived upstream. They still work, and people still install them by the hundred thousand, but archived means no maintenance, which for a component that holds your tokens and often your credentials is its own risk, tying straight back to the install-trust failures in our agent-security ledger. Popularity on a list is a lagging signal; it can point at software the maintainer has already walked away from.
Keep or cut, by standard #
The verdict follows the same standard Anthropic’s own guidance points at: run /context
, and disable servers you are not actively using via /mcp
. Concretely, from the numbers here:
Keep the small, always-useful ones. Filesystem and a fetch or search tool earn their weight; you use them most turns.Load the heavy ones only for the session that needs them. Notion, Firecrawl, Supabase, and Playwright are the expensive rows. Attach them for the task, then turn them off. On a deferring client that costs little at rest, but it removes the first-use spike from every unrelated turn and shrinks the surface fromthe security piece.Cut what you installed once and forgot. The cheapest tokens are the ones a server you never call is no longer allowed to charge you.
The whole point is that this is now a decision you can make on a number instead of a vibe. The table is dated and the method is a paragraph; re-run it against your own client and version, because deferral behaviour is exactly the kind of thing that changes between releases, and the value of a receipt is that you can check whether it still holds. For the workflow that keeps these servers in their lane, our Claude Code guide is the companion, and the field guide maps which agents defer this cost and which do not.
One email, when there's something worth sending
Get the research in your inbox. #
No fixed schedule, no filler. You get an email when we've tested something, run the numbers, or found a tool worth your time.
Free. Double opt-in, unsubscribe in one click.
What is riding along in your context? Compare notes in the forum ↗
Sources & how we researched this #
- Okane Land measurement (run 2026-08-09, Claude Code 2.1.204 on macOS): for each server we connected an MCP stdio client and called tools/list, then measured the JSON size of the returned tool array (characters, and an estimate at roughly four characters per token). We also measured total prompt tokens at session start with and without a server attached. Method and raw table published with this piece.
- MCP specification, revision 2026-07-28 (latest; previous 2025-11-25): the current revision makes the protocol stateless and removes the initialize handshake. modelcontextprotocol.io/specification/2026-07-28
- Claude Code costs documentation (read 2026-08-09): states that MCP tool definitions are deferred by default, so only tool names enter context until a tool is used, and documents /context and disabling unused servers via /mcp. code.claude.com/docs/en/costs
- Candidate list built by intersecting four public lists read 2026-08-09: the official modelcontextprotocol/servers repo (7 current reference servers, 13 archived), punkpeye/awesome-mcp-servers (about 92,130 stars, described in its own README as the companion to the Glama directory), wong2/awesome-mcp-servers, and appcypher/awesome-mcp-servers (itself an archived repo, disclosed here), plus live Google autocomplete intents.
- npm/PyPI weekly download counts (read 2026-08-09) as a popularity signal with a CI-and-mirror caveat: @playwright/mcp about 6.66M, @upstash/context7-mcp about 1.0M, @modelcontextprotocol/server-filesystem about 485k, mcp-server-fetch about 445k, and @modelcontextprotocol/server-github about 125k despite being archived upstream.
- Scalekit benchmark (75 runs, Claude Sonnet 4, GitHub remote MCP vs a CLI, 2026): for that one server and task, the MCP agent used about 44,026 tokens against the CLI agent's 1,365 for the same result; the 7 MCP failures were TCP-level connect timeouts, which the authors label "not an MCP protocol error." A single-server comparison, not a general multiplier.
- Anthropic engineering, "the new rules of context engineering" (2025-11-04): uses an illustrative example of tool-definition overhead falling from about 150,000 tokens to about 2,000 via progressive disclosure. An illustration, cited as such.