kevinhall left a comment on my piece about the 200-tool menu, and it pointed at the one split my run never made. He had measured real hosted tools, and the heaviest definition he found was almost all an output schema the server had made up from past runs, nothing the author wrote. So the cost was not always in the descriptions. My run never split the output schema out from the description and the input schema, so I could not say whether he was right, or how far it went.
I split five real server definitions open this week: the filesystem, memory, sequential-thinking, everything, and github servers, 68 tools in total, counted the same way as the earlier runs so the totals reproduce exactly. The answer is messier than either of us expected. kevinhall is right that the cost is not in the descriptions. He is wrong about where it is. And the split turned up something neither of us was looking for, hiding in the heaviest server of all.
My claim before the numbers: the output schema would be the biggest chunk on the heavy servers, and trimming descriptions would be trimming the wrong thing. The first half was wrong. The second half was right for the wrong reason.
Problem 1: the description is the biggest chunk on none of the five servers
Across all 68 tools, 23,298 tokens of definition: descriptions are 2,619 tokens, 11.2 percent. Input schemas are 6,876, 29.5 percent. Output schemas are 2,205, 9.5 percent. The description is not the largest part anywhere.
On the filesystem server, the input schema is 39.4 percent, the description 26.1, the output schema 18.1. On sequential-thinking, the input schema is 43.8 percent against a 33.8 percent description. On github, the input schema is 84.4 percent and the description is 8.0. And github has no output schema at all, on any of its 26 tools. Stripping every description on all five servers saves 2,619 tokens. The output schema alone is 2,205, nearly as big as all the descriptions put together, and the input schema is nearly three times the descriptions.
So the advice to trim descriptions is trimming the third-biggest bucket at best. It is not useless. 11 percent is 11 percent, and over forty turns it compounds. But it is not where the cost lives, and anyone selling description-trimming as the fix for definition bloat is selling a haircut for a weight problem.
Problem 2: the output schema wins on exactly one server, by 27 tokens
The memory server is the one place kevinhall's shape shows up. Its output schema is 37.3 percent, edging out its input schema at 36.4 percent, and the description is a distant third at 14.2. Stripping every description there saves 453 tokens while the output schema alone costs 1,186, two and a half times more. The three read tools, read_graph, search_nodes and open_nodes, each carry the fattest output schema in the whole set at 238 tokens: the full entity and relation shape, with per-field descriptions.
But here is the detail that changes the story. I checked the shipped server source instead of guessing, and every output schema in this set is author-written. The memory server's schemas are Zod objects written in the server's own code, reusing the same entity shape as the input schema. The filesystem server's output schema is a generic wrapper the author wrote once: {content: string}, the identical 40-token schema on fifteen of its sixteen tools, because the server returns every result as one text blob. The "everything" server's two output schemas are plain JSON Schema literals written by hand. None of them was generated from past runs. None of them describes anything the tool actually returns in particular. The filesystem one does not even try: it is a wrapper that says "the result is text", forty tokens, fifteen times over.
So kevinhall's "made up from past runs" shape does not appear on these five servers. That does not disprove his measurement. His server was a hosted one he did not name, and I could not measure it. It means the pattern is not universal. Whether an output schema dominates depends on whether the server author bothered to write one, and how rich it is. On github, the author did not bother at all. On memory, the author wrote a rich one. The cost follows the author's habits, not the protocol.
Problem 3: the heaviest server is fat with pictures
The surprise came from the heaviest server in the set. The everything test server totals 11,914 tokens across 16 tools, and 9,520 of those, 79.9 percent, are icons. Every one of its tools carries two base64-encoded SVG icons, light and dark, 595 tokens each. The single heaviest tool in the whole set, get-header-params at 898 tokens, is 595 tokens of icons, 108 of input schema, 91 of output schema, and 58 of description. The earlier run called that tool fat on schema richness. The split shows it is mostly pictures.
Strip the icons and the whole test server falls to 2,394 tokens — cheaper than the filesystem server. Whether a host even sends icons to the model is host-dependent, but they are in the listed definition, so they are in the count. And everything is a test server, so its numbers are real but not representative. It is included because it proves the point the other four servers only suggest: schema and icon richness dominates tool count. A server with 16 tools can cost more than a server with 26, because the cost was never about how many tools there are. It is about what each definition carries.
Problem 4: presence is an author choice, not a protocol fact
Step back and the pattern across all five servers is simple. 28 of 68 tools have an output schema. Github has none. The filesystem server's is a 40-token boilerplate repeated fifteen times. The memory server's is a hand-shaped entity graph. Any claim of the form "output schemas cost X percent" needs the server named alongside it, because the answer is 37 percent on one server, 18 on another, 1.4 on a third, and zero on a fourth. There is no general number. There is only the server in front of you, split open.
That is the rule I am keeping, and it is narrower than the one I went in with. Split the definition before you trim anything, because the biggest chunk is different on every server, and on most of them it is the input schema, and on one of them it is pictures. The description is never the biggest chunk. Trim it if you like. 11 percent is real money over forty turns. But trim it knowing it is the third thing on the list, not the first.
The honest limit, stated plainly: these are local stdio servers, not hosted ones. kevinhall measured a real hosted server and did not name it, so I could not re-measure his server. A hosted server that synthesises output schemas from past runs would show a much larger output-schema share than anything here. This run neither confirms nor refutes that shape. It says what the five real official servers actually carry, and what they carry is input schemas, author-written output schemas, and, on the fattest one, pictures.
Have you ever split one of your own tool definitions open? I would like to hear what the fattest part turned out to be, and whether it was the part you expected.
P.S. Everything I write stays free — that part doesn't change. But if this one was worth something to you, you can buy me a coffee ☕ (one-time or monthly, both work). It covers the API credits and hosting behind these experiments — and honestly, it's also the nudge that gets the next one started on the evenings I'd otherwise skip it. — Salam


Top comments (0)