End Mcp Agents: The Code-First Revolution That Slashes Token Use by 98%

[rehub_toc]

In a groundbreaking shift in AI agent architecture, Entropic’s latest blog post has challenged the foundational role of Model Context Protocol Servers (MCPS) in building intelligent agents. Even more striking? The speaker behind this video independently implemented the exact alternative approach just one week before the blog post dropped—and saw 98% less token consumption, significantly better results, and greater autonomy. This comprehensive guide unpacks every insight, technique, and implication from that revelation, offering a complete blueprint for moving beyond MCPS to a more powerful, efficient, and scalable paradigm: code execution with on-demand tool access.

Whether you’re a developer, AI engineer, or enterprise architect, this article delivers every detail from the transcript—no insight left behind. From the core flaws of MCPS to step-by-step implementation strategies, privacy safeguards, and future-proof agent evolution, you’ll learn exactly why and how to end MCPS agents in favor of a code-native future.

What Are MCPs? The Original Vision for AI Agent Integration

Model Context Protocol (MCP) was introduced as an open standard designed to connect AI agents to external systems. At its core, an MCP is essentially an API built for AI agents, not human developers. While traditional APIs are crafted for programmers to consume, MCPs are structured so that large language models (LLMs) can understand, select, and invoke tools autonomously.

Technically, there’s little difference between an MCP and a standard REST or GraphQL API. The real innovation wasn’t the protocol itself—it was the industry-wide standardization. Because MCP became a universal format, developers could build once and unlock an entire ecosystem of integrations. This fostered collaboration, tool sharing, and interoperability across the AI agent landscape.

The Hidden Cost of MCPS: Why Token Consumption Spirals Out of Control

Despite its initial promise, MCPS introduces severe performance and cost bottlenecks as agent complexity grows. The transcript identifies two primary causes of excessive token usage:

1. Tool Definition Overload in the Context Window

When you connect an agent to an MCP server, it typically exposes 20 to 30 individual tools. Most developers don’t stop at one MCP—they often connect five or six MCP servers simultaneously. Each tool comes with a detailed description, parameters, and usage instructions. Even if the agent only needs one tool for a task, all tool definitions from all connected MCPs are loaded into the context window.

This leads to three critical problems:

• Increased cost due to higher token consumption
• Higher latency from processing unnecessary context
• Greater risk of hallucinations as the model sifts through irrelevant information

2. Intermediate Tool Results Flooding the Context

When an agent calls a tool—like retrieving a transcript from Google Drive—the full result (e.g., 50,000+ tokens) is often dumped into the context window. Worse, large documents may even exceed the model’s context limit. Yet, the agent might only need the first paragraph or a specific excerpt. MCPS provides no mechanism to filter or stream partial results, forcing the agent to process everything—even data it doesn’t use.

The Code-First Alternative: On-Demand Tool Execution

Entropic’s solution—and the speaker’s independently discovered approach—is to replace static MCP loading with dynamic code execution. Instead of pre-loading all tool definitions, agents generate and execute code to call only the tools they need, exactly when they need them.

Folder-Based Tool Organization Structure

The proposed architecture organizes tools in a hierarchical file system:

• Root project folder
• → Subfolder for each MCP server (e.g., /salesforce, /google-drive)
• → Inside each server folder: individual TypeScript files for each tool (e.g., getTranscript.ts, createTicket.ts)

When the agent requires a specific capability, it dynamically imports the relevant TypeScript file and executes the function—no other tools are exposed.

Five Transformative Benefits of the Code-First Approach

1. Drastic Token Reduction (98% Less Usage)

By eliminating tool definition bloat and avoiding full-result ingestion, the agent’s context remains lean. The speaker reports a 98% reduction in token consumption—a game-changer for cost and scalability.

2. Selective Data Access and Processing

Instead of reading an entire 50k-token transcript, the agent can:

• Save the raw data to a variable or file system
• Extract only the needed portion (e.g., first paragraph)
• Or even pass the data without reading it—e.g., sending a Google Drive transcript directly to a Salesforce MCP server for processing

3. Progressive Disclosure: Unlimited Tool Scalability

With code-based tool access, there’s no hard limit on the number of MCP servers. Agents can be equipped with thousands of tools. To navigate this vast toolkit, they can use a dedicated “search tools” function to discover the right MCP or tool for the current task—enabling true scalability without context bloat.

4. Enhanced Data Privacy for Enterprise Use

Enterprise clients often refuse to expose sensitive data (e.g., customer emails, financial records) to third-party LLM providers like OpenAI or Anthropic. MCPS inherently leaks this data into the model’s context.

The code-first approach solves this via a custom data harness. For example, you can modify the getSheet tool to automatically anonymize sensitive fields:

// Example: Anonymizing emails in Google Sheets data
function getSheet(sheetId: string) {
  const rawData = fetchSheet(sheetId);
  return rawData.map(row => ({
    ...row,
    email: anonymizeEmail(row.email) // e.g., user123@domain.com → ***@***.***
  }));
}

This ensures PII never reaches the LLM provider.

5. State Persistence and Self-Evolving Skills

This is the most game-changing benefit, according to the speaker. Agents can now:

• Identify a missing capability
• Generate a new function (e.g., a custom data parser)
• Save it as a TypeScript file in the appropriate tool folder
• Reuse it in future tasks

This enables agent evolution—a concept closely aligned with Cohere’s “skills” framework. Over time, your agent builds a personalized library of competencies, becoming more powerful with every interaction.

