# MCP: the protocol that plugs your systems into agents, its limits, and what it needs around it

> MCP has become the standard for connecting agents to company tools. But the protocol handles neither the catalogue, nor fine-grained rights, nor audit, nor cost: that is the shared foundation’s job.

Source : https://dasein-ai.com/en/articles/mcp · Dasein · Updated 1 October 2026

## In short

- MCP standardises the connection between an agent and a tool: an API becomes usable by any compatible agent.
- The protocol deliberately leaves out operational security, the catalogue, audit and cost.
- Dasein helps put in place the foundation that provides them: registry, gateways, policies and observability, building on what you already have.

## 1. MCP in two minutes

MCP (Model Context Protocol) is an open protocol describing how an agent discovers and uses tools. On one side, an “MCP server” exposes an application’s capabilities: read a ticket, look up a customer, create an order. On the other, the agent connects to that server and immediately knows what it can do, with no custom development.

- **Tools** : Actions the agent can trigger: search, read, create, update.
- **Resources** : Data the agent can look at to build context: documents, records, history.
- **Prompts** : Ready-made instruction templates offered by the server.

Created by Anthropic in November 2024, MCP was handed over in December 2025 to the Agentic AI Foundation, hosted by the Linux Foundation and backed by OpenAI, Google, Microsoft and AWS. The July 2026 version makes the protocol stateless, which finally makes it easier to run behind load balancers.

> MCP does for agents what REST APIs did for applications: a common way to plug in. Not a common way to be governed.

## 2. Why everyone is adopting it

- An existing API can be exposed as an MCP server: it becomes usable by every compatible agent.
- The same connector serves several front ends and agents: no need to redo the integration for each tool.
- The main assistants on the market (ChatGPT, Claude, Copilot, Le Chat, Gemini) already connect to it.
- Companies that already run an API management platform start ahead: their APIs are documented, secured and catalogued.

## 3. What it is used for: three families of use cases

Once systems are exposed as MCP servers, nearly every use case falls into one of three families. They rely on the same servers and the same foundation: only the use case changes, and that is what makes the investment pay off.

*Diagram: Three families of use cases on a shared foundation: querying data, supporting decisions, acting in systems.*

## 4. The limits, one by one

The specification says so itself: MCP cannot enforce security principles at the protocol level. It is not a design flaw, it is a choice of scope. But as soon as you go past the prototype, these gaps have to be filled elsewhere.

| Limit | What can happen | What we put in place |
| --- | --- | --- |
| Untrusted content | A document or ticket contains hidden instructions that the agent follows (prompt injection). | Separate read and write, human approval for any action, content filtering. |
| Poisoned tool descriptions | A server slips instructions into its tool descriptions, or changes them after approval. | Catalogue of approved servers, pinned versions, review of every change. |
| Unofficial servers | In 2025, a popular MCP package was altered to secretly copy every email sent. | Internal hosting, verified images, dependency scanning. |
| Optional authorization | Authentication is not mandatory in the spec, and fine-grained per-tool rights are not part of it. | MCP gateway with per-tool and per-group rights, identity propagation, never passing tokens through. |
| Too many tools | According to Anthropic, 58 tools take about 55,000 tokens before the first question, and accuracy drops. | Expose tools by domain, tool search, per-agent sub-catalogues. |
| No enterprise catalogue | The official registry lists public servers; it does not say which ones are allowed in your company. | An internal registry: approved agents, MCP servers, prompts and skills. |
| No audit, no cost | The protocol defines neither an audit log nor cost tracking: only tracing conventions. | Central observability: every call traced and attributed to an agent and a team. |
| Agent to tool only | MCP links an agent to a tool. For two agents to work together, another protocol is needed: A2A. | A2A gateway and orchestration between agents. |

## 5. The foundation around MCP

The market’s answer is the same everywhere: agents do not talk to MCP servers directly. A single checkpoint sits between them, which knows who is calling what, with which rights and at what cost.

*Diagram: The foundation around MCP: agents go through a registry and gateways before reaching MCP servers and models.*

