Every enterprise integration era has had its connective tissue. SOAP and ESBs defined one generation. REST APIs and iPaaS tools defined the next. In 2026, a third layer is forming, and it is not designed for developers writing code. It is designed for AI agents that need to discover and use your systems on their own.
That layer is the Model Context Protocol, or MCP. Anthropic introduced it as an open standard, and it has since moved from developer curiosity to something enterprise architecture teams are putting on roadmaps.
This article takes a specific angle. The protocol itself is the easy part to explain. The harder and more useful story is what enterprises are building around it: gateways, registries, identity controls and governance. That is where adoption succeeds or stalls.
A note on the numbers: many figures cited about MCP come from vendor-run surveys and secondary reports. Where I use them, I flag them as directional.

The Problem MCP Actually Solves: N×M Integrations
Before MCP, connecting an AI application to a business system meant custom work. Each model or agent framework needed its own connector for each tool. Ten agent applications and twenty systems could mean up to two hundred bespoke integrations.
MCP changes the arithmetic. A system exposes its capabilities once through an MCP server. Any MCP-capable client can then discover and call those capabilities. The effort moves from multiplying (N×M) to adding (N+M).
What an MCP server exposes
An MCP server describes what it offers in a standard way. This includes tools (actions an agent can invoke), resources (data an agent can read) and prompts (reusable templates). The agent learns what is available at runtime instead of having it hard-coded.
Why this is different from an API
APIs are written for developers who read documentation and write code against fixed endpoints. MCP tool descriptions are written for a model that decides, mid-task, which tool fits. That sounds subtle, but it changes how you design interfaces. Tool names, descriptions and argument schemas become part of the product, because the model reads them.
It also means MCP does not replace APIs. In most enterprises, an MCP server is a thin, well-described layer over existing services. Treat it as an interface for agents, not a new backend.
Adoption Signals: What the Data Says, and What It Doesn’t
Several data points suggest MCP has crossed from experiment to infrastructure.
- Industry surveys place production use at roughly 40–45% of software companies, but only about 19% report broad deployment. Methodologies differ, so treat these as directional.
- Stacklok surveyed 300 senior technical leaders in December 2025. MCP was a top-five priority for nearly half of large enterprises, and nearly 60% of respondents worked at companies with more than 5,000 employees.
- Reported Python and TypeScript SDK downloads reached about 97 million per month by March 2026, up from roughly 100,000 at launch. I could not corroborate that figure against a primary source, so read it as a rough indicator.
The gap between “using in production” and “broadly deployed” is the real signal. Many organisations have a handful of MCP servers running for developer workflows. Few have a governed, company-wide layer.
Where adoption leads
Developer tooling comes first. Test generation, code review, debugging, vulnerability remediation and legacy-code analysis are the common starting points. These are low-risk because the data is internal and the users are technical.
Security is the main constraint. In one survey, security ranked as the top obstacle for 64% of software respondents. Reported blockers include authentication, authorization, auditability, legacy integration and uncontrolled internet-facing servers.

Neutral Governance: Why the Linux Foundation Move Mattered
Enterprises hesitate to build on a standard controlled by one vendor. In December 2025, Anthropic donated MCP to the Linux Foundation’s Agentic AI Foundation (AAIF). Reported co-founders include Anthropic, Block and OpenAI, with major cloud and infrastructure companies participating. Technical decisions remain with project maintainers.
The AAIF’s CTO has argued that neutral governance should increase trust and let more stakeholders shape the ecosystem. That is a vendor’s-eye view, but the logic is sound for buyers. A standard that competing vendors co-maintain is less likely to be redirected to serve one roadmap.
Lifecycle rules procurement teams care about
Reported governance changes include formal feature lifecycle management, public proposals, conformance testing, and a minimum 12-month deprecation window. That last item matters more than it sounds. Integration layers live for years. A promise that features will not vanish with a few weeks’ notice lets teams plan budgets.
The Stateless Specification and Why Platform Teams Care
Early MCP deployments were awkward to run at volume. Sessions and handshakes meant that requests often needed to reach the same server instance. That is sticky load balancing, and it complicates Kubernetes deployments.
The specification release reported for July 2026 made the core stateless and removed the session handshake. It also added HTTP routing headers, cacheable list results, multi-round-trip requests, asynchronous tasks and stronger authorization.
What this changes in practice
- Horizontal scaling: servers can sit behind ordinary load balancers.
- Gateway enforcement: header-based routing lets gateways make policy decisions without parsing message bodies.
- Long-running work: asynchronous tasks fit real enterprise jobs such as report generation or batch updates.
- Extensions: a framework for optional capabilities lets the core stay small.
In short, MCP started behaving like something a platform team already knows how to operate.

