We Said MCP Schemas Cost You Before You Type. On Claude Code 2.1.204, They Do Not.
In April we published Tool Sprawl Has a Token Tax. Its description said that at fifty-plus MCP tools, schemas eat five to seven percent of an agent’s context window “before the user types.” A measurement published in September 2026 by Akira Sumi at Okane Land shows that on at least one widely used client, that sentence is wrong about when.
Sumi’s phrasing is direct: “The schema is fetched when a tool is used, not when the session opens.” And on why attaching a server changes so little at startup: “because the client defers tool definitions and only their names ride along until a tool is called.”
The measurement has a version stamp, and the stamp is the whole story. Sumi states it as “Claude Code 2.1.204 on macOS, 2026-08-09.” One client, one version, one operating system, one date. Other MCP clients may still load every schema eagerly at session start. Nothing in this study says otherwise, and nothing in it licenses the general claim that MCP clients defer tool definitions.
The startup test, and what it does and does not prove
Sumi ran the smallest possible experiment. A trivial one-turn session in an empty repository. Sum the prompt tokens. Attach the filesystem server. Run it again. Sum again.
“The totals were the same inside run-to-run variance: roughly 25,300 either way.”
Read that number for exactly what it is. It is a startup prompt-token total for a one-turn session in an empty repo, which is the least interesting session anyone will ever run. It says very little about what your team’s sessions cost. A real repository has files, instructions, project context, and a conversation. The 25,300 figure exists to answer one narrow question, which is whether attaching a server moves the startup number, and the answer on that client and that day was no.
That is the part of our April post that does not survive. We said the schemas were already in the window before the first prompt. On this client, at this version, they are not.
The 30x is a spread between servers, not a multiplier on MCP
The same study reports that “tool-definition weight varies by more than 30x across popular servers.” The TLDR summary of it invites reading that as evidence that MCP is expensive. Sumi rejects that reading in the study itself: neither number supports “MCP costs 30x more” as a general law.
The 30x is a spread. It compares one server’s tool-definition weight to another’s. It says nothing about the cost of using MCP versus going without.
The spread itself is worth the whole study. Sumi’s figures, which are the author’s own estimates at roughly four characters per token and are explicitly not tokenizer-exact:
| Server | Tools | Estimated tokens |
|---|---|---|
| Notion | 24 | ~19,050 |
| Firecrawl | 27 | ~9,870 |
| Supabase | 29 | ~4,990 |
| Playwright | 24 | ~4,630 |
| GitHub | 26 | ~3,960 |
| Filesystem | 14 | ~3,240 |
| Memory | 9 | ~2,690 |
| Context7 | 2 | ~1,215 |
| Puppeteer | 7 | ~610 |
Notion’s raw schema text runs 76,215 characters across 24 tools. Playwright’s runs 18,502 across the same tool count. In Sumi’s words, “Notion’s 24 tools weigh four times Playwright’s 24.”
Tool count is a poor unit of cost. Two servers with 24 tools each differ by 4x. Two servers with 29 and 27 tools differ by roughly half. Whatever budget you have been building around “how many servers are attached” was measuring the wrong thing, and it was measuring the wrong thing even before deferred loading changed where the cost lands.
Deferred loading moves the bill. It does not cancel it.
If schemas arrive when a tool is called, the tokens still arrive. They arrive later, inside the session, mixed into a context window that is already carrying conversation history and file contents. We argued in the context window is a budget, not a bucket that the expensive moment is the one where you have the least room left. Deferred loading puts the schema cost at exactly that moment.
That reframes the governance question. On this client, “how many servers are attached at startup” no longer shows up in the startup number, so it stops being a useful proxy for anything. What remains measurable is which tools actually get called, how heavy those specific tools are, and where in a long session they land.
Under eager loading, a heavy server you never invoke is a fixed, visible cost you pay once. Under deferred loading, that same server is free until an agent decides to call it, late in a long session, when the window is nearly full. The second failure mode is harder to see and harder to attribute.
Our analysis of computer-use economics against MCP made the same shape of argument from a different angle. Per-call costs that look trivial at the boundary compound inside a session. This measurement is the tool-definition version of that.
The archived-server problem is untouched by any of this
Sumi’s other finding has nothing to do with tokens. Six of the most-recommended MCP servers are archived upstream. The GitHub server, while archived, sees about 125,000 downloads a week.
An unmaintained dependency stays unmaintained under deferred loading. It makes it cheaper to leave attached, which is worse. A server that costs nothing at startup has no budget pressure arguing for its removal, and the thing you stop noticing is the thing you stop reviewing.
Do this now
Open a session in a real repository rather than an empty one, and run /context. That is Sumi’s operational rule and it is the correct one, because it reports what your client is actually doing rather than what a blog post says it does. On Claude Code, an eagerly loading configuration would show the schemas sitting in the window at turn zero. If it defers, you will not, and your investigation moves to what happens mid-session.
Then run /mcp and disable every server you are not deliberately using. Check each remaining one against its upstream repository for an archive banner. Both are short, and the second one is the check that no token measurement will ever do for you.
We are leaving the April post published with a link to this one. The tool-surface governance argument in it holds. The specific claim about cost arriving before the first prompt does not hold on Claude Code 2.1.204, and a correction that stays quiet is not a correction.
This analysis synthesizes The MCP tax: what each server costs before your first prompt (Okane Land, Akira Sumi, September 2026).
Victorino Group helps engineering teams measure and govern the tool surface their agents actually use. Let’s talk.
All articles on The Thinking Wire are written with the assistance of Anthropic's Opus LLM. Each piece goes through multi-agent research to verify facts and surface contradictions, followed by human review and approval before publication. If you find any inaccurate information or wish to contact our editorial team, please reach out at editorial@victorinollc.com . About The Thinking Wire →
If this resonates, let's talk
We help companies implement AI without losing control.
Schedule a Conversation