Real-World Performance Results: What the Speaker Observed

After implementing the code-first approach one week before Entropic’s announcement, the speaker witnessed dramatic improvements:

Key Limitations and Trade-Offs of the Code-First Model

While powerful, this approach isn’t without challenges. The speaker candidly outlines two major drawbacks:

1. Reduced Reliability Due to Code Generation Errors

Every tool invocation now requires the agent to generate correct, executable code. If the LLM makes a syntax error, misnames a function, or passes wrong parameters, the tool call fails. This introduces more points of failure compared to the structured, schema-enforced nature of MCPS.

2. Increased Infrastructure Overhead

To safely execute agent-generated code, you must deploy a secure sandbox environment. This isolated runtime must:

• Prevent malicious or infinite loops
• Restrict network access to approved APIs only
• Handle authentication and rate limiting
• Provide observability and error logging

Setting this up requires significant DevOps effort—though the speaker notes their platform already offers this capability.

When to Still Use MCPS: The Right Tool for Simpler Jobs

The speaker emphasizes: MCPS isn’t obsolete. It remains ideal for specific, constrained use cases:

For these scenarios, the overhead of code generation and sandboxing isn’t justified. MCPS offers simplicity and reliability.

Why Code Execution Aligns with Modern LLM Capabilities

The shift to code-first isn’t just practical—it’s inevitable. As the speaker notes: “Agents have become increasingly good at generating code in the last couple years.” Modern LLMs like GPT-4, Claude 3, and others excel at writing syntactically correct, functional code in languages like TypeScript, Python, and JavaScript.

Adding layers of abstraction (like MCPS) on top of this capability reduces agent autonomy. The whole point of an AI agent is to autonomously execute tasks. Every abstraction forces the agent to conform to human-designed constraints rather than leveraging its native reasoning and coding strengths.

Step-by-Step: How to Implement the Code-First Agent Architecture

Based on the transcript, here’s how to transition from MCPS to code execution:

1. Create a root project directory for your agent’s codebase.
2. Set up subfolders for each external service (e.g., /google-drive, /salesforce, /notion).
3. Inside each service folder, add TypeScript files for individual tools (e.g., getTranscript.ts, createRecord.ts).
4. Implement a secure sandbox environment where the agent can execute generated code (or use a platform that provides this).
5. Equip the agent with a “search tools” function that scans the file system to discover available capabilities.
6. Add data anonymization wrappers for tools that handle sensitive information.
7. Enable dynamic skill creation by allowing the agent to write new .ts files into the tool folders.

Privacy by Design: Building Enterprise-Ready Agents

For organizations handling regulated data (GDPR, HIPAA, etc.), the code-first model enables privacy-preserving agent design:

• All sensitive data processing happens inside your secure sandbox, never leaving your infrastructure
• Data sent to the LLM is pre-sanitized via tool-level anonymization functions
• You maintain full audit logs of data access and transformations

This contrasts sharply with MCPS, where raw API responses—including PII—are streamed directly into the LLM’s context, often hosted by third parties.

The Future of AI Agents: Skills, Evolution, and Autonomy

The ability for agents to create and persist their own skills points toward a new era of adaptive AI. Inspired by Cohere’s “skills” concept, this approach allows agents to:

• Learn from repeated tasks
• Generalize solutions into reusable functions
• Share skills across agent instances
• Continuously improve without developer intervention

This transforms agents from static task executors into evolving digital colleagues.

Infrastructure Requirements for Safe Code Execution

To adopt this model, you’ll need:

Comparing MCPS vs. Code-First: A Complete Feature Breakdown

Practical Example: From Google Drive to Salesforce Without Reading Data

Imagine an agent tasked with sending a meeting transcript to Salesforce. With MCPS:

1. Loads 100+ tool definitions into context
2. Calls Google Drive MCP → receives 50k-token transcript
3. Processes entire transcript in LLM context
4. Calls Salesforce MCP with extracted info

With code-first:

1. Agent generates: import { getTranscript } from './google-drive/getTranscript';
2. Executes const transcript = getTranscript(meetingId); → saves to variable
3. Generates: import { sendToSalesforce } from './salesforce/sendToSalesforce';
4. Executes sendToSalesforce(transcript); without ever reading the content

No extra tokens. No data exposure. Maximum efficiency.

How to Get Started Today

The speaker invites viewers to explore their platform, which already implements this secure, sandboxed, code-first agent architecture. For DIY developers:

• Start by converting one critical MCP tool into a TypeScript function
• Set up a basic sandbox using Docker or Firecracker microVMs
• Implement a simple “tool discovery” function that lists available .ts files
• Measure token usage before and after to validate the 98% reduction

Conclusion: The End of MCPS Agents Is the Beginning of True Autonomy

The transcript delivers a clear verdict: while MCPS played a crucial role in standardizing AI agent tooling, its limitations in token efficiency, scalability, and privacy make it unsuitable for advanced applications. The code-first approach—leveraging modern LLMs’ coding prowess—unlocks 98% lower costs, enterprise-grade privacy, and self-evolving agent capabilities.

This isn’t about discarding standards; it’s about recognizing that code is the ultimate abstraction. As agents grow more capable, we must stop over-engineering layers between them and their actions. The future belongs to agents that write, execute, and improve their own code—autonomously.

Ready to see a live implementation? The speaker recommends watching their next video, which demonstrates an agent connecting to any API—without MCPS.

End Mcp Agents: The Code-First Revolution That Slashes Token Use by 98%

Buy this item