The Gateway Pattern: The Real Enterprise Architecture
Linux Foundation research found practitioners commonly place an intermediary gateway between agents and models for governance, usage metrics and cost control. The takeaway is blunt: MCP standardizes connections, but it does not by itself make enterprise data accessible or safe.
A gateway becomes the single control point. Typical functions include:
- Authentication and authorization for every call
- Policy enforcement, such as which agents may use which tools
- Observability and usage metering by team, agent and tool
- Input and output filtering
- Audit logging for compliance
- A registry of approved servers
Why a registry is as important as the gateway
Without a registry, developers stand up servers wherever they like. Security teams then find internet-facing servers they did not know existed. A registry gives you an inventory, an owner for each server and a review process before anything reaches production.
Case Study: Uber’s Gateway and Registry
Uber is a useful example because it built the layer, not just the servers. According to reporting, the company created an MCP gateway and registry that converts internal service endpoints into MCP tools. It applies a two-tier trust model and scans configurations for risky combinations.
That last detail is worth noting. Individual tools can be safe, while combinations are not. An agent with access to both a data-reading tool and an external-sending tool can create an exfiltration path that neither tool created alone.
The platform reportedly supports no-code agents, customer products and Minions, a coding agent used by 95% of Uber’s engineering organization and producing around 1,800 weekly code changes. These are company-reported figures, but they show the point: one shared layer served several very different use cases.
Other Production Examples
Block and Goose
Block co-developed MCP with Anthropic and uses its open-source Goose agent across thousands of employees. Reported time savings reach 50–75% on routine work, with connections to Snowflake, GitHub, Jira, Slack, Google Drive and internal APIs.
Microsoft’s Sales Development Agent
Microsoft reported that its Sales Development Agent used MCP with Dynamics 365 across 61,734 leads from January to November 2025. It reported a 15.1% increase in lead-to-opportunity conversion. This is a vendor’s own result, not an independent test.
SUSE
SUSE combined its Multi-Linux Manager MCP Server with n8n, Revenium and Stacklok. The pairing of workflow automation, usage billing and security tooling shows how the surrounding ecosystem is filling in.
A Forbes-reported workflow claimed 18,000 saved hours annually and doubled landing-page conversion by reducing developer dependency. I would treat single-source claims like this with caution.

Identity and Authorization: The Hard Part
The question every security team asks: when an agent calls a tool, whose permissions apply? The user’s? The agent’s? A shared service account? Shared service accounts are the fastest route to an audit finding.
Enterprise-Managed Authorization addresses this. It reportedly stabilized around identity-token exchange and centralized identity-provider control, with scoped grants and auditability. The idea is that your existing IdP decides which MCP servers a user or agent may reach, rather than each server running its own login.
Principles worth adopting now
- Act on behalf of the user. Agent actions should carry the end user’s identity and be limited to that user’s rights.
- Grant narrow scopes. Read-only by default. Write access per tool, with approval for destructive actions.
- Log every call. Record who, which agent, which tool and what arguments.
- Review tool combinations. Assess risk across toolsets, not tool by tool.
- Treat tool output as untrusted. Content returned by a server can contain instructions aimed at the model (prompt injection).
What MCP Does Not Fix: Legacy Systems and Data Quality
MCP is a connection standard. It does not make a 20-year-old ERP expose clean data. Analysts note that enterprises still need APIs, data replication, change-data-capture and custom integration layers for legacy systems.
An MCP server over a messy system gives an agent a tidy doorway into a messy room. The agent will still struggle with inconsistent fields, duplicate records and undocumented business rules.

Other operational barriers
An academic enterprise study found MCP useful for cross-system collaboration, task decoupling and knowledge reuse. It also identified ecosystem fragmentation, coordination costs, distributed-state management and fault diagnosis as barriers. Participants asked for better standardization, low-code deployment and operational support.
Debugging is a real issue. When an agent chooses the wrong tool, the cause may be a vague description, not a code bug. Teams need tracing that links the model’s reasoning, the tool call and the downstream system response.
Who Should Own MCP Inside the Company
Ownership is where many programs drift. If every team publishes its own servers, you get sprawl. If one central team must build everything, you get a bottleneck.
A workable split:
- Platform team: owns the gateway, registry, identity integration, logging and standards.
- Domain teams: own the servers for their systems, since they understand the data and the risks.
- Security: sets policy, reviews high-risk tool combinations and monitors usage.
- Product and operations: define which workflows are worth automating.
Treat tool descriptions as a product surface. Version them, test them against realistic prompts and review changes.
A 90-Day Plan to Get Started
Days 1–30: Inventory and guardrails
Find out what already exists. Developers are probably running MCP servers locally. Catalogue them, decide what is acceptable and stand up a registry, even a simple one. Pick an identity approach before building more servers.
Days 31–60: One gateway, two use cases
Deploy a gateway and route everything through it. Choose two internal use cases with low data sensitivity, such as ticket triage or code review assistance. Measure time saved and error rates from the start.
Days 61–90: Expand with review gates
Add domain servers using a standard review checklist: owner, scopes, logging, tool-combination risk and a rollback plan. Publish the results internally, including failures.
Conclusion: The Layer Is Forming, the Discipline Is Optional
MCP is becoming the enterprise integration layer for agents because it solves a real multiplication problem, has neutral governance and now behaves like normal infrastructure. The evidence is mixed in quality, but the direction is clear.
The protocol alone will not make your deployment safe or useful. The winners will be the organisations that build the gateway, registry and identity controls early, and that fix their underlying APIs and data.
Actionable takeaways
- Inventory every MCP server in use today and assign an owner to each.
- Put a gateway in front of everything before scaling usage.
- Tie agent identity to your existing identity provider and default to read-only.
- Review tool combinations, not just individual tools.
- Do not expect MCP to fix legacy systems; budget for APIs and data work.
- Treat tool descriptions as product and test them.
- Verify vendor-reported figures before using them in business cases.

Leave a Reply