This isn't just us talking

Those numbers are ours, but "loading every tool schema into context is expensive" is not a claim only we make:

• Anthropic: tool schemas flooding the context window is a real pain — one example drops from 150,000 tokens to 2,000 (a 98.7% saving)
• Firecrawl benchmark: the same task cost 1,365 tokens via CLI vs 44,026 via MCP — 32× (full schema loaded upfront)
• Scalekit benchmark: CLI is 10–32× cheaper and 100% reliable; MCP scores 72%
• MCP-Zero (arXiv:2506.01056): on-demand tool retrieval achieves near-constant cost regardless of tool count
• SEP-1576: an open MCP proposal to cut schema redundancy — the problem is acknowledged upstream

We're not the only ones who measured this. mcptoon is the one you can use today, covering every agent at once.

Up and running in 30 seconds

pip install mcptoon                          # pure stdlib, 128KB, zero dependencies



# Add any MCP server — one command:

mcptoon add fetch --stdio npx -y @modelcontextprotocol/server-fetch



# See every tool available (names-only by default; 255 tools cost 581 tokens):

mcptoon manifest



# Call a tool (JSON output by default; add --toon to save more):

mcptoon call fetch fetch '{"url":"https://example.com"}'

Or let mcptoon auto-discover servers already on your machine:

mcptoon quickstart     # discover + configure + list tools — one command

That's it. No hand-written JSON config. No MCP protocol debugging. No polluted context window.

The problem

Every MCP agent (Claude Code, Cursor, Codex, …) stuffs every tool's full schema into your context window before doing any work:

50 tools  → 14,113 tokens of schema → a 128K context: 11% gone

255 tools → 71,929 tokens of schema → a 128K context: 56% gone

So you unload servers you aren't using and reload them when you are. Back and forth. Adding one new server still means hand-writing a JSON config — one missing comma and everything breaks.

mcptoon fixes this. Your MCP servers stay configured, but their schemas never enter the agent's context by default. The agent just runs mcptoon commands, and only the compact result you asked for enters context — the name index weighs 581 tokens (114 for 50 tools, −99.2%).

Without mcptoon: 255 tools → 71,929 tokens, over half the window

With mcptoon:    255 tools → 581 tokens. 99.2% saved.

Both rows are measured configurations, not one number scaled up and down (tiktoken cl100k_base, assets/benchmark_tiktoken.json). Your mix will differ — compute your own numbers in the browser, 30 seconds, nothing uploaded.

Installing MCP servers — one command each

# Install from npm (most MCP servers live here):

mcptoon install brave-search --npm @modelcontextprotocol/server-brave-search



# Install from pip:

mcptoon install my-tool --pip mcp-my-tool



# HTTP/SSE servers:

mcptoon install remote-api --url https://example.com/mcp



# List installed:

mcptoon install --list



# Uninstall:

mcptoon install --remove brave-search

mcptoon connects, discovers tools, generates the handler, registers it. No restart needed.

Any MCP server works:

mcptoon add my-server --stdio npx -y @any/mcp-package

mcptoon manifest    # usable immediately

Prefer a GUI? ToonDeck

Don't want to hand-edit configs? ToonDeck is a local console for mcptoon: every MCP server and tool in one place with a real health check, one skill folder synced to all your agents, agent launching with live logs, and API keys stored in your OS keychain — never in a plaintext file.

pip install toondeck    # ships the web UI inside the wheel — no node, no build

Pre-alpha; free (Apache-2.0). ToonDeck drives the engine — mcptoon stays the single source of truth underneath.

Works with every AI agent

mcptoon is a CLI. If your agent can run a shell command, it can use mcptoon. No plugins, no SDK, no per-agent setup.

Configure once in ~/.mcptoon/config.json; every agent that can run shell commands shares the same servers and tools. GUI agents that can't? mcptoon sync writes native JSON into each one's own location.

export MCPTOON_AGENT_TYPE=claude   # call results auto-select --toon

# export MCPTOON_AGENT_TYPE=openai   # or keep the default JSON

Your AI can even add tools by itself — no human in the loop:

# Agent needs GitHub access mid-task? It just runs:

mcptoon add github --stdio npx -y @modelcontextprotocol/server-github

mcptoon call github search_repos '{"query":"mcp"}'

# Done. No JSON editing. No restart. No lost context.

The numbers

mcptoon's token savings are two separate bills — know which one you're reading before comparing numbers.

Bill 1 · Tool discovery (manifest): 99.2% saved by default

This bill comes due before your agent decides "which tool do I use". Native MCP shoves every tool's full schema into context (50 tools: 14,113 tokens; 255 tools: 71,929 tokens). mcptoon sends only the name index — that's where "114, not 14,113" comes from.

Zero action, on by default: mcptoon manifest with no flags is this tier. Want to give the agent more? --full (names + parameter types) saves 88.5%; --json (full schema) is the baseline.

Both rows are measured configurations, not one number scaled up and down (tiktoken cl100k_base, assets/benchmark_tiktoken.json). Your mix will differ — compute your own numbers in the browser, 30 seconds, nothing uploaded.

Bill 2 · Call results (call): optional, --toon saves ~34%

This bill comes due after a tool returns its result to your agent. mcptoon call outputs JSON by default — yes, the default saves nothing. To shrink results too, add --toon (structured encoding, reversible):

Default:  mcptoon call fetch fetch '{"url":"https://example.com"}'   → JSON (baseline)

Leaner:   mcptoon call fetch fetch '{"url":"https://example.com"}' --toon   → ~34% saved

34% is the measured toon_save value in assets/benchmark_tiktoken.json (34.0–34.2%), not a marketing number.