- **Registry** : The catalogue of everything that is allowed: agents, MCP servers, prompts, skills, models. Each item has an owner, a version and an approval status.
- **MCP gateway** : The mandatory path between agents and MCP servers: authentication, per-tool rights, rate limits, filtering, logging.
- **LLM gateway** : The mandatory path to models: model choice, quotas, cost per team, freedom to switch provider.
- **A2A gateway** : The same control applied to exchanges between agents: which agent may call another, and for what.
- **Policies** : Rules applied to every exchange: personal data masking, rate limits, compliance checks.
- **Observability** : An overview of the agent network: who calls whom, volumes, response times, errors and cost.

> Controls sit in two complementary places: in the gateways, for every agent at once, and in each agent’s middleware, closest to its decisions (human approval, caps, data masking).

## 6. Identity: four ways to link the user to the MCP server

Between the user and the target application, the request goes through an AI gateway, the agent, then an MCP gateway. The real question is: with which identity does the MCP server act, and who checks the rights? Four patterns come up, from the simplest to the finest-grained.

*Diagram: The four ways to carry the user’s identity to the MCP server, through the gateways.*

| Pattern | What the MCP server receives | When to use it | Watch out for |
| --- | --- | --- | --- |
| 1. Technical account plus user context | A technical token issued to the gateway, with a signed user context. The gateway has already checked identity, per-tool rights and quotas. | Internal applications without fine per-user rights; quick start. | The MCP server must trust user context only from the gateway; the application itself sees a technical account. |
| 2. User token passed on | The user’s token, which the MCP server validates itself, rights included. | Same identity provider everywhere, token issued for this MCP server. | The MCP spec forbids accepting a token that was not issued for the server: never pass a token through “as is”. |
| 3. Token exchange | A new token, obtained by the gateway from the identity provider on the user’s behalf, limited to this server and these rights. | The default choice for sensitive data: the application sees the real user, with reduced rights. | The identity provider must support token exchange (OAuth standard, RFC 8693). |
| 4. In-task authorization | A second token, obtained when the user signs in to the target system during the task. | Systems with their own identity provider: SaaS, partners, subsidiaries. | An interruption for the user; tokens to store and revoke properly. |

> In every case the gateway remains the checkpoint: it validates identity, applies quotas and rate limits, and traces every call.

## 7. Three protocols, three links

MCP is only one of an agent’s three links. The other two are being standardised too, with open protocols that complement rather than compete with each other.

*Diagram: Three complementary protocols: AG-UI between interface and agent, MCP between agent and tools, A2A between agents.*

| Link | Protocol | Role |
| --- | --- | --- |
| Agent ↔ user | AG-UI (Agent–User Interaction) | Connects an agent to the application the user sees: live answers, visible tool calls, approval requests. Started by CopilotKit. |
| Agent ↔ tools and data | MCP (Model Context Protocol) | Connects an agent to company applications and data. Started by Anthropic. |
| Agent ↔ agent | A2A (Agent2Agent) | Lets agents from different frameworks or vendors find each other and hand off tasks. Started by Google. |

With A2A, each agent publishes an “agent card”: a small file describing what it can do, where to reach it and how to authenticate. Delegated tasks have a lifecycle (submitted, working, waiting for input, completed…), which supports long-running work with a human in the loop. For governance this is good news: these cards belong in the registry, just like MCP servers.

## 8. The market

Integration vendors, clouds and open-source projects all offer a version of this foundation. The right choice mostly depends on what you already run.

