The Model Context Protocol (MCP) is an open standard for connecting AI applications to the systems where your data and actions live. You describe a system once, as an MCP server, and any compatible assistant or agent can use it, so you stop building one integration per model per tool. It standardises the wiring but does not decide what an agent should be allowed to do, and that part remains your job.
What is MCP, in plain words?
A language model can only read and write text. To be useful inside a company it has to look things up and do things: find a customer record, read a contract, raise a ticket. Each of those needs a connection between the AI application and another system.
MCP is an agreed format for that connection. The specification describes it as an open protocol for integrating LLM applications with external data sources and tools, and says it took inspiration from the Language Server Protocol, which let one piece of language tooling work across many code editors. Anthropic published MCP in November 2024, and it has since become the usual way for assistants and agents to plug into other software.
The comparison we use with non-technical teams is the card terminal in a shop. The shop does not install a separate reader for each bank. Cards and terminals follow one standard, so any card works in any terminal. MCP tries to do the same for AI applications and business systems.
What problem does it solve?
Take a property-management company with five systems that matter: tenancy records, maintenance tickets, accounting, a document store and email. It uses three AI applications: a general assistant for staff, a chatbot for tenants and a coding assistant for its developers.
Without a standard, each application needs its own connector to each system, written for that application’s particular way of defining tools. Three applications times five systems is fifteen integrations to build, secure and keep working as both sides change. Replace the staff assistant with another vendor’s product and five of them are rewritten.
With MCP, each system gets one server. That is five pieces of work. Each AI application contains an MCP client, which its vendor has already written. A new application can use all five systems on the day it arrives, and a new system reaches all three applications through one more server.
That is the whole commercial argument. Integration effort grows by addition instead of multiplication, and your integrations stop being tied to one model vendor.
What it does not do is equally worth knowing. MCP does not make a model better at choosing tools. It does not check that an action is sensible. And connecting twenty servers to one assistant makes it worse, because every tool description takes up room in the model’s context and gives it another way to pick the wrong one.
Servers, clients, tools and resources
The vocabulary is small.
- Host: the AI application a person or process uses, such as a desktop assistant, a code editor or an agent you built.
- Client: the connector inside the host that speaks MCP to one server.
- Server: a program that sits in front of a system and describes what that system offers.
A server can offer three kinds of thing. In the spec’s words, tools are ‘functions for the AI model to execute’, resources are ‘context and data, for the user or the AI model to use’, and prompts are ‘templated messages and workflows for users’. Tools get nearly all the attention, because they are what lets an agent act.
A tool is a name, a description the model reads, and a schema for its inputs:
{
"name": "get_tenancy_balance",
"description": "Return rent due, rent paid and arrears for one tenancy. Use the tenancy reference, not the property address.",
"inputSchema": {
"type": "object",
"properties": { "tenancy_ref": { "type": "string" } },
"required": ["tenancy_ref"]
}
}
The description matters more than people expect. It is all the model knows about the tool, so a vague one produces wrong calls.
Servers run in one of two ways. A local server runs on the user’s own machine and talks to the host over standard input and output, which suits developer tools and anything that touches local files. A remote server runs as a web service over what the spec calls Streamable HTTP, behind a login. That is the form you want for company systems used by many people, and it needs the same care as any other service you host: secrets, monitoring and a deployment pipeline, the ordinary cloud and DevOps work.
Where does MCP stand in late 2026?
Four things have changed since the early days, and each affects a decision you may be making.
A neutral home
In December 2025 Anthropic donated MCP to the Agentic AI Foundation, a new body under the Linux Foundation, alongside projects contributed by Block and OpenAI. The founding announcement lists AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft and OpenAI as platinum members, and names Claude, Cursor, Microsoft Copilot, Gemini, VS Code and ChatGPT among the products that had adopted the protocol. For a buyer the point is simple: MCP is no longer one vendor’s format, and the products of the largest model providers all support it.
A simpler, stateless protocol
The current revision of the specification is dated 28 July 2026 and replaces the one from November 2025. Its changelog is mostly about removing things. The opening handshake and protocol-level sessions are gone, so every request is self-contained. Servers must answer a discovery call stating which versions and capabilities they support. Long-running work has moved into an optional tasks extension. Several older features (roots, sampling, protocol-level logging and the original HTTP+SSE transport) are deprecated, under a new policy that gives at least twelve months’ notice before anything is removed.
If you are commissioning a server now, two consequences follow. Remote servers are easier to host, because a request no longer depends on which machine handled the previous one. And anything built against a 2025 revision needs a migration plan, so ask every vendor which revision their server speaks.
Authorisation based on OAuth
For remote servers the spec defines an authorisation model built on OAuth 2.1. The MCP server is treated as a protected resource, an authorisation server (which can be your existing identity provider) issues the tokens, and the server must check that each token was issued for it specifically. Authorisation is optional in the protocol. For anything that holds company data, treat it as required. Local servers do not use this flow and take their credentials from the environment they run in.
A registry, still in preview
There is an official MCP Registry, a central catalogue of publicly available servers. At the time of writing, its own documentation says it is in preview and may change before general availability. It stores metadata that points to packages or remote URLs, verifies that a publisher controls the namespace it publishes under, and leaves security scanning to the package registries and to the marketplaces built on top of it. It does not list private servers. A company that wants an approved internal catalogue runs its own registry.
What are the security risks?
MCP makes it easy to give a model new abilities, and that ease is the risk. The spec is candid about it: tools ‘represent arbitrary code execution and must be treated with appropriate caution’, and the protocol ‘cannot enforce these security principles at the protocol level’. The host application and the people deploying it carry the responsibility.
The problems we see fall into four groups.
Over-broad tools. A server that exposes run_sql or a send-any-email tool hands the model everything the underlying account can do. Expose narrow tools, give the server its own credentials with the least access that works, and keep read tools apart from write tools so the host can demand approval for the second kind.
Untrusted servers. Installing a local server means running someone else’s code on your machine with your permissions. The official security guidance describes malicious start-up commands hidden in one-click install configurations, and requires clients to show the exact command before running it. A registry listing tells you who published a server. It does not tell you the server is safe. Keep an allow-list, pin versions, and read the tool list of anything you connect.
Instructions hidden in content. Whatever a tool returns goes into the model’s context: a web page, a support ticket, a calendar invitation. If that text contains instructions, the model may follow them. This is indirect prompt injection. MCP neither causes nor cures it, but every extra server gives an attacker another way in and more tools to misuse. The spec adds that a tool’s own description and annotations should be considered untrusted unless they come from a server you trust. We go through the defences in guardrails for AI agents.
Sloppy token handling. A common shortcut is for a server to take whatever token the client sends and pass it on to the system behind it. The spec forbids this. A server must accept only tokens issued for itself, or you lose both the audit trail and the boundary between services.
None of this is a reason to avoid MCP. It is a reason to give each server what any integration with production access gets: an owner, a review, scoped credentials and logs.
Build an MCP server or integrate the API directly?
MCP is a means of distribution. It pays off when more than one AI application needs the same capability, or when the application is one you do not control. Otherwise a plain function call inside your own agent is simpler and easier to test.
| Your situation | What we would do |
|---|---|
| One agent in your own codebase, one model, two or three internal systems | Call the APIs directly as tools in your code. Add MCP later if a second consumer appears. |
| Staff use bought assistants and want company data inside them | Build a remote MCP server. It is the supported way to extend those products. |
| Several teams or agents need the same system | One MCP server, owned by the team that owns the system. |
| A SaaS vendor already publishes an official server | Use it, after checking its tools and scoping the account it connects with. |
| You sell software and customers ask to use it from their AI tools | Publish a remote server with OAuth, so customers can connect your product to the assistants they already use. |
| A fixed, high-volume pipeline where code decides every step | Plain API integration. No model is choosing tools, so MCP adds nothing. |
On effort: a first server over a documented API is usually days of engineering, not months. The code is the small part. The time goes into choosing which five or six tools to expose out of fifty endpoints, writing descriptions a model reads correctly, setting up authorisation, and testing against the questions real users ask. A server that mirrors every endpoint one for one is quick to generate and performs badly, for the reasons we give in AI agents in production.
Back to the property company. The staff assistant is a bought product, so tenancy and maintenance data reach it through a remote MCP server with single sign-on, starting with read-only tools. The tenant chatbot is their own code talking to the same two systems. It could call the APIs directly, but reusing the server gives one set of permissions and one audit log. The nightly accounting reconciliation stays a normal scheduled job. Three consumers, and a different sensible answer for each.
How to start
In the first week, make an inventory, not a server. List the AI applications people in the company already use and the three systems they most often copy data out of by hand. Where those overlap is your first candidate.
Then decide three things before any code is written: which handful of read-only tools would answer most of those questions, which identity provider will issue tokens, and who owns the server once it is live. Build that small read-only server, connect it to one assistant for one team, and read the logs of what people ask for a fortnight. Write actions come afterwards, one at a time, each with an approval step.
This is routine work for our AI agents and integrations team, and the order above is the one we would follow.