The CORBA of AI, or the Plumbing We Haven’t Finished Yet?
A Dialogue Between Alan “Shimmy” Shimel and Mitch “Shakespeare” Ashley
There is a moment in every technology wave when the room splits into two camps.
One says: This is the future.
The other says: This is overengineered nonsense.
Right now, that moment is happening around the Model Context Protocol (MCP).
Instead of another solo op-ed, what follows is a conversation — not staged, not polite, but grounded in how platform leaders actually argue when the stakes are real.
Shimmy:
Mitch, I’m going to just say it,
MCP is starting to feel like the CORBA of AI.
Not useless. Not stupid. Just too much architecture before we even know what the building looks like.
Everywhere I turn, platform teams are telling me the same thing: Security risk, token overhead, operational pain, weird deployment models. Some vendors are already pivoting to simpler Agent APIs, direct integrations, even CLIs.
Reality is undefeated. And reality is pushing back.
Shakespeare:
Alan, I think that framing misses why MCP spread in the first place.
MCP didn’t go viral because Anthropic ran a great marketing campaign. It spread because every team building with LLMs hit the same wall independently:
How do you reliably connect models and agents to real systems?
Before MCP, everyone had duct tape:
- Custom tool wrappers
- Proprietary function-calling formats
- One-off integration layers
- Zero portability
MCP gave the ecosystem a shared language. Adoption was pull, not push. Engineers don’t voluntarily adopt new infrastructure unless it solves real pain.
Shimmy:
Fair. The problem is real. Nobody disputes that. Is this the right solution? This is the question, Shakespeare :-)
Solving a problem once doesn’t mean the solution survives contact with production.
Platform teams aren’t rejecting the idea of agent-to-tool connectivity. They’re rejecting the operational cost of doing it this way.
Dynamic discovery sounds great until security shows up and asks who approved that tool invocation. Or finance shows up and asks why token spend doubled. Or SRE shows up at 3 a.m. because a persistent connection model doesn’t behave like the stateless infrastructure everything else uses.
That’s when elegance stops mattering.
Shakespeare:
Every AI plan is great until the token bill shows up! And that pushback is exactly why MCP shouldn’t be dismissed.
The gaps teams are discovering are not random flaws. They’re a roadmap of what agent infrastructure still lacks.
Security teams are right to worry. Formalizing autonomous tool access across trust boundaries without first solving identity, authorization and provenance absolutely creates a new attack surface.
Prompt injection becomes command execution. Tool poisoning becomes supply chain risk. Dynamic capability discovery becomes a vector if trust isn’t anchored.
FinOps is right to freak out when the piper comes a’ piping to pay the AI bill. Time to optimize and not let AI make those decisions by itself.
But those are solvable problems. They don’t invalidate the need for a standard.
Shimmy:
Solvable, sure. But not trivial.
Right now, most enterprises barely have identity and governance under control for humans. Now we’re introducing non-deterministic machine actors that can discover capabilities on the fly.
That’s not just a protocol problem. That’s an existential governance problem.
So platform teams are doing what they always do: routing around the risk.
LLM generates intent. Deterministic systems execute it. Guardrails everywhere. No surprise autonomy.
Boring architecture wins in production.
Shakespeare:
And yet proprietary fragmentation is worse long-term.
If every platform builds its own agent-to-tool interface, we recreate the pre-web era of incompatible systems. MCP’s value is interoperability — the idea that agents and services can talk without bespoke glue code for every pairing.
But for that to work, MCP has to mature in very specific ways.
It needs cryptographic attestation of tool servers so agents can verify provenance. It needs native observability of decision cycles so governance systems can reconstruct what happened and why. It needs authorization enforcement at the write boundary before actions execute, not logs after the fact.
Right now, most of that lives outside the protocol.
Shimmy:
Which brings us to the real issue.
Platform engineers don’t care where the capability lives. They care whether the system is governable.
Identity. Authorization. Auditability. Observability. Cost control.
If MCP doesn’t provide those, teams will bolt them on or bypass MCP entirely.
Either way, the protocol becomes plumbing, not architecture.
Shakespeare:
Exactly. And plumbing is where it belongs.
HTTP isn’t exciting. TCP/IP isn’t debated at conferences. They’re invisible because they work.
MCP is noisy because it isn’t production-grade yet.
The danger isn’t that MCP fails. The danger is that the ecosystem stops doing the hard work to make it boring.
And if MCP doesn’t evolve and fill its gaps, something else will quickly come along and take its place.
Shimmy:
So maybe the CORBA analogy is only half right.
CORBA failed not because distributed objects were useless, but because lighter approaches solved most problems with less operational pain.
If MCP becomes heavy middleware instead of lightweight plumbing, history repeats.
But if it evolves — adds identity primitives, telemetry, governance hooks — it could disappear into the stack the way successful protocols do.
Invisible but indispensable.
Shakespeare:
CORBA failed because it was too complex, and MQ series and a succession of message bus technologies pushed past it.
For MCP, the real architecture battle isn’t even at the transport layer.
The decisive layer is above it — the control plane that keeps autonomous systems accountable.
That’s where machine identity lives. Where policy intercepts actions before execution. Where knowledge authority defines trusted data sources. Where evidence trails link agent intent to real-world impact.
That layer barely exists today. But it will come. It will come because AI must have to reach production at scale.
Shimmy:
Now we’re getting to something platform leaders actually need to hear.
Whether MCP wins, loses or morphs, the winners won’t be the teams betting on a protocol. They’ll be the teams building governable agent platforms.
Identity-first machine actors. Deterministic execution boundaries. Curated capability surfaces instead of open discovery. Decision-level observability. Cost-aware design. Human override mechanisms.
In other words, platforms resilient to change.
Because the protocol will change.
Shakespeare:
And the next signal for MCP will come soon.
The Agentic AI Foundation under the Linux Foundation is hosting an MCP Dev Summit in New York this April. Open governance matters. It means the evolution of MCP isn’t tied to a single vendor roadmap.
What happens there will reveal whether the ecosystem is serious about closing the security, authorization and observability gaps — or content to celebrate adoption while enterprises quietly build alternatives.
Shimmy:
So let’s answer the question everyone keeps asking.
Is MCP the CORBA of AI?
Maybe. Maybe not.
What’s certain is this: Agents are coming whether MCP succeeds or not. Autonomous software interacting with real systems is no longer hypothetical.
The protocol layer matters. But it isn’t where platforms live or die.
Shakespeare:
The real question isn’t whether to MCP or not MCP.
It’s whether we can make autonomous systems governable at scale.
What’s the ultimate answer? The market always wins. Not the best technology.
Shimmy:
Now that’s a question worth arguing about.
Because in platform engineering, elegant ideas don’t win.
Operational reality does.
Build for that — and you’ll survive whatever protocol ends up carrying the traffic.
I come here today not to bury MCP, but to praise it as a good first try. But we need more.
Shakespeare:
Fare thee well, Shimmy; till next we speak.