Connecting an MCP server in the enterprise: the controls to require before production

The MCP specification makes authorization optional, only recommends that a human be able to deny a tool call, and requires clients to treat tool annotations as untrusted. Here is what it requires, what it recommends, and what an organisation must require on its own before connecting an agent to its tools.

Transparency note — This article follows our editorial policy. It relies on the 2026-07-28 revision of the Model Context Protocol specification and on two OWASP publications, consulted on 16 and 17 November 2026. We separate what the specification requires ("MUST"), what it recommends ("SHOULD") and what it leaves to your decision. No client is named.

An MCP server secures nothing by itself. The specification makes authorization optional, only recommends that a human be able to deny a tool call, and requires the client to treat what a server says about the behaviour of its own tools as untrusted. Before connecting an agent to your business tools, the question is therefore not "does the server speak MCP?", but "who issues the tokens, with which rights, and who approves the action?".

In short

  • Being "MCP-compatible" says nothing about security: authorization is optional in the specification.
  • If the server applies the authorization specification, it must validate tokens and reject any token that was not issued for it. Ask for proof of both controls.
  • Rights should start small and be elevated on demand. A token that opens the whole scope catalogue widens the impact of a leak.
  • Tool annotations are hints, not guarantees. Tool definitions should be reviewed, pinned and reviewed again when they change.
  • A local server runs with the rights of the machine that launches it. Treat it as installed software, not as a simple connector.

This checklist helps prepare a review. It replaces neither a security analysis adapted to your information system nor legal or compliance advice.

What is MCP, factually?

MCP (Model Context Protocol) is a protocol. It describes how an application that hosts a model — the host and its client — discovers and calls the tools, resources and prompts exposed by a server. It standardises the conversation between these components. It decides neither what the agent is allowed to do nor how your information system authorises it.

The specification evolves through dated revisions. As of 17 November 2026, the versioning page states that the current revision is 2026-07-28. Every requirement quoted below comes from this revision. If your vendor or internal team relies on an older revision, ask which one, and reread the relevant sections for that revision.

ItemWhat the 2026-07-28 specification saysLevel
Authorization"Authorization is OPTIONAL for MCP implementations"—
HTTP transport, when authorization is supportedShould conform to the authorization specificationSHOULD
Server applying this specificationActs as an OAuth 2.1 resource server and must validate access tokensMUST
Resource indicatorThe client must implement RFC 8707 and name the canonical URI of the serverMUST
Token receivedThe server must not accept a token that was not explicitly issued for itMUST NOT
Local stdio transportShould not follow the authorization specification; credentials come from the environmentSHOULD NOT
Tool callA human should always be able to deny the callSHOULD
Tool annotationsThe client must treat them as untrusted unless they come from a trusted serverMUST

Source: MCP specification, revision 2026-07-28, Authorization, Security Best Practices and Tools sections.

The difference between MUST and SHOULD matters. A MUST is a conformance condition. A SHOULD is a strong recommendation that an implementation may set aside for a reason. In a review, a SHOULD that was set aside is not a fault in itself, but it needs a written justification.

Why "authorization is optional" changes the review

The consequence is simple. Two "MCP-compatible" servers can have nothing in common on security. One delegates authentication to your identity provider and checks every token. The other asks for none, or runs locally with credentials placed in an environment variable. Both conform to the specification.

The specification describes three cases when authorization is supported:

  1. with an HTTP-based transport, the implementation should conform to the authorization specification;
  2. with the local stdio transport, it should not follow it and retrieves its credentials from the environment;
  3. with another transport, it must follow established security best practices for that protocol.

For a mid-sized company, protocol conformance therefore does not replace a review. It only sets its vocabulary. The first questions to ask a vendor or an internal team are:

  • Which transport does the server use in production: HTTP, stdio or another?
  • Is authorization enabled? If not, what prevents an unauthorised call?
  • Which authorization server issues the tokens, and is it connected to your identity provider?
  • With which identity does the server then call your systems: the user's, or a technical account?

The last question is often the most revealing. A server that calls your ERP with a very broad technical account turns every user of the agent into a holder of that account, however good the protocol upstream is.

Tokens: who they are issued to, and why passthrough is forbidden

When authorization follows the specification, the MCP server acts as an OAuth 2.1 resource server. Two requirements then shape the review.

The client must name the intended server. The specification requires the client to implement the RFC 8707 resource indicators and to state the canonical URI of the MCP server it requests a token for. The token obtained is thus bound to a specific recipient.

The server must reject tokens that are not meant for it. The Security Best Practices section describes the token passthrough anti-pattern: a server accepts a token from the client without checking that it was issued for it, then forwards it unchanged to a downstream API. It derives a rule without exception: an MCP server must not accept any token that was not explicitly issued for it.

