The Context Cost of Tool Calls — How to Not Blow Up in the MCP Era

Five tools makes an LLM app. Fifty tools makes an agent platform. Five hundred tools is what Cursor and Claude Code carry as general-purpose IDEs. Every tool eats context — 100-300 tokens per schema, so 500 tools start you at 100K+. Once Anthropic's November 2024 MCP protocol became the standard, this turned into a production engineering problem.

How Many Tokens Does One Tool Schema Cost

# tested: 2026-04-26 · anthropic@0.40.0
{
    "name": "get_weather",
    "description": "Get the current weather for a given location. Returns temperature, conditions, humidity. Use this when the user asks about weather, climate, or atmospheric conditions for a specific city or geographic location.",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "The city and state/country, e.g. 'San Francisco, CA' or 'Tokyo, Japan'"
            },
            "unit": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperature unit"
            }
        },
        "required": ["location"]
    }
}

Anthropic's token counter: ≈ 180 tokens. Simple tools land at 100-150. Complex ones (multiple enums, nested schemas, long descriptions) hit 300-500. Cursor ships ~50 built-in tools. Claude Code with MCP carries 500+.

At 500 tools you still burn half your context after caching.

MCP — The Tool Standard After Nov 2024

MCP (Model Context Protocol) is the open protocol Anthropic released in November 2024 (modelcontextprotocol.io). It defines how an LLM client discovers and calls external tools.

• Before MCP, every client (Cursor / Claude Code / Cline) had its own tool plug-in path
• After MCP, write a single server and every client can use it — write one for GitHub, both Claude Code and Cursor get it for free

In 2025 the MCP spec moved to streamable HTTP: tool lists can be hosted remotely and pulled in real time.

MCP only standardizes how to plug a tool in, not when to load its schema. That part is still the client's engineering call.

Three Tool-Loading Strategies

1. Eager Loading — Stuff Everything In

# tested: 2026-04-26 · anthropic@0.40.0
client.messages.create(
    model="claude-sonnet-4-6",
    tools=ALL_500_TOOLS,  # 100K token 全塞
    messages=[...]
)

Pro: model sees every capability up front. Con: at 500 tools you still occupy 50% of context after a cache hit. Fits: tools under 30, used frequently.

2. Lazy Loading — Load on Demand

Claude Code's default. Expose a meta tool ToolSearch. Client mounts ~50 core tools at startup. On a complex task, the model first calls ToolSearch("send slack") to fetch the matching schema, then makes the real call on the next turn.

# Claude Code 实际行为
启动: 挂 50 个 core tool（Bash / Read / Write / Edit / Grep / ...）
当用户说: "发个 slack 给团队"
  Step 1: 模型调 ToolSearch("send slack message")
          → 返回 mcp__slack__send_message 的完整 schema
  Step 2: 模型用拿到的 schema 调用 mcp__slack__send_message

Pro: context never blows up. Con: each new tool costs an extra LLM round-trip (~500ms first use); repeat use is free. Fits: tools over 50, per-task usage under 5 (most general-purpose agents).

3. Code Execution — Anthropic's 2025 Approach

In 2025 Anthropic published Code execution with MCP: the model never receives tool schemas, just a sandboxed Python environment + MCP client library. It writes Python to call tools, interpreter runs it, results come back.

# 模型写出来的代码:
import mcp
slack = mcp.connect("slack")
result = slack.send_message(channel="#team", text="hello")
print(result)

Anthropic's measurement: token usage drops 98.7% on tool-heavy workloads.

Cost: sandboxed interpreter required (not every client can run one); model has to write decent Python (smaller models drift); debug reads code traces, not tool-call traces.

Fits: tools over 200, strong model (Sonnet 4+), sandbox available.

JR Real Case: Claude Code with 17 MCP Servers Doesn't Blow Up

JR's Claude Code config (.claude/settings.json) has 17 MCP servers — Canva, Gmail, Notion, Google Drive/Calendar, jr-data, Chrome DevTools, Playwright, Context7, AWS Deploy/Pricing, Filesystem, and more. Each exposes 5-30 tools. 200+ tools × ~200 tokens = 40K of schema if eaten eagerly.

Claude Code default:

{
  "permissions": {
    "deferred": true   // 大部分 MCP tool 默认 deferred
  }
}

deferred = don't mount schema at startup, fetch via ToolSearch on demand. Result: startup schema ≈ 5K (50 core tools); one extra round-trip per first-time tool use; repeat use within a session is free.

Lazy loading in production — the move that lets a real agent run with 200+ tools attached.

Eager vs Lazy vs Code Execution — Trade-off

JR's internal rule: new LLM apps start eager (under 10 tools). Cross 30, switch to lazy. Code execution is the endgame for 200+ tools, not a starting point.

Takeaway

Each tool schema is 100-300 tokens. 500 tools eager-loaded eats half your 200K context. Lazy loading (ToolSearch + deferred) pushes the ceiling from 30 to 500. Code execution pushes it to 5000. Engineering complexity scales linearly too — don't pre-optimize.

---

References

1. Anthropic. (2024-11-25). Introducing the Model Context Protocol — MCP launch announcement.
2. MCP team. Specification 2025-11-25 — 2025 update for streamable HTTP transport.
3. Anthropic. Code execution with MCP — code interpreter approach measured at 98.7% token reduction.
4. Anthropic. Tool use documentation — tool schema format and token counting.
5. modelcontextprotocol. GitHub specification repo — full MCP spec source.
6. Wikipedia. Model Context Protocol — MCP timeline and ecosystem context.

Production case: JR Academy Claude Code config (.claude/settings.json) — 17 MCP servers / 200+ tools / lazy loading by default via ToolSearch.