| Solution | Type | Key point |
| --- | --- | --- |
| MuleSoft Agent Fabric | Integration platform (Salesforce) | Agent registry, MCP and A2A connectors, orchestrator, agent network map, policies through the API gateway |
| Kong AI Gateway | API gateway | MCP proxy, OAuth authentication, per-tool rights |
| Azure API Management | Microsoft cloud | Exposes managed APIs as MCP servers, AI gateway policies |
| AWS Bedrock AgentCore Gateway | AWS cloud | Turns APIs and functions into MCP tools behind a single endpoint |
| Cloudflare MCP Server Portals | Zero Trust | Several MCP servers behind one portal, per-user policies, logging |
| Gravitee Agent Mesh | API gateway | LLM, MCP and A2A proxies, agent catalogue |
| LiteLLM | Open source | LLM, MCP and A2A gateway: keys, team rights, quotas, spend tracking |
| IBM ContextForge | Open source | Gateway and registry federating MCP, REST and A2A |
| Docker MCP Gateway | Open source | MCP servers isolated in containers, verified catalogue |
| Microsoft MCP Gateway | Open source | Kubernetes reverse proxy: routing, authorization, server lifecycle |

> If you already manage your APIs with an integration platform, start there: adding MCP to an existing API foundation is often the shortest path. Otherwise, an open-source gateway is enough to get going.

## 9. Where to start

- Pick two or three useful systems and expose their APIs as MCP servers, read-only first.
- Register these servers, the agents and the models in a registry, with an owner for each.
- Route every call through a gateway: identity, per-tool rights, quotas, logging.
- Observe the agent network, and only then orchestrate several agents across an end-to-end process.

## Further reading

- [MCP: specification (2026-07-28)](https://modelcontextprotocol.io/specification/2026-07-28)
- [MCP: changelog 2026-07-28 (stateless protocol)](https://modelcontextprotocol.io/specification/2026-07-28/changelog)
- [MCP: security best practices](https://modelcontextprotocol.io/docs/tutorials/security/security_best_practices)
- [MCP: authorization](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization)
- [IETF: RFC 8693, OAuth 2.0 Token Exchange](https://datatracker.ietf.org/doc/html/rfc8693)
- [Microsoft: OAuth 2.0 on-behalf-of flow](https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-on-behalf-of-flow)
- [MCP: 2026 roadmap](https://blog.modelcontextprotocol.io/posts/2026-mcp-roadmap/)
- [MCP Registry: preview announcement](https://blog.modelcontextprotocol.io/posts/2025-09-08-mcp-registry-preview/)
- [Anthropic: MCP donated to the Agentic AI Foundation](https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation)
- [Anthropic: advanced tool use (tool search)](https://www.anthropic.com/engineering/advanced-tool-use)
- [Anthropic: code execution with MCP](https://www.anthropic.com/engineering/code-execution-with-mcp)
- [Invariant Labs: tool poisoning attacks](https://invariantlabs.ai/blog/mcp-security-notification-tool-poisoning-attacks)
- [Simon Willison: MCP and prompt injection](https://simonwillison.net/2025/Apr/9/mcp-prompt-injection/)
- [Koi Security: malicious postmark-mcp package](https://koi.ai/blog/postmark-mcp-npm-malicious-backdoor-email-theft)
- [A2A: specification](https://a2a-protocol.org/latest/specification/)
- [AG-UI: introduction](https://docs.ag-ui.com/introduction)
- [Linux Foundation: Agent2Agent (A2A) project](https://www.linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project-to-enable-secure-intelligent-communication-between-ai-agents)
- [MuleSoft: Agent Fabric](https://www.mulesoft.com/ai/agent-fabric)
- [Kong: AI MCP Proxy](https://developer.konghq.com/plugins/ai-mcp-proxy/)
- [Azure API Management: MCP servers](https://learn.microsoft.com/azure/api-management/mcp-server-overview)
- [AWS: Bedrock AgentCore Gateway](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway.html)
- [Cloudflare: MCP server portals](https://developers.cloudflare.com/cloudflare-one/access-controls/ai-controls/mcp-portals)
- [Gravitee: Agent Mesh](https://documentation.gravitee.io/apim/agent-mesh)
- [LiteLLM: MCP gateway](https://docs.litellm.ai/docs/mcp)
- [IBM: ContextForge](https://github.com/IBM/mcp-context-forge)
- [Docker: MCP Gateway](https://docs.docker.com/ai/mcp-catalog-and-toolkit/mcp-gateway/)
- [Microsoft: MCP Gateway](https://github.com/microsoft/mcp-gateway)
