Skip to content

Model Context Protocol (MCP): Connecting Agents the Standard Way

Once an organisation runs more than one AI agent, the same question keeps coming back: how does the agent reach the ERP, the service desk, the document store? The Model Context Protocol (MCP) answers it with a shared standard. This guide looks at MCP from the point of view of an IT leader or enterprise architect: where it fits, what it competes with, and what it takes to operate. Everything here reflects the state of play in November 2026 and MCP specification revision 2026-07-28.

What is MCP, and what do organisations use it for?

MCP is an open protocol that lets AI applications use tools, data and templates exposed by other systems. An MCP server publishes a system's capabilities once, and any MCP-capable agent can use them. In practice, MCP becomes the integration layer between your agents and your line-of-business systems.

The specification draws the comparison with the Language Server Protocol, which gave every code editor a common way to support programming languages. MCP does the same for connecting context and tools to AI applications. For an IT department, that changes the unit of work: you integrate a system once, not once per agent and once per AI vendor.

Common uses in mid-sized and large organisations:

  • Read access to knowledge: manuals, inspection reports or product data in SharePoint or a document management system, so an agent can answer questions with citations.
  • Actions in business systems: opening a ticket, checking a delivery status, saving a draft quotation in the ERP.
  • Developer tooling: repositories, CI pipelines and databases for coding agents.
  • Shared services: calendars, email, directories, approval workflows.

Since December 2025 MCP has not belonged to a single vendor. According to the Linux Foundation announcement, Anthropic contributed the protocol to the newly formed Agentic AI Foundation. For a decision with a multi-year horizon, neutral governance matters.

How is MCP structured? The building blocks for architects

