Convert Any MCP Server to Code Execution (Template)

Too Long; Didn't Watch — Summary

This video demonstrates Anthropic's MCP code execution method for AI agents, showcasing how it drastically reduces token consumption by up to 98% and enhances agent autonomy by allowing them to evolve skills, providing a step-by-step build, a comparison with the direct MCP approach, and a verdict on its production readiness.

Main Takeaways

• Anthropic's MCP code execution method significantly reduces token consumption (up to 98%) and increases AI agent autonomy and flexibility.
• The new approach involves agents executing code directly, saving tool descriptions in code rather than passing them to the agent's context window.
• A sales operations agent was built to demonstrate the method, capable of copying transcripts from Google Drive to Notion.
• Comparison showed the MCP code execution agent consumed 12,000 tokens initially, reduced to 4,000 tokens with learned skills, compared to 32,000 tokens for the direct MCP agent.
• The method is production-ready but requires careful prompting, and is best suited for sophisticated general agents like analytics, research, or operations, not simple agents.

Detailed Summary

Introduction to MCP Code Execution (0:00 - 0:45)

The video introduces Anthropic's MCP code execution method, highlighting its potential to revolutionize AI agent building. This technique is presented as the future, capable of reducing token consumption by 98% and granting agents greater autonomy and flexibility to develop their own skills. The presenter promises a step-by-step build, a comparison with the older direct MCP method, and a template for converting existing MCP servers to this new pattern. Viewers are advised to watch a previous video for theoretical background.

Building the Sales Operations Agent (0:45 - 2:00)

• The agent to be built is a sales operations agent, inspired by Anthropic's blog post, designed to read meeting transcripts and attach them to a CRM (Notion) without directly processing file content.
• The architecture is simple: one agent with a code execution tool connecting to Google Drive MCP and Notion MCP.
• To start, users need to copy a starter template, set visibility to private, and open the repository in a coding environment like Cursor.
• The agent is initialized with two essential built-in tools: an IPython interpreter and a persistent shell tool, enabling it to discover local files and run Python code.
• A direct MCP agent is also created for later comparison.

Adding MCP Servers with Code Execution (2:00 - 4:07)

• A new special command, MCP code execution, is introduced to add MCP servers using the new pattern.
• Users tag this command and specify the MCP servers, ideally by linking to GitHub repositories.
• This command provides Cursor with all necessary information, including links to the blog post and resources, ensuring the server is added using the proposed structure.
• The process involves Cursor creating a server directory with code and then generating code for individual tools.
• Unlike the direct MCP method, tool descriptions are saved directly in code, not passed into the agent's context window, reducing token usage.
• Authentication for servers using OAuth is required, and credentials must be provided upfront to avoid testing issues.
• The example resulted in 15 tools for Notion MCP and 4 for Google Drive.

Writing Agent Instructions and Workflow (4:07 - 5:25)

• The write instructions command is used to define the agent's context, requiring careful answers to questions, especially regarding the process and workflow.
• Prompting is crucial for effective use of this technique; the agent must clearly understand its operational process.
• The general workflow involves checking the Mnt skills folder for existing skills, using them if found, otherwise reading only necessary tools, combining them to complete tasks, and suggesting new skills.
• Simultaneously, MCPs are added to the direct MCP agent for comparison using the add MCP command.

Testing the MCP Code Execution Agent (5:25 - 7:58)

• The agent is tested by asking "what's on this notion page?" The agent lists the mount skills directory, reads the fetch tool file, and despite initial import issues, successfully retrieves a preview of the page.
• The agent is then deployed to agencii.ai by pushing changes to GitHub, creating a new agency, and providing API keys.
• A more complex task is given: copying a transcript from Google Drive to a Notion page.
• Initially, the agent reads unnecessary files, but eventually confirms successful completion of the task.
• The agent proposes creating a new skill, which is then saved in the mount skills directory.
• The mount directory provides persistent storage, allowing agents to save and reference skills across different chats, enabling self-improvement.
• When the same prompt is given in a new chat, the agent uses the saved skill, completing the task much faster and with fewer tokens.

Comparing with Direct MCP and Cost Analysis (7:58 - 9:35)

• The direct MCP agent is tested with the same task. It reads the entire transcript and Notion page, manually typing the content, which is highly inefficient and token-intensive.
• Tracing is enabled by default to analyze costs. The direct MCP agent consumed 32,000 tokens for the task, with a significant portion being expensive output tokens.
• In contrast, the MCP code execution agent initially consumed 12,000 tokens for the same task, a substantial reduction.
• When the MCP code execution agent utilized an existing skill, it only consumed 4,000 tokens, demonstrating a 10x improvement over the initial run and a much larger improvement over the direct MCP method.
• The higher initial token consumption for the code execution agent is attributed to unnecessary tool calls, suggesting further optimization through prompting is possible.

Conclusion and Production Readiness (9:35 - 11:26)

• The MCP code execution approach is deemed extremely powerful but requires careful implementation.
• While it reduces token consumption from intermediate tool outputs, initial runs can still involve unnecessary tool calls and file reads.
• However, the agent's ability to self-improve by creating and utilizing new skills significantly cuts down subsequent execution costs.
• The final verdict is that this approach is production-ready, but proper prompting is crucial, as LLMs are not yet fully trained for this method.
• The benefits of increased autonomy and flexibility outweigh the minor drop in reliability.
• This paradigm shift allows agents to generate code directly, eliminating the need for complex abstractions.
• It is recommended for sophisticated general agents (analytics, research, operations) but not for simple agents (customer support).
• The platform agencii.ai is highlighted for addressing the infrastructure overhead, which is a major challenge for this approach.

Notable Quotes

"This technique is the future of building AI agents because it reduces token consumption 98% while giving your agents way more autonomy and flexibility to evolve their own skills." — [Speaker]

"Prompting is key with this technique and in order for this agent to use it effectively, it must clearly understand the process." — [Speaker]

"So in conclusion, I believe this approach is extremely powerful, but as they say, with great power comes great responsibility." — [Speaker]

"My final verdict is yes, this approach is ready for production, but it requires proper prompting." — [Speaker]

"Just let your agents run the code. We no longer have to create these abstractions on top of other abstractions because agents can just generate the code to do whatever they need by themselves." — [Speaker]