MCP Isn't Dead. It Just Needs the Right Engine

Everyone’s talking about MCP, especially after Anthropic published a blog last month identifying two critical challenges when MCP scales: it uses too many tokens, and it fills up context windows quickly. Anthropic’s recommended approach involves code execution to solve these problems, generating data queries via Python requests on the fly and presenting MCP tools as APIs.

Code execution offers real benefits, but it also introduces new issues, especially at enterprise scale where you need repeatable, deterministic results and the ability to audit every query for governance and compliance.

We’ve built CData Connect AI, our managed MCP platform, to strategically address these two challenges. Our platform retains the core benefits of MCP (giving AI tools to actively find context on the fly through real-time data connectivity) while solving the token and context challenges in our data layer. Our focus is building for enterprise scale: an architecture that runs efficiently for many users, many MCP connections, and many instances of AI, with the security and governance needed across the entire deployment.

We’ll break down each approach and how they address the core challenges raised by Anthropic.

What are code execution and skills?

Before diving in, let's define the other approaches gaining traction as alternatives to direct MCP tool calling.

Code execution (sometimes called "code mode") allows AI to write and execute custom Python code on the fly rather than calling predefined tools. When an agent needs to query data, transform results, or combine information from multiple sources, it generates the code to do so within a sandboxed execution environment. Intermediate results stay in that environment rather than passing through the AI's context window.

Skills are predefined operations with specific context and actions that AI can execute with repeatability. Rather than figuring out how to accomplish a task from scratch, AI follows a prescribed set of steps and instructions to return a consistent result.

Both approaches are gaining traction because they address real pain points with MCP at scale. Code execution reduces token costs by keeping intermediate data outside the context window. Skills provide efficiency through predetermined paths. Anthropic and others have highlighted these approaches as ways to make AI agents more practical for complex data tasks.

How does Connect AI work?

We’ve strategically built Connect AI to reap the benefits of MCP while solving the token use challenges Anthropic identified. Rather than trying to work around MCP with code generation or predetermined Skills, we solve them at the platform layer while keeping MCP's benefits intact.

At the core of our approach is supplying a purpose-built semantic engine for AI, delivering a real-time query intelligence layer that transforms how AI agents interact with enterprise data. An AI agent connects their enterprise sources to Connect AI and then to their AI client through MCP. We expose the relevant context needed for the conversation: data sources, tables, columns, and relationships as structured metadata that the AI model can understand. Based on this metadata, the AI writes a more informed query to retrieve or act on the data it needs, translating natural language intent into a precise request.

Connect AI receives this query and makes intelligent improvements in real-time, optimizing and determining which operations can be pushed down to execute at the source system versus processed by AI in-memory, translating requests into each system's native API language. Connect AI performs this processing, shifting the burden away from the model – and from consuming unnecessary tokens - to a dedicated data platform tailored specifically to efficiently exploring and querying data.

AI agents connected through our single MCP endpoint can use our efficient set of MCP tools to work across all 350+ supported data sources. Instead of learning Salesforce's API, Google Drive's folder structure, and Snowflake's query syntax separately, agents use one consistent interface. This means AI can focus on what it does best: reasoning and forming thinking chains to best respond to a given task. The data platform handles what it does best: efficient, deterministic query execution and data processing with full auditability.

Let’s break down each of the challenges surfaced in Anthropic’s article.

Challenge 1: MCP uses too many tokens

The problem: Typically, every source system has its own MCP Server with its own set of tools. Across 12,000+ MCP servers registered in Github, the average has 5.7 tools each, with some exposing upwards of 217. When multiple servers are connected to one client, this proliferation of MCP tools causes AI to spend too many tokens understanding all the tools available to it. Anthropic's analysis found that tool definitions alone can consume over 150,000 tokens before processing a single request. Each data source brings dozens of specialized tools for pagination, filtering, and authentication. Agents waste precious context exploring these tools instead of solving problems.

