What is MCP? A business leader’s guide to Model Context Protocol

MCP is an open standard for connecting AI applications to external tools and data. It can reduce integration fragmentation, but it does not replace APIs or decide what an agent should be allowed to do.

Decision brief

In brief

A business leader’s guide to Model Context Protocol. KOR explains how MCP connects AI applications to tools and resources, how it differs from APIs and RAG, what changed in the 2026 specification and why standardised connectivity still requires enterprise identity, permissions and governance.

Signal
AI applications increasingly need access to the same enterprise data, tools and services, while bespoke integrations create repeated technical and governance work across platforms.
Implication
MCP can standardise part of that connection layer, but organisations can create a larger attack and control surface if reusable connectivity is mistaken for reusable trust or unrestricted authority.
Decision
Treat MCP as shared integration infrastructure: decide which capabilities should be exposed, through which servers, under which identities and scopes, with what supplier assurance, approvals and observability.

An organisation has approved several AI platforms.

Each needs access to some combination of contracts, policies, supplier records, support systems, internal knowledge and workflow actions.

Without a common integration pattern, the architecture begins to multiply.

One AI application needs a bespoke connection to the contract repository. Another needs its own connector to the same repository. A third needs a separate integration to the procurement platform. Security teams review similar access patterns repeatedly. Suppliers implement the same capabilities differently. Switching the model or AI interface can mean rebuilding parts of the connection layer.

Model Context Protocol — MCP — is an attempt to standardise part of that problem.

The current MCP documentation describes it as an open standard connecting AI applications to the systems where data and tools live. Rather than every AI application inventing a proprietary mechanism for discovering and invoking external capabilities, an MCP server can expose them in a common form that compatible AI hosts can use.

That makes MCP strategically important. It also makes it easy to overstate.

MCP is not an AI model. It does not make a system agentic. It does not replace the underlying API, application or identity system. It does not decide whether a tool is safe, whether data is accurate or whether an agent should be allowed to perform an action.

KOR’s central argument is:

MCP standardises connectivity. It does not standardise trust, authority or business judgement.

For enterprise leaders, that is the useful place to start.

In brief

Signal: AI platforms increasingly need access to the same enterprise tools, data and services, while one-off integrations create repeated technical and governance work.

Implication: MCP can make capabilities more reusable across AI applications, but reusable connectivity can also make poorly governed capabilities easier to reach.

Decision: Treat MCP as shared integration infrastructure. Define which capabilities should be exposed, who may use them and how each action is authorised, observed and controlled.

What is Model Context Protocol?

Model Context Protocol is an open standard for connecting AI applications to external data sources, tools and services through a common protocol.

Anthropic introduced MCP in November 2024 as an open standard for connecting AI assistants to systems where data lives. In December 2025, Anthropic donated MCP to the Linux Foundation’s Agentic AI Foundation, co-founded with Block and OpenAI and supported by a wider group of technology companies.

The protocol has continued to develop under open governance. The current specification release is 2026-07-28.

At a business level, MCP creates a common way for an AI host to discover and use capabilities made available by an MCP server.

The server may sit in front of an existing application, database, API or service. It exposes the relevant capability in a form the AI system understands.

This is why MCP should be thought of as an interoperability layer rather than a replacement for enterprise systems.

The basic architecture

The technical implementation can become detailed, but the business architecture is straightforward.

The AI host

The host is the application in which the AI capability operates.

That might be an enterprise assistant, coding environment, agent platform or a custom application.

The host is responsible for the user experience and for coordinating the AI system’s access to connected capabilities.

The MCP connection

The MCP client side communicates with one or more MCP servers using the protocol.

The protocol standardises how capabilities are described and invoked, along with supporting behaviours such as discovery, authorisation and transport.

The MCP server

The server exposes selected capabilities from an underlying system.

Current MCP SDK documentation describes servers exposing tools, resources and prompts.

A server might expose a contract-search capability, supplier-data retrieval, an approved calculation, a workflow action or access to a knowledge source.

The important point is that the server should expose the capability the organisation intends the AI application to use — not automatically everything the underlying system can do.

The underlying enterprise system

