MCP Doesn't Suck, Your Agent Does

With the ecosystem expanding to 15,000 servers, the Message Communication Protocol (MCP) enables secure access to tools and resources for AI platforms like Claude and ChatGPT.

The protocol provides AI agents secure access to tools and resources, fostering rapid ecosystem growth with 10,000 to 15,000 active servers used by platforms like Claude and ChatGPT.

High-profile figures and projects within the industry have voiced significant frustration with MCP, challenging its fundamental design.

Critics, including prominent figures like Peter Levels and Gary Tan, claim MCP is an incorrect abstraction and argue that deterministic CLIs would have been a superior alternative for every MCP server.

Early agent implementations naively registered all available MCP tools in their context window immediately upon startup.

This practice meant agents would load hundreds of tools, wasting a significant portion of the context before any actual task began, leading to a phenomenon called 'context bloat'.

Jan Čurn points out that continuous tool use and result injection further exacerbate this bloat, reducing accuracy and increasing token costs, asserting that this issue lies with the agent's harness implementation, not the MCP protocol itself.

While splitting tasks into sub-agents can help isolate specific contexts, it does not reduce the overall token cost because tokens are still consumed.

Sensitive data returned by tools remains within the context, making it vulnerable and failing to address the risks of cross-tool data abuse or the challenges of handling large datasets.

This approach merely postpones or relocates the problem rather than providing a fundamental solution.

To solve context bloat caused by over 100 unused tools, Anthropic and Cursor introduced a dynamic discovery method late last year that imports them only when necessary.

This method addresses the issue of loading hundreds of unused tools by dynamically finding and importing specific tools only when they are needed.

By doing so, agents consume fewer tokens, leading to faster execution and lower operational costs.

This approach leverages Large Language Models' (LLMs) inherent strength in analyzing and writing code, eliminating the need to teach models an artificial 'tool calling' construct.

By presenting tools as code, LLMs can naturally reason about and interact with their definitions.

Cloudflare's current Code Mode implementation is platform-specific, making it challenging to adopt broadly.

Most existing MCP clients do not support the advanced features of the protocol, despite its significant evolution.

This disparity means many agents operate with outdated capabilities, failing to leverage the latest improvements in the MCP standard.

Agents naturally engage with Command Line Interface (CLI) tools using progressive discovery, as they do not load entire help files into their context.

CLI tools operate as code within a sandbox, aligning perfectly with LLMs' strengths and training since 1969 on Linux/Unix commands.

Terminal interfaces, refined over 40 years, offer high information density, making them inherently optimized for agents.

This long history of interaction and optimization makes CLIs a more intuitive and efficient interface for agents compared to raw MCP.

Agents demonstrate a deep understanding of shell commands, including how to execute and pipe them, due to extensive training data.

AI labs can generate infinite training data by exploring shell commands, further enhancing this proficiency.

This makes the shell a predictable and familiar environment for LLMs to operate within.

Standard CLIs act as local black boxes, lacking a unified output and transport protocol, which complicates enterprise security and management.

The absence of internal introspection and standardized credential injection mechanisms makes securing and monitoring CLI operations difficult.

For remote access scenarios, MCP retains a distinct advantage due to its standardized protocol features.

This approach enables the delivery of all MCP protocol features through a simple bash tool call, which agents are already proficient in, effectively abstracting MCP's complexity.

The agent only needs to understand how to invoke 'bash', simplifying session management and authorization processes.

mcpc supports MCP tasks, resources, and prompts, abstracting the underlying protocol and ensuring full compatibility with 'Code Mode'.

It includes a '--JSON' flag for pure JSON output, facilitating integration with tools like 'jq', and securely manages credentials by saving them to the local OS keychain after browser-based authentication.

The MCP protocol includes specific instructions that many current clients fail to support.

MCPC addresses these limitations by supporting persistent sessions, which remain active even after a user disconnects, maintaining state for later return.

It also facilitates progressive tool discovery through a grep-like command, allowing agents to filter and find specific servers and tools, and enables configuration sharing without repetitive setup.

The MCP protocol now includes an asynchronous task feature, which many clients do not yet support.

MCPC enables users to start tasks on a server, allowing them to run in the background without blocking local operations.

This feature allows users to detach from ongoing tasks and later check their progress or retrieve results.

MCPC's `--JSON` command allows outputting results in JSON format, facilitating seamless integration into shell scripts.

This enables background execution of MCP servers, conserving context tokens by not loading unnecessary information.

Additionally, MCPC has expanded its support to include tools like X42, allowing for local wallet management through the client.

Apify developed the 'Connector Evals' framework to benchmark the performance of various connectors, focusing on completion time and token cost.

Tests conducted with Claude 3.5 Sonnet showed that MCPC and native CLIs exhibited similar performance metrics.

While raw MCP sometimes completed tasks faster, it often consumed more tokens in certain scenarios, indicating a trade-off.

The conclusion suggests that a hybrid approach combining MCP with a CLI client, such as mcpc, offers the optimal balance of performance and cost efficiency.