Code execution reduces tool definition overhead by giving AI a general-purpose capability rather than source-specific tools. Instead of loading definitions for every possible operation, the agent writes custom code to accomplish what it needs. Anthropic's article highlights capabilities like tokenizing PII during processing and finding relevant capabilities dynamically with generated scripts.

The approach works well for reducing upfront token consumption. But it introduces tradeoffs: the overhead of generating, validating, and executing code for every request, plus the infrastructure requirements of secure sandboxed environments.

We built our MCP platform with an efficient set of just 9 MCP tools, letting AI focus on reasoning rather than loading, then navigating through, tool context up front. Our approach is to skip the token-heavy tool selection that comes from many MCP servers each with their own toolsets and data connections:

• An efficient set of universal MCP tools that work across every connected source. Nine tools handle schema discovery, query execution, and write operations for 350+ data sources. There's no need to load separate tool definitions for each system.

• A single MCP endpoint to context in many systems. When an agent needs customer data from Salesforce, support tickets from Zendesk, and telemetry from Snowflake, it doesn't load three sets of tool definitions up front. It requests data once, and our platform handles the rest.

• Source-specific MCP instructions to limit data exploration. Our platform includes intelligence about each connected source, reducing the queries needed to find relevant datasets.

We also offer features to customize for specific use cases, providing similar benefits to what Skills can offer:

• Derived Views let you save reusable complex queries instead of consuming thousands of tokens on data manipulation instructions. That "customer health" calculation joining five tables? Define it once, then query it directly. This is equivalent to querying Skills, as Anthropic laid out in their article.

• Custom Tools let you define specific actions for your use cases, equivalent to action Skills in the code execution model.

Benchmark testing: We tested this approach by running the same request through typical MCP servers and Connect AI: "Create an executive summary of our top 5 highest-value customers and their current health status."

Traditional MCP servers consumed 96,000 tokens across 10 tool calls. Connect AI completed the same task with 14,202 tokens and 3 calls. That's an 85% reduction in token usage and 70% fewer API calls.

Challenge 2: MCP fills up AI context window

The problem: Conversations end early, or AI forgets previous context because the context window fills up with unnecessary data, server definitions, and tool overhead. MCP's design flows intermediate results through the context window repeatedly. Query 10,000 records? They all enter the context window. Join data from multiple sources? Each intermediate step consumes context.

Anthropic's article also makes an important point: "With large documents or complex data structures, models may be more likely to make mistakes when copying data between tool calls." Context saturation doesn't just limit conversation length; it degrades response quality.

Code execution keeps intermediate results in the execution environment rather than passing them through the AI's context window. When transforming or combining data, results stay in memory until the final output is ready.

However, code execution introduces its own complexity. Anthropic acknowledges this directly: "Running agent-generated code requires a secure execution environment with appropriate sandboxing, resource limits, and monitoring. These infrastructure requirements add operational overhead and security considerations that direct tool calls avoid." The benefits should be weighed against these implementation costs.

We purpose-built a semantic engine as a real-time query intelligence layer that only introduces the most relevant data to AI's context window by performing the query logic in our data layer. AI uses MCP to ask Connect AI for the right data rather than fetching everything available and trying to reason over it within the conversation.

Instead of being forced to organize and catalog data up front before ever connecting to AI, CData takes a novel approach to query data in-place, in source systems where data is gathered and stored, and then provide the semantic engine at the platform level to AI to choose the right data context. This bypasses the need to introduce, sort, and parse through data in the AI context window and instead perform those operations in the data layer on-demand for AI:

• Intelligent Query Processing: The engine handles the complexity that makes enterprise integration slow. It manages API pagination through concurrent page fetching, automatically detects and leverages bulk endpoints when available, respects each system's rate limits to prevent throttling failures, and translates responses from JSON, XML, CSV, and other formats into a standardized structure. What would require months of custom development for each source system is handled automatically.

• Pushdown Architecture: Our engine handles data filtering, aggregation, and transformation at the source, returning only the precise results the agent needs rather than raw data for the model to process. This pushdown architecture dramatically reduces token consumption because the model receives clean, relevant answers instead of processing thousands of rows to extract what it needs.

