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.

How we measured

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.

The payload table

Client (session start)Tool objects sentTool bytesTotal body
Claude Code, default (tool search on)14 builtins, 0 MCP schemas50,424136,304
Claude Code, ENABLE_TOOL_SEARCH=false495 (14 + 468 MCP + 13 plugin)525,622595,513
Codex CLI29 (12 builtins + 17 mcp__* namespaces)436,398460,286
Gemini CLI484 function declarations584,112628,725
Claude Code + Yaw MCP gateway14 builtins, 0 schemas50,424112,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: deferral works, and here is the number

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.

Codex: "tool search" that does not shrink the payload

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: no deferral found

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.

The gateway row: where the fixed cost hides

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.

What this does and does not say

Related Articles

Jeff Yaw, Yaw Labs.

Published by Yaw Labs.

From Yaw MCP -- MCP servers, managed locally. Free for personal use.