MCP
MCP isn't Dead. Your Server Design is
In March, Perplexity CTO Denis Yarats announced at Ask 2026 that Perplexity was moving off MCP in favor of APIs and CLIs. Within a week, “MCP is dead” was the loudest take in AI engineering. The critics have real numbers: an Apideck deployment where three MCP servers consumed 143,000 of 200,000 context tokens (72%) before the agent did anything, Scalekit benchmarks showing up to 32× more tokens than CLI for identical operations, and an audit finding half of public MCP servers abandoned. (The 72% figure is Apideck’s measurement, not Perplexity’s; most coverage conflates them.)
I kept seeing one thing missing from both sides of the argument: nobody was measuring which servers cost what, or asking whether the overhead comes from the protocol or from how people build on it.
So I measured. I benchmarked the tool definitions of popular MCP servers, from Notion and GitHub to Slack and Playwright, found a 25× efficiency spread between the best and worst, then redesigned the worst one and cut its token cost by 95% while keeping the workflows agents actually use.
The protocol is fine. A lot of servers are not.
The method
Tool definitions are the fixed tax of MCP: every tool’s name, description, and input schema gets injected into the model’s context on every request, before the agent does anything. That’s the tax behind the 72% figure.
The benchmark is deliberately simple, and you can rerun it yourself:
-
Spawn each server over stdio
-
Send initialize and tools/list, the standard MCP handshake
-
Serialize each tool definition (name + description + inputSchema) as JSON
-
Count tokens (o200k tokenizer; absolute counts will differ somewhat under other tokenizers. The harness is public, rerun it with yours. The rankings are what matter here.)
This measures the floor. Real clients add framing around tool definitions, so actual costs run higher.
The results
Server Tools Tokens % of 200K context
Notion (official) 24 17,161 8.6%
Firecrawl 26 16,565 8.3%
GitHub (archived npm) 26 3,546 1.8%
Playwright 23 3,198 1.6%
Filesystem 14 1,640 0.8%
Everything (reference) 13 1,084 0.5%
Context7 2 977 0.5%
Memory 9 900 0.4%
Sequential Thinking 1 852 0.4%
Slack 8 679 0.3%
Three things jump out.
The spread is 25×. Notion costs 17,161 tokens. Slack costs 679. These are both official servers for mainstream SaaS products with comparable API complexity. If the protocol were the problem, they’d cost roughly the same. They don’t, because token cost is a design decision.
Tool count isn’t the culprit. Context7 has 2 tools and costs more than Slack’s 8. Firecrawl’s single firecrawl_monitor_create tool is 2,012 tokens, bigger than the entire Slack server. You can’t fix a bloated server by removing tools; the weight is inside them.
A realistic setup gets you to the infamous number fast. Notion + GitHub + Playwright + Filesystem + Slack = 26,224 tokens, 13% of a 200K context occupied before the conversation starts. Swap in one or two more Notion-class servers and you’re on your way to Apideck’s 72%.
A labeling note: the GitHub row is the archived npm server, benchmarked because it’s still what npx installs. The current official Go-based server exposes several times more tools; if anything, rerunning against it widens the spread.
“Doesn’t prompt caching fix this?”
Partly, and it’s worth being precise about which part. Caching fixes cost: with a cached prefix you pay full price for tool definitions roughly once per session, not per request. It does not fix occupancy: those 26K tokens still sit in the window every single turn, crowding out conversation history and diluting the model’s attention across a pile of tool specs it mostly won’t use. And the cache only holds while the prefix is stable. Connect or drop a server mid-session and you’re repaying. Perplexity’s complaint was occupancy, not billing. Caching makes bloated servers cheaper; it doesn’t make them good.
Clients are also attacking occupancy from their side with deferred tool loading, which keeps tool names out of context until searched for. That helps, but it treats the symptom. A 22× lighter server wins whether or not loading is lazy, and lean definitions still win after a deferred tool gets loaded.
Autopsy of a 17,000-token server
Where do Notion’s tokens actually live? Not in the descriptions; those are only 3% of the total. 97% is input schemas.
The server is generated from Notion’s OpenAPI spec, and it shows. Tools are named API-patch-page and API-post-search. Descriptions include HTTP error code listings. And every tool embeds Notion’s complete rich-text object model as JSON-schema $defs, the full recursive definition of what a Notion block can be.
Every tool. Including API-get-user, which takes exactly one string parameter and costs 591 tokens.
This is the API-mirroring anti-pattern: pointing a generator at an OpenAPI spec and calling it an MCP server. The result is a protocol translation, not a tool an agent can use efficiently. Given that an audit this year found most public MCP servers are low-effort and abandoned, I’d bet this pattern accounts for a large share of the “MCP is bloated” experience.
The redesign: 24 tools → 7
I redesigned the Notion server’s tool surface using three patterns. It covers the workflows agents actually perform: search, page read/write, database query and schema management, comments, users.
None of these patterns are my invention. They’re the published guidance of teams that build agents for a living: Anthropic’s tool-writing guide says to consolidate API calls into tools that complete whole tasks, and names token efficiency as a core design principle. Block’s MCP playbook says to start from the workflow and work backwards. Industry guidance (Docker, Speakeasy) puts the sweet spot at 5 to 8 tools per server and warns against endpoint-shaped tools. That’s what makes the benchmark damning rather than merely unfortunate: the best practices are public, and official vendor servers ship in violation of all of them. Slack’s server follows the guidance and costs 679 tokens. Notion’s doesn’t, and costs 17,161.
1. Workflow tools, not API mirrors. Agents don’t think in HTTP endpoints; they think in tasks. One write_page tool (create or update, with content, append, properties, and archive options) replaces seven endpoint-shaped tools: post-page, patch-page, patch-block-children, update-page-markdown, update-a-block, delete-a-block, move-page.
2. Markdown in, markdown out. The block tree is Notion’s internal problem, not the agent’s. Accept a markdown string and translate inside the server, which the official server already does for its two markdown tools. The schema collapses from a recursive $defs forest to content: string.
3. Flat schemas, one-line syntax hints. Instead of exhaustively schema-typing every filter permutation, describe the syntax in one sentence: {“property”: “Status”, “operator”: “equals”, “value”: “Done”}. Models are good at this. It’s what they do.
The result:
Tools Tokens Avg per tool
Official Notion MCP 24 17,161 715
Redesigned 7 773 110
95.5% reduction. 22× smaller.
And here’s the detail I didn’t expect: the redesigned server costs 773 tokens, almost exactly what Slack’s official server costs (679). Filesystem, Memory, and Slack land in the same range too. In this sample (five servers, an observation rather than a law), well-designed MCP servers converge around 700 to 1,600 tokens regardless of domain, because the same instincts produce them: model the workflow, hide the wire format, trust the model with prose.
What this means if you ship an MCP server
Take your tools/list output, serialize it, and count the tokens. Five minutes. If you’re over ~150 tokens per tool, you’re probably shipping your API spec instead of a tool. Then:
-
Merge endpoint-shaped tools into task-shaped ones
-
Replace nested object schemas with strings in a format models already know (markdown, one-line filter syntax)
-
Delete $defs your tools don’t strictly need
-
Cut error-code listings from descriptions; the agent learns errors from error responses
The “MCP is dead” debate is really a debate about server quality wearing a protocol costume. The fix isn’t abandoning the standard. It’s treating tool definitions as UI for models, and measuring them like we measure everything else we ship.
Benchmark harness, raw per-server results, and the full redesigned tool definitions: github.com/zhang-liz/mcp-token-benchmark. Rerun it: node benchmark.mjs “label” npx -y package.