MCP Servers and Claude Cost

Last updated 19 September 2026. This page explains claude mcp cost as an operational problem: what the Model Context Protocol is, why connected servers feel free in the UI, how tool schemas and results actually bill tokens in Claude Code / Cowork-style clients, and which fixes keep the connectors without the permanent tax. Tool search defaults, alwaysLoad, output caps, and plugin MCP packaging evolve — confirm live behavior in Anthropic’s Claude Code MCP docs on code.claude.com. [VERIFY: 2026-09-19]

Not affiliated with Anthropic. Claude Token Optimization is an independent site and audit service. Claude® and related product names are trademarks of Anthropic PBC. Plan prices, model rates, MCP tooling behavior, and usage metering change; always confirm on Anthropic’s own docs. [VERIFY: 2026-09-19]

Searches for claude mcp cost, MCP token tax, and “why did adding three servers empty my bar” usually want the same answer: a connector is not free context. Server instructions and tool names (or full schemas) sit where the model can see them; every tool result re-enters the conversation; multi-step agent loops call MCP again and again; plugins can bundle MCP you never asked for by name.

This spoke sits under the Cowork hub — MCP is how desk-style and coding agents reach issue trackers, databases, design tools, and APIs. Pair it with Cowork vs Claude Code, subagents, tool-use costs, skills and plugins, Claude Code tokens, workflows, and cut token usage. Soft CTA to a written review at the end — no dollar price on this page.

What MCP is (operator view)

Model Context Protocol (MCP) is an open standard for connecting AI clients to external tools and data sources. In Claude Code (and related Cowork / client surfaces that speak MCP), you add servers — remote HTTP connectors, local stdio processes, or plugin-bundled packs — so Claude can read and act on systems instead of waiting for you to paste exports. Typical jobs: implement a Jira ticket and open a PR, query Postgres, pull Figma notes from Slack, or react to events a channel server pushes into the session. [VERIFY: 2026-09-19]

From a cost seat, MCP is just another tool stack with a sharper install story. Each enabled server advertises tools (and often prompts and resources). Those definitions and every subsequent tool result compete for the same context window and the same usage pool as chat, Code, and Cowork work. The product value is real; the meter still cares.

Why MCP feels free (and is not)

In Claude Code, claude mcp add or enabling a plugin MCP server feels like wiring a menu item. You run /mcp, see Connected, and ask Claude to use Notion or GitHub. Nothing looks like a line item. The session still pays four recurring bills:

1. Tool discovery / schemas in context. With tool search (default on first-party hosts), Claude Code defers full tool definitions and loads mostly names and server instructions at start — lower always-on tax. With ENABLE_TOOL_SEARCH=false, non-first-party hosts, or some cloud deployments, tools may load upfront and consume context like any other agent schema pack. [VERIFY: 2026-09-19]
2. Tool results re-enter context. Query rows, issue bodies, schema dumps, and API payloads land back in the window and stay for later turns — the same physics as tool-use costs.
3. Multi-step tool loops. Agents call, observe, call again. Each round multiplies input. Chatty MCP loops are how one “quick lookup” becomes an afternoon of capacity.
4. Plugin-bundled MCP and alwaysLoad. Marketplace / project plugins can start MCP servers when enabled; alwaysLoad: true (or per-tool anthropic/alwaysLoad) forces tools into context at session start even when tool search is on. [VERIFY: 2026-09-19]

That is why claude mcp cost shows up in audits next to skills listings and fat CLAUDE.md files. Teams attribute spend to “the model” and miss that eight unused servers, one alwaysLoad database pack, and a loop that dumps full schemas are the real ballast. Finance sees capacity drain; developers see a green Connected badge; nobody owns the MCP budget until someone runs /mcp and /context.

Treat the table as planning orientation from the MCP docs dated for this page — not as a substitute for /context on your session. Product versions and host platforms change the exact knobs. [VERIFY: 2026-09-19]

Cost levers from Anthropic’s Claude Code MCP docs

Checked 2026-09-19 against code.claude.com/docs/en/mcp. These are the controls that actually move the meter.

