About this video

• Video Title: STOP Using MCP Like This, Use MCP 2.0 Instead (Save 98% More Tokens)
• Channel: Nick Puru | AI Automation
• Speakers: Nick Puru
• Duration: 00:18:43

Overview

This video explains the inefficiencies and problems associated with the traditional Model Context Protocol (MCP) when building AI agents. It introduces a new approach, referred to as MCP 2.0 or code execution, which significantly improves token efficiency, reduces costs, enhances reliability, and offers better privacy by allowing AI models to write code to interact with tools rather than directly calling functions. The video contrasts the two methods, highlights real-world applications, and discusses when to use each approach.

Key takeaways

• Traditional MCP Inefficiencies: The standard method of using MCP leads to high token costs, hallucinations, and random workflow failures due to cluttered context windows filled with unused tool definitions.
• Code Execution (MCP 2.0) Advantages: This new approach presents MCP tools as a file system for the AI agent to explore. Agents write code to use specific tools, keeping the context window clean, reducing token usage by up to 98%, and improving reliability.
• Cost and Reliability Benefits: Code execution drastically cuts down token costs and processing time, making complex AI automations economically viable and more dependable.
• Enhanced Privacy: Sensitive data is processed within a sandbox environment, never reaching the AI model, which is crucial for regulated industries.
• Improved Agent Capabilities: Agents can learn and improve over time by saving and reusing useful code snippets, similar to how Claude skills work.
• When to Use Each Approach: Traditional MCP is suitable for simple use cases with few tool calls and low volume. Code execution is recommended for complex workflows, heavy data processing, high-volume operations, and situations requiring enhanced privacy or where traditional MCP hits context limits.

The main problems encountered when using the traditional Model Context Protocol (MCP) are:

• Hallucinations: Agents tend to hallucinate more than they should.
• Spiraling Token Costs: Token costs become uncontrollably high.
• Random Workflow Breakdowns: Workflows randomly break when they hit context limits.
• Inefficient Token Usage: Consumes up to 98% more tokens than necessary.
• Confused Agents: Agents get confused because their context is cluttered with numerous tool definitions they don't use.
• Context Window Overload: Everything dumps into the agent's context window, creating a mess.
• Increased Costs and Slower Response Times: The agent has to process too much "noise," leading to higher costs and slower responses.
• More Mistakes: Agents make more mistakes due to excessive clutter in the context, leading to confusion about which tool to use, hallucinating parameters, or trying to call tools incorrectly.
• Economic Viability Issues: The token costs can make entire automation projects economically questionable.
• Reliability Issues: Context limits can cause failures mid-workflow.

The code execution approach (MCP 2.0) improves token efficiency and reduces costs in several ways:

• Selective Tool Loading: Instead of loading all tool definitions into the context window, the agent only loads the specific tool definition it needs for a task. This drastically reduces the initial noise and token count.
• Sandbox Processing: Results from tool interactions are kept in a sandbox environment outside the agent's main context. The agent can then write code to filter, transform, and process this data within the sandbox.
• Minimal Context Return: Only the final, processed result (e.g., a few hundred tokens) is returned to the agent's context window, rather than the massive raw data (tens of thousands of tokens) that would have been loaded directly in the traditional approach.
• Reduced Data Redundancy: Data doesn't need to flow through the context window multiple times for different operations. Processing and transformation happen in the sandbox before a concise result is passed back.
• Efficient Data Handling: For complex tasks like comparing data across multiple systems (e.g., inventory levels), the agent writes a comparison script that runs in the sandbox. This avoids loading huge datasets into the context, leading to significantly fewer tokens used overall (e.g., 2,000 tokens instead of 150,000).
• Clearer Context: By keeping the context window clean, the agent avoids being overwhelmed and makes fewer mistakes, which indirectly saves costs associated with retries or errors.

Here are the key differences in how AI agents interact with tools in the traditional MCP versus the code execution method:

Traditional MCP:

• Direct Function Calls: The agent directly calls predefined functions (tools) provided by the MCP server.
• Function Definitions in Context: All tool definitions, including their descriptions, parameters, and examples, are loaded into the agent's context window from the start.
• Agent Interprets Function Calls: The agent is responsible for figuring out which function to call and what parameters to pass based on its understanding of the tool definitions in its context.
• Data Directly in Context: When a tool is called, its output (often large amounts of data) is directly loaded back into the agent's context window.

Code Execution Method (MCP 2.0):

• File System Exploration: MCP servers are presented as a file system where each tool is a TypeScript file. The agent explores this structure to find what it needs.
• Agent Writes Code: Instead of calling a function directly, the agent writes code to interact with the specific tool it has identified.
• Limited Tool Definition Loading: Only the definition of the specific tool needed is loaded into the context, not all definitions from all servers.
• Sandbox for Processing: The results of the tool interaction are initially stored in a sandbox environment. The agent then writes further code to process, filter, and transform this data within the sandbox.
• Concise Results Returned: Only the essential processed information, not the raw output, is returned to the agent's context window.
• Leverages Model's Core Strength: This method plays to the AI model's strength in understanding and generating code, which it learned extensively during pre-training.

The code execution approach, while powerful, has some downsides and limitations:

• Reliability Variability: Traditional MCP tool calling is rigid but predictable. Code execution, however, means the agent must consistently write systematically correct code. This opens up possibilities for syntax errors, logic bugs, or issues with edge cases that the agent might not have accounted for. Agents might write code that works most of the time but fails unexpectedly if input data format changes slightly.
• Infrastructure Overhead: Deploying code execution requires more robust infrastructure. It cannot simply be deployed on a basic serverless function. A secure, isolated sandbox environment is necessary, which involves significant DevOps work for setup and maintenance.
• Not Trivial to Set Up: The infrastructure required for secure and isolated sandboxing with resource limits is complex and not a simple undertaking.
• Overkill for Simple Tasks: For very simple chatbots or use cases involving only one or two tool calls with low data volume, the infrastructure and complexity of code execution are unnecessary and overkill.