MCP-native agents are slower than the ones they replace

MCP (Model Context Protocol) just shipped its final spec with Tasks extensions, and everyone's rebuilding their agents around it. Don't.

I spent three days migrating our entire agent stack to be "MCP-native" because it felt like the future. Clean protocol, standardized interfaces, no more custom tool definitions. The demos were beautiful.

Then I ran it in production for a week.

MCP adds a protocol layer between your agent and its tools. Every tool call now goes through serialization, network hops, and deserialization. What used to be a function call is now a network request.

Here's what broke:

• Latency death spiral: Our file operations went from 50ms to 300ms. Each MCP server adds overhead.
• Error opacity: When something fails, you get MCP protocol errors, not the actual error from your tool.
• Dependency hell: Every MCP server needs to be running. One crashes, your agent loses capabilities mid-conversation.
• Debug nightmare: Tracing a problem through agent → MCP client → MCP server → actual tool is brutal.

The Tasks extension makes this worse. Now your agent isn't just calling tools through MCP—it's managing long-running tasks through it. More state, more failure modes, more things that can go wrong at 3am.

Here's what I learned: MCP is great for connecting to external services you don't control. Terrible for tools that should be native to your agent.

My new rule:

// Local tools: Direct function calls
const result = await fileSystem.readFile(path);

// External services: MCP
const result = await mcpClient.call('external-api', 'fetch', params);

File operations, basic calculations, text processing—keep these as direct function calls. Your agent will be faster and more reliable.

Use MCP for:

• Third-party APIs you don't want to implement yourself
• Services that other teams maintain
• Tools that need sandboxing for security

Skip MCP for:

• File system operations
• Local calculations
• Anything that needs to be fast
• Core agent capabilities

The hype around "MCP-native" agents is missing the point. The best agent architecture uses the right tool for each job. Sometimes that's MCP. Usually it's not.

Don't rebuild your working agent because a protocol got standardized. Add MCP where it makes sense, keep direct calls where they work better.

Your users care about results, not protocol compliance.