MCP does not make the underlying system disappear.

The ERP platform, document repository, CRM, procurement suite, database or internal service still exists. Its own APIs, permissions, data model and controls remain relevant.

MCP sits above or alongside those capabilities and presents them through a common AI-facing protocol.

What is MCP? A business leader’s guide to Model Context ProtocolA business leader’s guide to Model Context Protocol. KOR explains how MCP connects AI applications to tools and resources, how it differs from APIs and RAG, what changed in the 2026 specification and why standardised connectivity still requires enterprise identity, permissions and governance.A KOR proposed framework for diagnosis and implementation; use it as a decision aid rather than a universal standard.

What MCP is trying to solve

The integration problem becomes more visible as organisations use several AI applications.

Suppose five AI applications need controlled access to contract, supplier and finance capabilities.

Without a common interface, each product may need its own connector design, authentication implementation, capability description and maintenance process.

MCP creates the possibility of making a capability reusable across compatible hosts.

A well-designed contract MCP server, for example, could expose approved contract-search and retrieval tools in a consistent form. Several authorised AI applications could then use that server rather than each team designing the same capability independently.

The value is not that custom work disappears.

Someone still has to connect the server to the underlying system, map the data, configure identity, decide which capabilities are exposed, maintain the server and test changes.

The difference is that the AI-facing interface can become more standardised.

That can improve portability and reduce repeated integration work where the use case genuinely reuses the same enterprise capabilities.

Tools, resources and prompts

MCP includes several ways for servers to expose capability. Business leaders do not need to memorise the protocol methods, but the distinction helps explain the operating model.

Tools

Tools allow the AI application to invoke an operation.

A tool might search a supplier database, retrieve a contract, calculate a value, create a ticket or initiate a workflow action.

Tools are where MCP becomes operationally consequential because they can move from information access into system action.

A tool description therefore has governance significance. It should be clear what the tool does, what inputs it accepts, what identity is used and what downstream action occurs.

Resources

Resources expose information that the AI application can read.

These might represent documents, reference data, records or other context.

Resource access still requires data-governance decisions. The fact that a server can expose a resource does not mean every model, user or agent should receive it.

Prompts

Prompts can provide reusable instructions or interaction templates exposed by the server.

They can help standardise how particular capabilities are used, but they should not be confused with enforceable control. A prompt can guide behaviour; permissions and technical constraints determine what the system is actually able to do.

What changed in the 2026 MCP specification

The protocol has moved quickly, so older descriptions can already be misleading.

The 28 July 2026 specification introduced a major architectural revision. The MCP maintainers moved the core towards stateless request/response operation, so individual requests can be handled without relying on a persistent protocol session.

The release also added or strengthened several production-oriented features:

  • method and tool information in HTTP headers to support routing and policy enforcement;
  • cache hints for capability lists and resource reads;
  • authorisation hardening aligned more closely with established OAuth and OpenID Connect patterns;
  • an extensions framework for capabilities that can evolve outside the core protocol;
  • updated support for long-running work through the Tasks extension;
  • formal deprecation rules and conformance expectations.

These changes matter because they make MCP easier to operate on conventional enterprise infrastructure and create clearer hooks for gateways, identity and observability.

They do not mean an MCP deployment is secure by default.

Security still depends on the server implementation, downstream system, identity design, scopes, tool behaviour, host controls and operational monitoring.

MCP is not the same as an API

This is one of the most common points of confusion.

An API defines how software interacts with a service.

An ERP API may allow software to retrieve suppliers, create purchase orders or query invoices. A contract platform API may allow search, upload and metadata updates.

MCP can sit on top of those APIs and expose selected capabilities in a standard form for AI applications.

The API remains the underlying service contract. MCP provides an AI-oriented interoperability layer.

In some cases, an MCP server may call an API. In others it may interact with a database, filesystem, local application or another service directly.

The practical distinction is:

APIs expose application capability. MCP standardises how AI applications discover and use selected capability.

MCP therefore does not make APIs obsolete. In many enterprise architectures it depends on them.

MCP is not the same as RAG

Retrieval-augmented generation — RAG — is a pattern for retrieving relevant information and supplying it to a model so that the model can answer using external context.