MCP defines three roles: the host (the AI application, such as a chat assistant or a back-end agent), the client (the connector inside the host) and the server (which exposes a system's capabilities). Messages use JSON-RPC 2.0. Since revision 2026-07-28, every request is self-contained.

According to the specification, a server can offer three kinds of building block:

Building blockUsed byExample
Toolsexecuted by the model"create ticket", "check stock level"
Resourcesthe user or the modela product data sheet, a test report
Promptstemplates for users"summarise this complaint"

One change in the current revision matters more to architects than to developers. The changelog for 2026-07-28 makes MCP stateless: no initialisation handshake and no session IDs. Each request carries its own protocol version and client capabilities. Servers that need state across calls issue their own handles, passed back as ordinary tool arguments.

What this means for operations:

  • Scaling: stateless servers can run behind a load balancer without pinning a caller to one instance.
  • Caching: tool, resource and prompt lists now carry a freshness hint (ttlMs) and a cache scope (cacheScope), so clients and intermediaries can cache them deliberately.
  • Long-running work: asynchronous tasks have moved into an official extension that works by polling.
  • Asking the user for more input: a server returns an "input_required" interim result, and the client retries the request with the answers.

If your engineers need the implementation details, such as transports, SDKs and server code, point them to MCP for developers: servers, clients and security. That guide covers how to build a server; this one covers where MCP belongs in your landscape and how to govern it.

MCP, A2A or a direct API: which one when?

MCP connects one agent to tools and data. A2A connects independent agents to each other. Calling an API directly from agent code is the simplest choice while exactly one agent uses exactly one system. The right answer depends on how many agents, systems and teams are involved.

The A2A project puts the distinction this way in its own documentation: MCP is "vertical" and deepens what a single agent can do, while A2A is "horizontal" and connects agents across team or organisational boundaries. The A2A specification has reached version 1.0.0; its core concepts are the Agent Card, a self-description an agent publishes, and the Task, a stateful unit of work.

CriterionDirect API in the agentMCP serverA2A
Connectsone agent to one systemany agent to one systemagents to agents
Effort, 1 agent and 1 systemlowmediumnot a fit
Effort, many agentsgrows with each agentonce per systemonce per agent
Stateinside agent codestateless, explicit handlestasks with a lifecycle
Typical useprototype, one-offenterprise integration layercollaboration across teams or partners

A pragmatic rule of thumb:

  • Direct API while a single prototype is proving that a use case works. Moving to MCP later is manageable if the functions are cleanly wrapped.
  • MCP as soon as a second agent or a second AI product needs the same system, or when you want to offer tools inside off-the-shelf assistants and coding agents.
  • A2A when an agent hands work to another agent that someone else runs, for example a partner's agent that you treat as a counterpart rather than a tool.

The protocols are not exclusive. An agent can accept work over A2A and use MCP internally to reach the ERP.

What does an enterprise MCP landscape look like?

A workable landscape consists of servers cut along business domains, one identity provider for sign-in, a catalogue of approved servers and shared logging. The cut is what matters most: one server per business domain, not one per database table and not one server for everything.

Cut servers along domains

A "customer service" server with tools such as search_tickets, create_ticket and read_maintenance_history is easier for an agent to use correctly than a generic database connector. The clearer a tool's name, description and input schema, the more reliably the model picks it. The cut also settles ownership: the team that runs the business system should own its MCP server.

Build, adopt or buy

Besides building your own servers, you can adopt publicly available ones, such as those listed in the official MCP Registry. That turns into a familiar make-or-buy decision:

  • A server from the system's vendor, where one exists, saves development effort but comes with whatever scope the vendor chose, which may be wider than you need.
  • Community servers are quick to try but deserve the same scrutiny as any third-party software: provenance, maintenance, permissions, dependencies.
  • Your own servers make sense for in-house systems, for sensitive data, and wherever you want to keep the tool surface deliberately small.

Catalogue and approval

The official MCP Registry lists publicly available servers and checks at publication time that the publisher controls the namespace, for example via GitHub or a domain. Its repository describes it as still in preview. For enterprise use it does not replace your own approval process: keep an internal catalogue that records each approved server with its version, owning team, permission scope and data classification.

Local or central?

MCP servers can run locally on a user's machine (the stdio transport) or centrally over HTTP. Local servers are convenient for developer tools but escape central control. For business systems holding company data, central hosting is usually the better choice, because sign-in, logging and updates happen in one place.

How do you secure MCP servers?

For centrally hosted servers, the specification defines sign-in based on OAuth 2.1. The MCP server acts as a resource server and only accepts tokens issued for it. Add least-privilege permissions, human approval for write actions, and a default assumption that tool descriptions may not be trustworthy.

According to the authorisation specification, authorisation is optional, but HTTP-based servers that implement it should follow the spec. Four points matter for architects:

  • Identity provider integration: the MCP server advertises its authorisation server through standard metadata (RFC 9728). That can be your existing identity provider, provided it supports the required OAuth features.
  • Audience-bound tokens: clients must name the server a token is meant for (RFC 8707), and servers must not accept or pass on tokens issued for other services.
  • Incremental permissions: the specification recommends starting with minimal scopes and requesting more only when an action actually needs them.
  • Local servers: with stdio, credentials come from the environment rather than an OAuth flow, which makes secrets on employee laptops a governance issue.

The security best practices describe the typical attacks in concrete terms: token passthrough, server-side request forgery through manipulated metadata URLs, hijacked state handles and compromised local servers. For local servers they recommend, among other things, showing the full start-up command, requiring explicit consent and running servers in a sandbox with minimal privileges.

One point is about mindset rather than mechanics. The specification states that tools represent arbitrary code execution and that tool descriptions should be treated as untrusted unless they come from a trusted server. An agent that combines servers from several sources can be steered into unintended actions through manipulated descriptions or content. Put write actions and anything with real consequences behind human approval.

How do you run MCP servers over time?

An MCP server is a service like any other: it needs an owning team, versioning, monitoring and a plan for protocol updates. The current specification helps with OpenTelemetry trace conventions, a formal deprecation policy and a version check on every request.

Protocol versions and deprecations

MCP is still moving. Revision 2026-07-28 removed sessions and the handshake and deprecated several features, including sampling, roots and logging. The same revision introduced a feature lifecycle policy under which deprecated features remain available for at least twelve months and are tracked in a dedicated registry. Plan SDK upgrades as recurring maintenance, not as exceptions.

Every request states its protocol version, and a mismatch produces a specific error. Servers must also implement server/discover, which lets clients learn the supported versions up front. That makes it easier to run old and new clients side by side during a migration.

Observability

The specification now documents how to pass OpenTelemetry trace context (traceparent, tracestate, baggage) in request metadata. That lets you follow an agent run from the user's request through the model call to the tool call in the business system. At a minimum, log which agent acted, on whose behalf, which tool it called, with which parameters, and what came back.

Ownership and change

When a tool's name, description or input schema changes, the behaviour of every agent using that server changes too. Treat such edits as interface changes, with versioning, notice and a test run against the affected agents. In our own operations we review tool descriptions in the same pull request as the code, because small wording changes can noticeably shift which tool the model chooses.

What do you need in place before adopting MCP?

The technical bar is low: a system with a reachable interface and somewhere to run the server. The real prerequisites are organisational: clear ownership of servers, an identity provider that supports OAuth, a data classification scheme, and a rule for which actions an agent may take without approval.

  • Interfaces: the business system needs an API, a database connection or another programmatic route. Systems that can only be driven through a user interface are hard to connect cleanly.
  • Identity: a central identity provider through which agents act on behalf of users or as service accounts.
  • Data classification: which data may an agent read, and which may it send to an external model? This also shapes whether you run models in the cloud or as sovereign AI on your own infrastructure.
  • Operating model: who runs the servers, who monitors them, who approves new ones?
  • Employee representation and privacy: if agents process employee data or log activity, involve works councils or employee representatives (where your jurisdiction has them) and your data protection officer early. This is orientation, not legal advice.

Step by step: from a first server to an MCP platform

Start with one use case and one read-only server, check whether the agent chooses the right tools, and only then add write actions and more servers. Platform concerns such as a catalogue, a gateway and central logging matter from the second or third server onwards, not before.

  1. Pick a use case: a concrete process, for example answering questions about the maintenance status of installed equipment in technical service. Write down the goal and success criteria first.
  2. Shape the tools: which three to five functions does the agent really need? A few well-described tools beat a full mirror of the API.
  3. Start read-only: the first server only reads. That keeps risk low and quickly shows whether data quality and tool descriptions hold up.
  4. Sign-in and logging from day one: even the pilot uses the real identity provider and traceable logs, so moving to production is not a rebuild.
  5. Write tools with approval: once the read side is stable, add tools that change things, with confirmation from a person.
  6. Catalogue and rules: from the second server onwards, keep an internal catalogue and agree rules for approval, versioning and deprecation.
  7. Reuse: new agents use existing servers instead of building their own integrations. This is where MCP pays off as an architecture decision.

Limits and risks: when is MCP the wrong choice?

MCP is an integration layer. It does not fix poor data, unclear processes or missing interfaces. For a single agent talking to a single system, a direct integration is often simpler. And every extra server widens the attack surface if permissions and approvals are loosely managed.

  • Too many tools: the more tools an agent sees at once, the harder it is for the model to choose well, and the more context the descriptions consume. Curate which servers each agent gets.
  • A moving protocol: the specification has changed substantially between revisions, most recently by dropping sessions. Older servers and clients need upgrading.
  • Uneven client support: capabilities are negotiated per request, and not every client supports every building block. Check what your target applications actually use before you build.
  • Untrusted servers: servers from unknown sources run with whatever rights you grant them. Without review and isolation they are an entry point.
  • No substitute for process design: an agent that reaches the ERP through MCP is only as good as the process it supports. If nobody knows who decides what, a good interface will not help.

How do you get started with MCP?

Begin with an inventory: which systems should agents use, which already have an API, and which already have a public MCP server? Pick one use case with manageable risk from that list and build a read-only server with real sign-in.

Useful next steps:

  • For a short definition, see the glossary entry What is Model Context Protocol (MCP)?.
  • For your engineering team: transports, SDKs and server code in MCP for developers. The difference from this guide: that one is about how to build, this one is about where and why in your architecture.
  • Look at use cases with high reuse, such as knowledge management or technical service, where several agents work with the same documents and systems.
  • For an overview of what agents can do across the organisation, see AI agents.

If you want to anchor responsibility for AI in your organisation rather than run isolated projects, the fractional head of AI model is one way to do it.

Frequently asked questions

Who governs MCP today?

Anthropic contributed MCP to the Agentic AI Foundation, hosted by the Linux Foundation, in December 2025. The specification now evolves through a public proposal process known as SEPs.

Does an MCP server replace our REST APIs?

No. An MCP server usually sits in front of an existing API and turns selected functions into tools an agent can use. Every other application keeps using the API directly.

How long do deprecated MCP features keep working?

Revision 2026-07-28 introduced a lifecycle policy that keeps deprecated features available for at least twelve months. Treat SDK and protocol updates as routine maintenance rather than one-off projects.

Should we publish our servers in the official MCP Registry?

Only if they are meant for public use. The registry is a catalogue of publicly available servers and, according to its repository, still in preview. Internal servers belong in your own catalogue.

Do we need A2A as well as MCP?

Only if your agents delegate work to other independently run agents. MCP connects an agent to tools and data; A2A connects agents to each other, and many architectures end up using both.

Sources

  1. Model Context Protocol – Specification (Revision 2026-07-28) modelcontextprotocol.io
  2. MCP Specification – Key Changes 2026-07-28 modelcontextprotocol.io
  3. MCP Specification – Authorization modelcontextprotocol.io
  4. MCP – Security Best Practices modelcontextprotocol.io
  5. A2A Protocol – A2A and MCP a2a-protocol.org
  6. Agent2Agent (A2A) Protocol Specification a2a-protocol.org
  7. Official MCP Registry (GitHub) github.com
  8. Linux Foundation – Formation of the Agentic AI Foundation linuxfoundation.org