Benchmark testing: We ran a complex cross-system query: "Create an executive summary of our top 5 highest-value customers and their current health status, including any immediate actions needed"—requiring Salesforce Account and Opportunity data, Zendesk support tickets, and Snowflake telemetry. Without query pushdown, the LLM retrieved and stored 4 large datasets within its context window, then processed thousands of records in-context to identify customers, correlate support history, and synthesize insights. With intelligent processing and query pushdown, Connect AI parsed the query, using the semantic engine to first determine which parts each source system can answer before every querying, retrieving only relevant records, and joining the results outside the LLM's context window. The model receives a clean, pre-processed dataset of just 5 customers with correlated health metrics, focusing on analysis and reasoning rather than data wrangling. In our testing, we found up to 2-5X savings in context windows when the data that enters is curated for relevance before applying AI reasoning.

Providing security and governance for MCP

On top of solving token efficiency challenges with MCP, enterprises also need confidence that all AI data access – regardless of whether AI is using MCP, code execution, or Skills – is secure and auditable. Code execution approaches introduce additional enterprise security risk:

• Probabilistic uncertainty: LLMs generating executable code compounds the inherent randomness of AI responses. The same request might produce subtly different Python across conversations, with unpredictable results.

• Audit complexity: When compliance asks "what data did agents access last month?", reviewing thousands of unique Python scripts isn't feasible. Data queries logged in a platform are self-documenting and auditable.

• Security gaps: Sandboxing prevents code escape but doesn't enforce data access policies external to AI. Additional permissioning is required at a wider level than only within the AI chat interface itself.

Since our platform sits in between AI and data systems, we built Connect AI to deliver critical data security and governance controls for enterprises to leverage MCP at scale with confidence:

• Codified organizational learning: Each conversation rediscovers optimization patterns with code execution. A platform approach optimizes for specific data system patterns once then applies that semantic intelligence everywhere. Context-specific Skills can be created and shared, but this takes manual development and maintenance that break as source systems update and data schemas change.

• Identity-first security: Connect AI passes through queries to respect underlying system permissions, honoring user credentials via OAuth and SAML so that every agent request enforces source system access controls at runtime. Agents can't access data their users can't access, regardless of query construction. This enforcement happens at the platform level, before data ever reaches the AI model, preventing prompt injection attacks from bypassing security and eliminating data leaks through model manipulation.

• Query-level observability: Every interaction flows through a single governed layer with comprehensive audit trails: query, user, result set, timestamp. Every operation logs a human-readable query with full attribution. No forensic analysis of generated code required.

• Centralized control: IT manages all connections, authentication, and policies through a single platform. No shadow MCP servers spinning up outside governance.

• Zero-data retention: CData operates on a zero-data retention model. Agent requests pass through, results return, and no enterprise data is ever stored or cached. Organizations get the benefits of centralized connectivity without the security risks of centralized data storage.

Implement MCP efficiently with a managed platform

The challenges Anthropic identified with MCP are real, but they're implementation problems, not flaws with the protocol itself. With the right architectural approach, the token consumption and context window issues can be mitigated without sacrificing MCP's core benefits.

We've built Connect AI to give AI agents and assistants the flexibility to think and reason over optimal approaches for a given query (unlike Skills that follow prescribed tracks) while delivering deterministic, auditable results (unlike code execution that changes per conversation).

MCP's key benefits remain intact: giving AI the tools to autonomously take action and understand data. The right data platform powering MCP connectivity conserves token usage and context window consumption without limiting what AI can accomplish.

Our vision is for enterprises adopting AI to use MCP for intelligent data access and autonomous action at scale, without relying on non-deterministic code execution or pre-set Skills that follow prescribed paths. The future of AI shouldn't require choosing between efficiency, flexibility, and governance. With the right platform solution, you can use existing protocols that work and get all three.

Now available in the Anthropic connector directory

Start a 14-day free trial to try Connect AI’s MCP approach for yourself. Connect AI was recently certified by Anthropic and featured for Claude users across Claude, Claude Code, and the Apps SDK. Learn more and try it today in Claude.