MCP is a protocol.

An MCP server can expose a search or retrieval tool that participates in a RAG workflow. It can expose resources that an AI host reads. But MCP itself does not define the retrieval strategy, ranking model, embedding approach or grounding quality.

RAG answers how relevant information is retrieved and used for generation.

MCP answers how an AI application can interact with an external capability through a standard protocol.

They can work together without being alternatives.

MCP is not the same as an agent

An agent is an AI system that can choose among actions or tools in pursuit of an objective.

MCP can make tools available to that agent.

It does not decide which tool the model selects, how the task is planned, how long the system persists, what state it retains or when human approval is required.

This is why MCP belongs inside the wider agentic AI architecture rather than defining it.

ConceptPrimary roleWhat it does not decide
APIExposes application/service capabilityHow an AI system should reason or orchestrate work
MCPStandardises AI-facing access to tools/resources/capabilitiesWhether access is appropriate or which action should be chosen
RAGRetrieves relevant external information for model contextGeneral action authority or cross-system tool use
AgentChooses and performs permitted steps towards an objectiveUnderlying integration standards or enterprise permission policy

Standard connectivity does not equal standard trust

The strategic advantage of MCP is also the reason it requires governance.

If a capability becomes easier to reuse across AI hosts, an organisation needs confidence that the capability is appropriate to reuse.

A server is not trustworthy simply because it implements an open protocol.

The organisation still needs to establish:

  • who built and operates the server;
  • which underlying systems it connects to;
  • what data can pass through it;
  • which tools it exposes;
  • how the server authenticates clients and users;
  • what permissions reach the downstream service;
  • whether tool calls are scoped to the user, the agent or a shared service identity;
  • how activity is logged and traced;
  • how server and tool changes are controlled;
  • what happens if the server is compromised or unavailable.

This is where the protocol becomes an operating-model question rather than a developer preference.

Identity and authorisation are central

The current MCP specification has continued to strengthen its authorisation model, but enterprise identity architecture still has to decide who is acting.

Consider an agent that uses an MCP tool to update a supplier record.

Is the action performed as the employee who requested the work?

As a service account?

As a distinct agent identity?

Does the downstream system know which person authorised the action?

Can the agent update every supplier the user can see, or only the supplier relevant to the task?

Can a high-risk action trigger a stronger authorisation step?

These are not protocol vocabulary questions. They are authority questions.

NIST’s 2026 work on software and AI-agent identity similarly focuses on identification, authorisation, auditing and non-repudiation. MCP gives enterprises another place where those principles have to be implemented coherently.

Tool descriptions become part of the control surface

Agentic systems often decide which tool to use based partly on the tool’s name, description and schema.

That makes tool design more consequential than a conventional hidden backend function.

A vague tool labelled manage_supplier creates a poor reasoning boundary.

Separate tools such as read_supplier_profile, request_supplier_update and approve_supplier_bank_change make authority clearer and allow different controls to be attached to each action.

The principle is simple: expose the narrowest useful capability.

A technically convenient tool that bundles read, write and approval authority may create unnecessary risk.

MCP expands supplier-assurance questions

MCP will increasingly appear inside products bought from third parties.

A supplier may provide an MCP server for its application. An AI platform may connect to external MCP servers. A service provider may operate servers on the customer’s behalf.

Procurement therefore needs to understand where responsibility sits.

KOR’s AI Supplier Due Diligence framework already asks buyers to identify the wider AI value chain rather than assessing only the contracted supplier. MCP adds another component to that chain.

Relevant questions include:

  • Is the MCP server first-party, third-party or customer-operated?
  • Which specification version and SDK are in use?
  • How are security updates and deprecations managed?
  • Which tools and resources are exposed by default?
  • Can administrators disable individual capabilities?
  • How are OAuth clients, tokens and scopes managed?
  • What telemetry is available to the customer?
  • Does the supplier support central gateway or policy controls?
  • How are changes to tool schemas or behaviour notified?
  • What happens to downstream access when an employee or agent loses permission?

The presence of MCP should increase architectural transparency, not become a shorthand answer to these questions.

