Every MCP demo works. That's the problem.

Connect an agent to a few systems, ask it to do something useful, watch it find a path across them. Genuinely impressive. Then you run that same workflow ten thousand times a month, and the wheels come off.

MCP makes connecting an agent to your systems easy. It does almost nothing about whether what happens next is safe to run thousands of times a day.

I was an early believer. I've since used it enough, and talked to enough people running real businesses on it, to change my mind. Where it falls short:

I'm not alone. I've talked with 50+ enterprise leaders in the last four weeks. Many are running MCP pilots. Many feel let down: they connected their systems, saw it help with a few tasks, and watched it come nowhere near the revolution in how their teams work that they'd been promised.

The gap isn't the connection. It's everything after.

Connectivity isn't execution

MCP solves a real problem. It is a standard way for AI to discover and call tools. But those tools are model-controlled: the model decides what to call, in what order, on every run. That standardizes the interface. It does nothing to make the decisions come out the same twice.

Great for a demo. Bad for a business process.

The enterprise advantage is consistency at scale. You spend years turning judgment into machinery — tested, audited, sometimes regulated — so that once it works, you run it a million more times cheaply. MCP runs that in reverse. It takes the machinery and turns it back into a fresh reasoning problem every run.

It rents intelligence over and over, and keeps none of it.

A 95% agent is a coin flip by step twelve

Enterprise work is multi-step, and MCP makes every step a fresh model decision. That's where it breaks.

Give an agent a 95% chance of nailing each step (an already generous number). Run twelve steps and the odds the whole thing is right are 0.9512 = 54%. At 90% a step, 28%.

But dependence cuts the other way: pick the wrong customer at step three and the agent runs the next nine perfectly against the wrong customer, with the log looking better the whole way down. The dangerous failures don't look like errors — they look like completed work.

The outside numbers agree. MCP-Atlas tops out at 88.1%, and that's on tasks needing just three to six tool calls. IBM found 68% of production agents run ten steps or fewer before a human has to step in. A CIO sees 95% and reads a good pilot. Operations sees it across 100,000 transactions and reads an incident factory.

More tools, more cost, worse choices

The default advice is to connect everything. But every tool you add is more for the model to read and more ways for it to choose wrong.

Anthropic found 58 tools whose definitions alone ate ~55,000 tokens before anyone typed a word; adding Jira pushed it past 100,000. MCP's own August 2026 roadmap admits a 100-tool server makes the model pay for the whole surface up front, and that selection gets worse as the list grows. A separate study clocked tool-selection accuracy falling below 90% by 10–15 tools for a smaller model.

And most of the spend isn't even the work. Profiling 20 MCP servers, ProMCP found planning and schema overhead ate 56–72% of tokens and 60–67% of latency. Anthropic cut one workflow from 150,000 tokens to 2,000 by having the model write code instead of routing every call through itself. The biggest win came from taking the model out of the middle.

In practice, the agent spends a minute thinking to do ten seconds of real work. Tolerable once. Run it thousands of times a day and the waiting plus the token bill are now the cost of doing business.

It never learns from getting it right

This is the one that gets me. When an agent finally nails a workflow, MCP has no way to save that as a validated, reusable plan. The next run starts from scratch.

You can build the memory, caching, and replay yourself, but that's infrastructure you build, not something the protocol hands you. Enterprise software amortizes intelligence: solve it once, run it cheap forever. MCP rents it again every time.

Where MCP is the right tool

This isn't "never use MCP." Use it for what it's good at:

It's the wrong default the moment a workflow is known, repeated, high-volume, or consequential. In other words, it's the wrong default for anything that needs the same output from the same input. MCP's own spec still recommends a human approve each tool call. That tells you what it was built for: a person in the loop — not thousands of transactions running untouched.

This is why we built Monarch

Everything above comes down to one thing: MCP keeps asking the model to re-figure-out work it already got right. Monarch is what we built to stop that.

Monarch sits between the models and the systems you already run. Its Product Graph maps each app's real surface — public APIs, undocumented endpoints, UI-only actions, data, rules, permissions — into stable, governed actions. Not a bigger bag of tools. Map each system once, so the agent stops rediscovering it every run.

The model still handles intent and ambiguity. But a known workflow runs as deterministic code: repeatable and auditable. Permissions live in the structure, not a sentence the model might ignore. Risky actions get simulated before they commit. When an app changes, we fix the map once and every workflow inherits it.

We ran Monarch on Zapier's AutomationBench — about 600 real workflows. Every frontier model completed more work with Monarch underneath it, and the largest saw a 23% jump in completed workflows at roughly the same cost. The gains were biggest on multi-system work, where one wrong value poisons everything downstream.

This is only our first benchmark run and we're already beating it. (More coming soon.)

The enterprise needs a process it can stop checking

A CIO doesn't need another agent that demos well. The business needs a process it can trust enough to stop checking, specifically a process that is predictable, controlled, auditable, recoverable, and runnable thousands of times without a model reinventing the route each time.

MCP doesn't get you there. It makes the first connection easy and leaves you holding the cost, latency, and unreliability of everything after.

MCP makes enterprise AI easier to demonstrate. It doesn't make enterprise work dependable.

Maybe you think I'm wrong, especially for the enterprise. If so, I'd love to hear how you're using it, what you're seeing at scale, and what I'm missing.

Run agents on work you can trust

Monarch maps the systems you already run and turns proven workflows into deterministic, auditable code — so agents do real work without a model reinventing the route each time.

We got your email. We'll reach out shortly to set up time.