Is MCP Dead? Why the Debate Is Asking the Wrong Question

MCP Isn’t Dead. Using It Without Guardrails Is.

Every week in AI brings a new headline that seems to rewrite the rules. Every company needs an OpenClaw strategy. Agent-to-agent protocols will replace tool calling. Anthropic is a supply chain risk.

The latest: MCP is dead.

The pace is relentless, and the discourse shifts faster than most enterprises can evaluate it.

Perplexity’s CTO Denis Yarats said they’re moving away from MCP internally. Y Combinator’s Garry Tan built a CLI instead of using it. Cloudflare replaced MCP’s tool-calling mechanism with code generation and cut token usage by 244x.

The pains they’re hitting are real. Basic MCP with 2,500 API endpoints is going to burn tokens and destroy context. Cloudflare found that tool descriptions alone would consume roughly 244,000 tokens before the agent processes a single user message.

Authentication across multiple MCP servers is fragile by design. When you give an agent access to fifteen granular tools and ask it to process an order, the LLM has to figure out the right sequence every time—and LLMs are nondeterministic by design. That’s what makes them powerful for reasoning and dangerous for sequential business logic.

But nobody should be running basic MCP in production. Full stop.

That’s like giving an intern the keys to every system on day one with no training, permissions, or approval manager—then blaming the keys when something breaks.

MCP Is a Protocol. It Was Never Meant to Be the Whole Answer.

MCP does something genuinely useful: it gives agents instructions, access to external tools, and the ability to take action across systems. Standardized discovery. A common interface. The ability for any MCP-compliant client to invoke any MCP server. That’s real value.

But a protocol is not a platform. MCP standardized the connectivity plane. It did not standardize governance, orchestration, identity, observability, or any of the things that make enterprise software production-ready.

The critics who are abandoning MCP are solving the wrong problem. Going back to raw APIs and CLIs eliminates the overhead. It also reintroduces every problem MCP was designed to fix—no standardized discovery, no unified governance, no centralized audit trail. Every tool connection goes back to being custom-built and independently maintained. Switching from MCP to CLI doesn’t eliminate prompt injection or privilege escalation. It changes the protocol, not the threat model.

The real question is not MCP or not MCP. It’s what sits underneath MCP to make it work at enterprise scale.

Three Layers: How Enterprises Should Actually Architect for AI

Step back from the MCP debate for a moment and ask a bigger question: how should an enterprise architect its AI strategy so it doesn’t break every time the landscape shifts?

The answer is three layers.

Bottom: your systems of record. ERPs, CRMs, databases, data warehouses, on-prem systems, SaaS applications. The source of truth for your business. These don’t change often—and they shouldn’t. You never want an AI improvising or hallucinating here.

Top: the fast-moving AI innovation layer. AI models, agent frameworks, copilot experiences, new UI protocols. GPT-5 ships. Claude gets smarter. OpenClaw launches. Cowork changes how people interact with agents. New research drops weekly. This layer should move fast. You want your teams experimenting, adopting what works, discarding what doesn’t. That’s healthy.

Middle: your stable action and control plane. This is the infrastructure layer most enterprises are missing—and it’s the layer that determines whether AI experimentation turns into durable business capability or a pile of technical debt.

This middle layer is where your governance lives. Your workflows. Your business process logic. Your identity and access controls. Your audit trails. The parts of your business that shouldn’t change every time a new model drops or a new agent framework trends on Twitter.

A composable skill like “generate quote” or “process refund” encapsulates your organization’s actual business logic—check inventory, validate pricing, verify payment, route approvals. That logic doesn’t change because you swapped Claude for GPT or moved from one agent framework to another. It’s a durable asset. If you couple it to a specific agent vendor or a basic MCP implementation, you’ll rebuild it every time the landscape shifts.

And the landscape will shift. Probably next quarter. Or next week.

The organizations that get this right decouple their investment in governed business capabilities from the rapid experimentation happening above. The ones that don’t will rebuild their agent infrastructure every six months.

What the Control Plane Actually Does

Workato Enterprise MCP is that middle layer. It keeps what makes the protocol valuable—standardized connectivity, tool discovery, a common interface—and adds the three things basic MCP is missing:

Context

Most MCP servers today are thin wrappers that return raw JSON. That’s fine for a developer in an IDE. For an enterprise agent that needs to reason accurately, you’re dumping noisy payloads into the context window, wasting your token budget, and increasing hallucination risk.

Enterprise MCP solves this with data servers that aggregate and transform information across multiple systems, returning agent-ready summaries instead of raw API responses. Instead of giving the agent fifteen fields of JSON and asking it to compute pipeline health, you return a curated summary the agent can actually use.

Trust

Many basic MCP implementations run on service accounts with admin access. There’s no user-level permission inheritance. Developers deploy servers on localhost, personal machines, unapproved cloud instances. Your IT team can’t tell you how many MCP servers are running in your environment right now.

Enterprise MCP replaces this with a single gateway—one identity model, one permission framework, one audit trail. Every agent action inherits the end user’s actual permissions. The agent accesses only what that user is authorized to see, not every record in the CRM.

Accuracy

This is the critical one. Instead of asking the agent to chain together a fifteen-step business process from granular API calls—hoping it gets the sequence right every time (without hallucination or improvisation)—Workato Enterprise MCP introduces composable skills.

With Enterprise MCP, a single skill invocation can trigger an orchestrated workflow with dozens of steps, error handling, approval routing, and compensating transactions. The agent provides the intent. The skill guarantees execution. Sequence is enforced. Business rules are embedded. Rollback handles failures gracefully.

That separation—agent reasons, skill executes—is the design principle that makes the difference between a demo and a production system.

This Makes You Faster, Not Slower

Here’s the real reason to invest in your AI control plane first: it accelerates everything above it.

If your organization has a hundred existing automation workflows, those become a hundred production-ready composable skills that any agent can invoke immediately—complete with error handling, business rules, and system connectivity you’ve already tested and operationalized. You’re not starting from zero. You’re turning years of integration work into instant agent capabilities.

And because the control plane is decoupled from the innovation layer, you get genuine freedom to move. GPT-5 outperforms your current model? Swap the reasoning layer without rebuilding your stack. A new agent framework gets traction? Adopt it. Your composable skills, governance controls, and orchestration logic carry over unchanged. No rip-and-replace.

This also changes the economics. Enterprise MCP transforms AI from a net-new build initiative into an agent-enablement initiative—a layer that sits on top of your existing integration investments and makes them available to every agent in your environment. No painful migrations. No replatforming. No vendor lock-in.

The Pace Isn’t Slowing Down

The AI landscape will keep moving. New models will ship every few months with materially improved capabilities. New protocols will emerge. Some of today’s agent frameworks won’t exist in eighteen months. The “MCP is dead” take will be replaced by something else next week.

None of that matters if your architecture is built to absorb change instead of breaking from it.

Basic MCP without guardrails will fail in enterprise environments. That’s not controversial—the critics are right about that. But Workato Enterprise MCP, which creates a governed layer of context, trust, and action between your fast-moving AI innovation and your systems of record, is what allows organizations to actually deliver on the promise of agentic AI.

Move faster. Increase trust. Transform without rebuilding every quarter.

The question is not whether to adopt MCP. It’s whether to build the control plane now—or discover the gaps in production.