MCP can help — and complicate — Shadow AI

MCP can make it easier for authorised AI systems to reach approved enterprise capabilities.

That can support governed adoption by reducing the incentive for teams to create unofficial point integrations.

It can also make it easier for employees or local builders to connect AI tools to organisational systems if server discovery and credentials are poorly controlled.

KOR’s Shadow AI work therefore extends naturally into MCP governance. The concern is no longer only which chatbot employees use. It includes which external capabilities that AI can reach and what it can do with them.

A useful MCP strategy needs both enablement and visibility.

The enterprise opportunity is a governed capability layer

Used well, MCP creates the possibility of designing reusable, approved enterprise capabilities for AI systems.

Instead of every team exposing a separate “search contracts” integration, the organisation can define one governed contract-search capability with known data scope, identity controls and observability.

Instead of several agent platforms implementing different supplier lookups, a common supplier-information server can expose a narrow read interface.

This does not mean every system should have an MCP server.

The architecture is strongest when the capability is genuinely reusable and the organisation can own or govern the interface over time.

A practical MCP governance model

KOR recommends treating each MCP capability through six control decisions.

1. Purpose

What business capability is being exposed, and why should AI systems need it?

A server should not exist merely because the underlying application can support one.

2. Provenance

Who built, operates and maintains the server and its dependencies?

Open protocol does not mean open implementation.

3. Identity

Which human, service or agent identity is used for each connection and action?

The organisation should be able to attribute material activity.

4. Permission

What can the capability read or change?

Scope tools narrowly and apply least privilege.

5. Approval

Which operations can execute directly and which require user confirmation or another control gate?

Approval should reflect action consequence rather than being added uniformly.

6. Observability

What can administrators see about discovery, connection, tool use, errors and downstream actions?

A reusable integration layer should make governance easier to operate, not create a new blind spot.

What leaders should ask before adopting MCP

MCP is already relevant even if your organisation has not deliberately selected it.

AI vendors, development tools and agent platforms increasingly support MCP, which means it may enter the environment through products already being assessed or used.

Leaders should therefore establish four things.

First, where MCP is already present. This belongs in technology and Shadow AI discovery.

Second, which enterprise capabilities are worth standardising. Focus on repeatable, governed interfaces rather than creating servers for every system.

Third, what the authority model is. Standardised connectivity should not produce standardised over-permission.

Fourth, who owns the shared layer. Platform engineering, security, enterprise architecture, AI governance and business functions may all have responsibilities. Procurement has an important role where external suppliers provide or depend on MCP infrastructure.

The protocol is infrastructure, not the operating decision

MCP matters because AI systems are becoming more connected.

A common protocol can reduce fragmentation and make tools and resources easier to reuse across compatible AI applications. The 2026 specification has also moved the protocol towards the operational characteristics enterprises expect from shared infrastructure: scalable request handling, clearer routing, stronger authorisation foundations, extensions and observability support.

None of that answers the most important business question: what should an AI system be allowed to do?

That remains an organisational decision.

The useful enterprise approach is therefore to separate the layers.

Use MCP where a standard AI-facing interface improves portability or reduces repeated integration work. Keep the underlying APIs and systems governed. Treat each server as a supplier and security dependency. Scope tools narrowly. Apply identity and permissions deliberately. Require approval for consequential actions. Maintain visibility over the connections that exist.

MCP can make the enterprise AI stack easier to connect. Human judgement and implementation discipline still determine whether that connected stack is safe and commercially useful.

References

  1. 01donated MCP to the Linux Foundation’s Agentic AI Foundation · Research source · accessed 2026-09-19
  2. 02Model Context Protocol — 2026-07-28 specification release · Research source · accessed 2026-09-19
  3. 03Model Context Protocol — TypeScript SDK v2 documentation · Research source · accessed 2026-09-19
  4. 04Model Context Protocol — August 2026 roadmap · Research source · accessed 2026-09-19
  5. 05NIST — AI Agent Standards Initiative · Research source · accessed 2026-09-19
  6. 06National Cyber Security Centre — Thinking carefully before adopting agentic AI · Research source · accessed 2026-09-19