Same 17 servers, same 468 tools, four clients. We logged the first request each one actually put on the wire.
Everyone agrees that piling MCP servers onto an AI coding client has a cost. What nobody seemed to have done is point a log at the request itself and measure it: with these exact servers attached, what does my client actually send to the model before I type a word? So we did. Same machine, same config, one captured tools/list from 17 real servers, four clients, first request only.
The answer varies by 4.5x -- and the client whose feature sounds like it should be the cheapest is not.
We probed every configured server over stdio for its real tool list -- names, descriptions, input schemas -- giving a corpus of 468 tools / 448,509 bytes of tool JSON. Each server was then replaced by a lightweight replay process serving exactly that captured list, so the clients ran their genuine tool-exposure code without the servers (or their credentials) starting. Model traffic went to local fake endpoints on 127.0.0.1 speaking each protocol, and every request body was logged: tool count, tool bytes, total body bytes.
Caveats, stated up front: four of 21 servers were excluded (three need a running Docker daemon, one needs a kubeconfig), so every number is a floor. This measures the payload of the session-start request on one machine -- not latency, not token cost, not accuracy. Byte counts are bytes; rough token conversions use ~4 bytes/token and are only order-of-magnitude.
| Client (session start) | Tool objects sent | Tool bytes | Total body |
|---|---|---|---|
| Claude Code, default (tool search on) | 14 builtins, 0 MCP schemas | 50,424 | 136,304 |
Claude Code, ENABLE_TOOL_SEARCH=false | 495 (14 + 468 MCP + 13 plugin) | 525,622 | 595,513 |
| Codex CLI | 29 (12 builtins + 17 mcp__* namespaces) | 436,398 | 460,286 |
| Gemini CLI | 484 function declarations | 584,112 | 628,725 |
| Claude Code + Yaw MCP gateway | 14 builtins, 0 schemas | 50,424 | 112,652 |
Versions: Claude Code 2.1.325, Codex 0.169.0, Gemini 0.68.0, Yaw MCP 1.1.13 -- all latest-stable at time of measurement.
Claude Code's docs say "Tool search is enabled by default: MCP tools are deferred and discovered on demand." The capture confirms it literally: with 17 servers attached, zero mcp__* schemas appear in request #1. What rides instead is a ToolSearch tool, a placeholder, and a ~16 KB reminder listing the deferred tools by name.
The cleanest evidence is an A/B: same config, one environment variable. ENABLE_TOOL_SEARCH=false sends 495 tools / 526 KB where the default sent 14 / 50 KB, and the body goes from 136 KB to 596 KB. The MCP surface went from zero schemas to all 468. Deferral is not marketing -- it is a 4.4x swing in the first request, isolated to a single toggle.
This is the finding that surprised us. Codex CLI has shipped tool search for MCP by default since v0.143.0 (July 2026), and its config reference describes an omit_tools_from surface that separates direct from deferred tools. So the top-level tool count is tiny: 29 objects, 17 of them one mcp__<server> namespace entry per server.
But the namespaces are not hollow pointers. Each carries nested tools[] arrays with full descriptions and input schemas -- and the total was 436,398 bytes, essentially the entire 448 KB corpus. The tool count collapsed; the bytes did not. Codex's real payload defense is something else: schema compaction (tool_input_schema_max_bytes, default 5,000), not deferral. A feature named "tool search" can still put every schema on the wire.
Gemini CLI sent 484 function declarations in one array -- 584 KB, everything upfront. We searched its docs and bundle strings for any tool-search or deferred-loading mechanism and found none (an absence claim, so judge it by our method: docs search + bundle grep, not a vendor statement). Its documented context controls are per-server mcp.excluded and per-tool excludeTools -- you choose what loads; the client does not defer it for you.
Attaching the same 17 servers behind Yaw MCP (one MCP entry instead of 17) sent the same 50,424 tool bytes as direct attach -- expected, since Claude Code defers either way. The 24 KB body gap is elsewhere: the deferred-names reminder drops from 16,469 to 903 bytes, and MCP server instructions drop from 9,121 to 1,035, because the model now sees one server (the gateway) instead of 17 with their usage rules. Total: 113 KB vs 136 KB direct, vs 596 KB with deferral off.
The broader lesson: even when tool schemas are deferred, per-server instructions and deferred-name lists are not -- they ride in the conversation regardless. Consolidating servers collapses that fixed cost too.
Jeff Yaw, Yaw Labs.
Published by Yaw Labs.