mcptoon claims 98% cut in MCP tool discovery tokens
An independent developer posted mcptoon on Show HN: a zero-dependency Python command-line client for the Model Context Protocol (MCP), the standard AI agents use to call external tools. The project's documentation frames the pitch around how much of an agent's context budget MCP itself eats before any reasoning happens.
The documentation walks through an illustrative scenario: an agent connected to 5 MCP servers spends about 10,000 tokens of JSON just listing their available tools, then burns another 500 to 3,000 tokens per response, wrapped in JSON's content-array envelope, across 20 tool calls. Added up, the documentation puts total MCP overhead at 40,000 to 70,000 tokens before any actual thinking happens, which it says consumes 30 to 55% of a 128K context window on syntax rather than work.
mcptoon's fix is to have the client output TOON (Token-Optimized Object Notation) instead of JSON. In the project's own comparison example, the same tool-listing response drops from 287 tokens in JSON to 5 tokens in TOON. The documentation states this yields a 98% reduction for tool discovery and 60% for full schema output, with, it says, zero information lost. The Show HN title itself states the discovery-token cut as 97%, a figure the documentation body does not reconcile with its own 98% claim.
The tool is about 1,700 lines of pure Python, packaged at 50KB with no third-party dependencies, and works over stdio or HTTP with any MCP server and any agent that can run shell commands, including Claude Code, Codex, OpenCode and Cursor. Servers are configured once in a shared config file and reused across agents. mcptoon also includes a router for registering custom, non-MCP tool handlers, a safety layer that blocks operations matching dangerous patterns such as delete, drop, purge, wipe or kill unless the --destructive flag is passed, and a local usage tracker the documentation says is stored only on disk and never transmitted. The project reports 98 tests passing in 0.09 seconds and ships under the Apache 2.0 license. The documentation states plainly that mcptoon is an independent third-party MCP client, not affiliated with Anthropic.
Key facts
- mcptoon is a zero-dependency Python CLI client for MCP servers (stdio and HTTP) that outputs a compact TOON format instead of JSON.
- Project documentation claims a 98% token reduction for tool discovery and 60% for full schema output; the Show HN title states 97% for discovery, an unreconciled discrepancy.
- The documentation's illustrative scenario: 5 MCP servers plus 20 tool calls could cost 40,000 to 70,000 tokens in JSON, or 30 to 55% of a 128K context window.
- The tool blocks destructive operations (delete, drop, purge, wipe, kill) unless run with --destructive, and the documentation states it stores no telemetry or credentials.
- About 1,700 lines of code, a 50KB package, 98 tests passing in 0.09s, released under Apache 2.0, and explicitly not affiliated with Anthropic.
Why it matters
MCP has become the common way AI agents call external tools, but every tool listing and every tool response is normally sent as verbose JSON. The documentation's own estimate, 40,000 to 70,000 tokens of overhead eating up to 55% of a 128K context window, points at a real cost: context spent on wire format rather than on the agent's actual task. mcptoon targets that overhead directly by changing only the serialization format, not the protocol or the tools themselves.
Who it affects
Developers and users of MCP-enabled AI agents and coding assistants, specifically ones named in the documentation as compatible: Claude Code, Codex, OpenCode and Cursor, plus any other agent able to run shell commands. It is aimed at people who already run multiple MCP servers and have noticed context budget disappearing into tool schemas and results.
How to use it
mcptoon installs via pip, requires Python 3.10+, and runs on Windows, macOS and Linux with no third-party dependencies. Setup is mcptoon init to create a config file, then mcptoon add <server> for each MCP server (stdio or HTTP). mcptoon manifest --toon lists available tools in TOON format, and mcptoon call <server> <tool> '{...}' --toon invokes a tool; setting an environment variable to identify the agent type auto-selects TOON output. The project is released under the Apache 2.0 license, so it is free to use and modify.
How solid is it
This is a fresh Show HN submission, about an hour old at 19 points and 7 comments, from what the source identifies only by a GitHub handle rather than a named author. Every token-reduction figure, 98%, 97%, 60%, comes from the project's own documentation; no benchmark methodology, test environment, or independent verification is described anywhere in the source. The 98 tests and 0.09-second run time are the project's own test suite, not third-party validation. The mismatch between the Show HN title's 97% figure and the documentation body's 98% figure for the same discovery-token comparison is left unexplained in the source.
Risks and caveats
No release date or version number appears in the source, and no named individual maintainer is identified beyond the GitHub account referenced in URLs. Because mcptoon sits between an agent and its MCP servers and can execute tool calls, including ones it flags as dangerous when the --destructive flag is passed, it is worth treating an early, single-maintainer project this way: useful if the token savings hold up, but not yet independently checked for either its performance claims or its handling of tool-call safety.
“MCP tool discovery costs 10,000+ tokens. mcptoon costs 350.”
— mcptoon project documentation