HN Debrief

Show HN: Mcptoon – Token-efficient MCP CLI client

  • AI
  • Developer Tools
  • Programming

mcptoon is a CLI client for MCP, the Model Context Protocol used to expose tools to LLM agents. Its pitch is simple: replace verbose JSON tool listings and outputs with a much shorter text format so agents spend fewer tokens on protocol overhead. The problem it is aiming at is real. People building MCP servers said even small integrations take real work if you want payloads that are interpretable and context-efficient, and many existing MCP servers dump huge schemas or bulky JSON that waste context.

If you are fighting MCP context bloat, do not trust character-level “compression” or headline token-savings claims without running the target tokenizer and measuring end-to-end task success. The practical path is thinner tool discovery, lazy schema loading, search over tools, or code-based inspection of large results rather than blindly stripping descriptions and schemas.

Discussion mood

Mostly skeptical and dismissive. People agreed MCP bloat is a real problem, but saw this project as an unvalidated, overhyped implementation that likely misunderstands tokenization and removes information agents actually need.

Key insights

  1. 01

    Tool names alone cause bad calls

    Returning just the tool name throws away the part of the interface that prevents argument hallucination. A proxy built on the same idea worked better when it listed signatures like `search_web(query)` instead of only `search_web`, because models otherwise invent parameter names and burn another round correcting themselves.

    If you compress tool discovery, keep argument names in the first-hop listing. Measure whether your format reduces failed calls, not just prompt size.

      Attribution:
    • ameshkov #1
  2. 02

    Good MCP payloads need domain redesign

    Building a usable MCP server is not the same as wrapping a REST API. One builder said even a four-tool integration took far longer than expected because the payload had to be rewritten for interpretability and context efficiency, and a generic token-saving filter would likely wreck that work.

    Treat MCP as a product surface for the model, not a transport shim. Review each tool response for what the model actually needs to see before adding any global compression layer.

      Attribution:
    • Loic #1
  3. 03

    Clients already defer oversized tool schemas

    At least some agent clients are already handling tool bloat more intelligently than dumping every schema into context. Claude Code was cited as deferring tool definitions when they exceed 10 percent of the context window, which means the better fix may be selective loading rather than lossy rewriting.

    Before building a custom compression layer, check what your client already does with lazy tool loading. You may get most of the win by changing harness behavior instead of inventing a new wire format.

      Attribution:
    • denis-stable #1
  4. 04

    Code-based tool inspection beats lossy summaries

    A better pattern is to let the model search tools, chain calls, and project only the fields it needs from large outputs. CodeMode in OpenCode V2 beta was mentioned as an example where tool search plus field projections cuts context while preserving access to the underlying structure.

    For large tool catalogs or bulky structured outputs, invest in search and projection primitives. That keeps fidelity high while still shrinking what lands in the model context.

      Attribution:
    • ekisu #1
  5. 05

    Cost visibility is useful even without compression

    Even critics saw value in one side effect of the project: making MCP context cost visible before an agent consumes it. Seeing how much schema and output budget each tool burns can help debug badly designed tools and spot where context is disappearing.

    Add token accounting to your tooling pipeline. Teams make better MCP design decisions when the context cost of each tool call is explicit.

      Attribution:
    • Avery29 #1

Against the grain

  1. 01

    A smarter agent might tolerate shorthand

    The stripped-down format could still be workable if the agent is capable enough and the goal is only lighter tool discovery. The idea here is not that the current implementation is proven, but that noisy full schemas may be unnecessary in every turn if the model can request more detail when needed.

    Do not dismiss shorthand listings outright. Test a staged flow where the model first sees compact tool summaries, then pulls full schema only for shortlisted tools.

      Attribution:
    • dthedavid #1
    • arjie #1
  2. 02

    Relying on vendor efficiency is risky

    Even if agents like Claude Code and Codex already optimize tool loading, that does not mean they always will or that their incentives line up with your costs. External clients can still justify their own efficiency layer if token spend or latency matters enough.

    If tool-heavy workflows are core to your product, keep your own measurements and controls instead of assuming model vendors will optimize for your budget.

      Attribution:
    • vichle #1

In plain english

Claude Code
Anthropic’s coding-focused AI agent tool for working in codebases and developer workflows.
CLI
Command-line interface, a program you use from a terminal by typing commands.
CodeMode
A tool-use pattern or feature mentioned in the comments where a model writes or uses code to search tools, chain calls, and project only needed fields.
Codex
A coding-oriented AI product name used here to describe agent-like development workflows and interfaces.
field projection
Selecting only specific fields from a larger structured result instead of returning the whole object.
JSON
JavaScript Object Notation, a common text format for structured data.
MCP
Model Context Protocol, a standard way for tools and data sources to be exposed to large language model agents.
OpenCode V2
A specific tool or product version mentioned in the comments as supporting code-based MCP workflows.
REST API
Representational State Transfer Application Programming Interface, a common web service style where clients call endpoints over HTTP.
schema
A structured description of what inputs or outputs a tool accepts, often including field names, types, and required values.
token
A chunk of text used internally by language models for input and output billing and context limits, which does not map cleanly to characters or words.
tokenizer
The component that splits text into tokens for a specific language model.

Reference links

Related MCP optimization projects

  • mcp-compress-router
    A similar MCP proxy that reduces tool exposure to a small interface and was cited as a more measured version of the same idea.
  • Headroom
    A comparison point for context-saving agent tooling that readers asked about when evaluating mcptoon.

Tokenization and client behavior references

  • tiktoken
    Referenced as the obvious way to verify whether the claimed text substitutions actually reduce tokens under a real tokenizer.
  • Claude Code MCP documentation
    Cited to show that Claude Code already defers loading tool definitions when they become too large.

Source code and implementation details