The risk is twofold. First, a server that does not check the token audience may accept a token issued for another service. Second, if it forwards that token unchanged, the downstream API may assume the token was validated upstream. This is the "confused deputy" problem: a legitimate intermediary is used for an action nobody authorised it to perform. For MCP servers acting as a proxy to a third-party API, the specification also requires per-client consent before relaying an authorization.

What to ask for, concretely:

  • proof that the server checks the token audience (not only its signature);
  • how the server obtains its own tokens to call downstream APIs, instead of relaying the client's;
  • a documented test in which a token issued for another service is presented to the server, and rejected.

A demo where "it works with my token" proves none of these three points. The case to test is the one where the token should not work.

Scopes: start small, elevate on demand

The token says who it was issued for. Scopes say what for. The Scope Minimization section of the specification starts from a precise scenario: an attacker obtains, through a log leak or local interception, a token carrying broad scopes granted up front. That token then opens access unrelated to the initial use, and revoking it interrupts every workflow at once.

The specification recommends a progressive model:

  • a minimal initial scope set, limited to discovery and low-risk reads;
  • targeted elevation, requested when a privileged operation is first attempted;
  • tolerance for reduced tokens: the authorization server may grant a subset of the requested scopes.

It also lists common mistakes: publishing every possible scope, using wildcard or omnibus scopes such as *, all or full-access, bundling unrelated privileges to avoid future prompts, or treating the scopes claimed in a token as sufficient without server-side authorization logic.

One point deserves attention. If the server's first challenge carries no scope, the specification directs the client to request all the scopes the server lists. The number of scopes a server publishes therefore becomes a security parameter: a server that publishes its whole catalogue will often get its whole catalogue.

OWASP points the same way in its MCP Security cheat sheet: per-server credentials, never shared across servers, narrow scopes (read-only rather than full modification) and short-lived tokens rather than long-lived personal access tokens.

To require before production:

  • the list of scopes the server publishes, with a justification for each;
  • the minimal scope the agent starts with;
  • the operations that trigger an elevation, and a trace of each elevation (scope requested, scope granted);
  • the token lifetime and the revocation procedure.

Tools: the human, annotations and pinned definitions

An MCP server exposes tools: functions the model can decide to call. The Tools section of the specification contains two warnings every review should reread.

A human should be able to deny. The specification states that there should always be a human in the loop with the ability to deny a tool invocation. It also recommends that applications make clear which tools are exposed to the model, show a visible indicator when a tool is invoked and present confirmation prompts. This is a SHOULD: the protocol mandates no interaction model. It is therefore up to the organisation to decide which actions require confirmation. Our article on human approvals for an agent connected to business tools explains how to place these control points according to the effect of the action.

Annotations are not guarantees. A server can describe its tools with annotations, for instance to state that a tool is read-only or destructive. The specification requires the client to treat these annotations as untrusted unless they come from a trusted server. A tool advertised as "read-only" can write. What counts is what the effective rights allow.

OWASP adds a useful practice: pin reviewed tool definitions with a cryptographic hash, and require a new review when they change. The cheat sheet says to hash the complete definition (input schema, output schema and annotations), not only the description: a flipped read-only or destructive hint can change the client's approval behaviour without any visible change in the description. It also notes the limit of this practice: it detects metadata changes, not changes to the server code behind an unchanged definition.

On confirmation, OWASP recommends requiring explicit confirmation for destructive, financial or data-sharing operations, and showing the user the full parameters of the call, not just the tool name. A confirmation that shows "send_email" with no recipient or content cannot catch a wrong target.

These three controls answer the three causes OWASP attributes to the LLM06:2025 Excessive Agency risk: excessive functionality, excessive permissions and excessive autonomy. Exposing fewer tools reduces the first. Limiting scopes reduces the second. Placing confirmation in the right place reduces the third.

Local servers and the supply chain

Many MCP servers are installed locally: a downloaded package, a command added to the client configuration, and the server runs on the user's machine. The specification devotes a full section to local server compromise and describes three scenarios: a malicious startup command slipped into the client configuration, a malicious payload distributed inside the server itself, and access to a local server left listening, through DNS rebinding.

The risks listed are concrete: arbitrary code execution with the client's privileges, no visibility into the commands executed, data exfiltration, data loss on the host machine.

The specification's requirements apply first to the client. If a client offers one-click configuration of a local server, it must show the exact command that will be executed, without truncation, flag it as a potentially dangerous operation, require explicit approval and allow cancellation. It should also run servers in a sandboxed environment with restricted file system and network access, and warn that the server runs with the same privileges as the client.