Tool search (default): defer full definitions

Tool search keeps MCP context usage low by deferring tool definitions until Claude needs them. Only tool names and server instructions load at session start, so adding more servers has minimal impact on the window compared with loading every schema upfront. Claude Code does not impose a fixed per-server tool cap; the practical limit is your context budget. [VERIFY: 2026-09-19]

Tool search is enabled by default on first-party Anthropic hosts for supported models. It falls back toward upfront loading when ANTHROPIC_BASE_URL points at a non-first-party host (many proxies do not forward tool_reference blocks), when ENABLE_TOOL_SEARCH=false, on some Microsoft Foundry deployments that reject it server-side, and on older Google Cloud Agent Platform model generations. Set ENABLE_TOOL_SEARCH explicitly (true, false, auto, or auto:N threshold mode) when you need to override the fallback. [VERIFY: 2026-09-19]

alwaysLoad: force tools into every turn

Set alwaysLoad: true on a server in .mcp.json (or the per-tool anthropic/alwaysLoad meta) when those tools must be visible without a search step. Every tool from that server then loads at session start regardless of ENABLE_TOOL_SEARCH. Use it only for a small must-have set — each upfront tool consumes context that would otherwise stay available for the conversation. [VERIFY: 2026-09-19]

MCP output: warn ~10k, default max ~25k

Claude Code displays a warning when any MCP tool output exceeds about 10,000 tokens and limits output to about 25,000 tokens by default via MAX_MCP_OUTPUT_TOKENS. Raise carefully (for example MAX_MCP_OUTPUT_TOKENS=50000) only when a tool truly needs larger results; oversized payloads still re-enter context and tax later turns. Tools that declare anthropic/maxResultSizeChars can raise their own persist threshold for text; image-bearing results still follow the token ceiling. Over the limit, Claude Code may save the result to a file and leave a path reference in the conversation. [VERIFY: 2026-09-19]

Fat results, resources, multi-server stacks, plugin packs

Resources referenced with @server:… mentions are fetched and attached like files. Multi-server stacks multiply names, instructions, and temptation to call “just one more” tool. Plugin-provided MCP servers start when the plugin is enabled and appear in /mcp with plugin indicators — same cost physics as manually configured servers, often installed as a side effect of wanting one slash command. See skills and plugins cost. [VERIFY: 2026-09-19]

Waste patterns that inflate MCP spend

These patterns show up repeatedly when teams paste Claude Code / Cowork sessions for review. None require exotic models — they are defaults that feel helpful.

• Too many servers enabled. Every Connected entry adds names, instructions, and call surface. Disable unused servers in /mcp (or remove them) rather than leaving them “for someday.”
• Broad tools never used. A database server with twenty query shapes when you needed one read-only lookup — or alwaysLoad on a fat pack you touch once a week.
• Dumping full DB / schema / issue dumps. “Show me the whole schema” or unpaginated list endpoints return tens of thousands of tokens that then sit in history.
• Chatty agent loops calling MCP. Unbounded research or repair loops that re-query the same connector each step. Pair with caps from tool-use costs and subagents.
• Plugins that add MCP you do not need. Installing for one skill also starts servers whose tools ride along every session after reload.
• Turning tool search off without a reason. ENABLE_TOOL_SEARCH=false (or a proxy that forces upfront load) puts full definitions in context for the life of the session.
• Raising MAX_MCP_OUTPUT_TOKENS as a habit. Silencing the 10k warning by raising the ceiling without paginating or summarizing just moves the cliff into later turns.

Fixing connector hygiene is usually worth more than shaving a few words off a system prompt. Start with servers you have not called this month and plugin MCP you did not know was running. [VERIFY: 2026-09-19]

Fixes that actually reduce Claude MCP cost

The goal is not “never use MCP.” The goal is a small, sharp connector set: deferred schemas where possible, thin results, loops with stop conditions.