For the server, the specification recommends using the stdio transport, which limits access to the client alone, or restricting access when it exposes an HTTP transport. OWASP adds an important nuance: stdio avoids a listening network endpoint, but it restricts neither the process's file system access, nor its network access, nor its credentials. The transport is not a sandbox.

On the supply chain, the OWASP cheat sheet recommends installing only from verified sources, reviewing code and tool definitions before installation, verifying package integrity, scanning dependencies and monitoring definition changes after installation. It cites typosquatting as a common vector: a package name one letter away from the expected one.

For an organisation, the practical rule is to treat a local MCP server as software installed on the workstation: same approval process, same inventory, same update rules. A server added by a user to their configuration outside that process is uninventoried software with access to the workstation's data.

Log so you can answer "who did what"

The specification sections quoted here do not set a log format for tool calls. The Scope Minimization section does recommend logging elevation events with a correlation ID. The OWASP cheat sheet goes further: log every tool invocation with full parameters, user context and timestamp, centralise these logs, alert on unusual patterns (a new tool being called, admin-level queries, abnormal call frequency) and redact secrets and personal data from logs.

The need is simple to state: after an incident, the team must be able to say which user triggered which call, with which parameters, which token and which result. Our article on AI agent traceability details the events to keep in order to reconstruct a decision.

Decision grid: what to require before production

AreaQuestion to askEvidence to obtainBasis
TransportWhich transport in production?Effective configurationSpecification, Authorization
AuthorizationIs authorization enabled? If not, what replaces it?Authentication and access-control designSpecification, Authorization (OPTIONAL)
Token issuerWhich authorization server, connected to which identity provider?Configuration and revocation procedureSpecification, Authorization
AudienceDoes the server reject a token issued for another service?Documented rejection testSpecification, Security Best Practices (MUST NOT)
Downstream callsWith which identity does the server call your systems?List of accounts and their rightsSpecification, Token Passthrough
ScopesWhich scopes are published, which one at start?Justified list, elevation traceSpecification, Scope Minimization; OWASP
Exposed toolsWhich tools does the model see, and why?Inventory of tools and their effectOWASP LLM06
ConfirmationWhich actions require confirmation, with which parameters shown?Approval rules and screenshotsSpecification, Tools (SHOULD); OWASP
Tool definitionsAre definitions pinned and reviewed when they change?Hashes and review procedureOWASP MCP Security
Local serversWho approves installation, and in which sandbox do they run?Inventory and isolation configurationSpecification, Local MCP Server Compromise; OWASP
LoggingCan you reconstruct who called what, with which result?Example log of a real callOWASP MCP Security

If a row has no evidence, the right next step is rarely to block the whole project. More often it is to narrow the scope: fewer exposed tools, a read-only scope, a confirmation on the action concerned, or a server kept out of production until the evidence exists. These conditions can be part of your go/no-go criteria between prototype and production, with an owner and a review date. They complement the controls in our reading of the OWASP Top 10 for LLMs applied to enterprise RAG.

FAQ

Is an "MCP-compatible" server secure?

Not by that fact alone. The 2026-07-28 specification makes authorization optional. A conformant server may ask for no token at all. Security depends on the transport, the authorization actually enabled, the rights granted and the downstream controls.

Should OAuth authorization be enabled for a local MCP server?

For the stdio transport, the specification says the opposite: the implementation should not follow the authorization specification and should retrieve its credentials from the environment. The control then covers installation, process isolation and the rights of the credentials provided, not an OAuth flow.

Can an MCP server forward the user's token to a downstream API?

The specification forbids an MCP server from accepting a token that was not explicitly issued for it, and describes forwarding a token unchanged to a downstream API as an anti-pattern. The server must obtain its own tokens to call downstream APIs.

Can you rely on a tool's "read-only" annotation?

No, unless the server is trusted. The specification requires the client to treat tool annotations as untrusted in that case. What actually limits a tool is the rights of the account it uses and the controls enforced by the systems it calls.

Is a human approval mandatory before every tool call?

The specification recommends it (SHOULD) without requiring it, and mandates no interaction model. It is up to the organisation to decide which actions require confirmation, based on their effect: data changes, external actions, elevated privileges.

Methodology and sources

The terms MUST, MUST NOT, SHOULD and SHOULD NOT are taken from the specification, which uses them as defined in RFC 2119 and RFC 8174. This article contains no client data, no statistics and no promise of security or compliance. The specification evolves: check the current revision before a review.


Preparing to put an MCP server into production? IgnitionAI can review these controls with your team before go-live: transport, authorization, tokens, human approval of tool calls. Get in touch.

Contact

AI agents that answer from your documents.

Sourced answers, a written scope before we start, and a fixed price written before the first piece of work.

Free 30-minute call, no commitment.