1. Disable unused servers in /mcp. Toggle off without losing config, or claude mcp remove what you will not need. Prefer disable over “leave it connected just in case.”
2. Prefer tool search. Keep the default deferral on first-party hosts; only set ENABLE_TOOL_SEARCH=false when you understand the upfront schema tax. [VERIFY: 2026-09-19]
3. Avoid alwaysLoad except small must-have sets. If Claude needs a tool every turn, keep that server tiny; put everything else behind search.
4. Paginate and summarize tool outputs. Ask for slices, top-N, or summaries. Prefer thin connectors that return what the task needs.
5. Raise MAX_MCP_OUTPUT_TOKENS only when needed. Treat the ~25k default as a safety rail; raise for known large-but-necessary tools, then measure whether history still balloons. [VERIFY: 2026-09-19]
6. Prefer thin connectors over kitchen-sink packs. One focused server beats a plugin that starts five.
7. Measure with /context (and /mcp status). Attribute MCP rows the way you attribute Skills and Tools. After changes, confirm the window actually shrank.
8. Bound agent loops that call MCP. Done-when, step caps, and kill switches — same Cowork checklist as Cowork costs.

How this shows up in an audit

A typical finding: the team insists prompts are lean; /context shows a large MCP / Tools footprint; half the Connected servers have never been called this sprint; one alwaysLoad database server dumps full schemas into every exploratory turn; a marketplace plugin added three MCP servers for a single skill nobody uses. Another finding: ENABLE_TOOL_SEARCH=false on a proxy host with no compensating trim. A third: agent loops that re-hit the same issue tracker ten times because the parent brief had no Done-when.

Fixes are connector and loop decisions, not “buy a bigger plan.” Attribute MCP schemas, MCP results, and MCP-driven agent rounds as their own buckets alongside skills and documents. Soft CTA: start a Claude token audit when MCP spend is opaque. This page never quotes an audit dollar price; pricing lives only on the audit page itself.

FAQ

Is MCP free once the server is connected?

No. Connection is configuration. Tokens still pay for what enters context — names/instructions or full schemas, every tool result, and every loop round. MCP is not a separate unlimited meter. [VERIFY: 2026-09-19]

Does tool search mean MCP never costs listing tokens?

No. Names and server instructions still load; full definitions are deferred until search/use. AlwaysLoad and tool-search-off paths put more upfront. [VERIFY: 2026-09-19]

What does the 10k / 25k MCP output guidance mean?

Claude Code warns above ~10,000 tokens of MCP tool output and defaults to a ~25,000 token max (MAX_MCP_OUTPUT_TOKENS). Raise only when needed; fat results still tax later turns. [VERIFY: 2026-09-19]

Do plugins add MCP cost automatically?

When a plugin bundles MCP servers, enabling the plugin starts those servers. You can often toggle a plugin server off in /mcp without uninstalling the whole plugin — confirm in your version. Prefer thin packs. [VERIFY: 2026-09-19]

Where should I look first in a live session?

/mcp for Connected vs disabled servers and tool counts; /context for how much of the window MCP/tools occupy; then disable unused servers and re-measure. Pair with tool-use and skills hygiene.

Is this only a Claude Code problem?

MCP appears wherever the client speaks the protocol — Claude Code is the best-documented cost surface today. Cowork-family and other agents that call the same connectors follow the same physics: schemas + results + loops. See Cowork costs and Cowork vs Claude Code.

Next steps

1. Open /mcp; disable or remove servers you have not used recently.
2. Confirm tool search is on for your host; drop alwaysLoad except tiny must-have sets.
3. Paginate/summarize fat tool outputs; raise MAX_MCP_OUTPUT_TOKENS only with a measured need.
4. Uninstall or disable plugins that added MCP you did not want; prefer thin connectors.
5. Bound agent loops that call MCP (Done-when, step caps) — see Cowork and tool-use costs.
6. Re-check with /context; pair with skills costs, Claude Code tokens, and cut token usage.
7. If MCP spend stays opaque, paste for a written audit.

MCP servers are leverage — or silent ballast. Manage claude mcp cost with the same Measure → Attribute → Reduce → Monitor loop as every other optimize spoke: keep the connectors that earn their place, defer schemas when you can, keep results thin, and stop loops that re-query forever. For the wider agentic picture, return to the Cowork hub.