---
title: 'MCP server security: what the protocol does not check for you'
description: >-
  MCP server security starts from an uncomfortable fact. The protocol does not
  verify which agent is calling, so identity and scope are yours to add.
author: elroot_labs
date: '2026-11-13'
categories:
  - artificial-intelligence
---
MCP server security has an awkward starting point. The protocol moves tool calls between an agent and a server, and it does not establish which agent is on the other end or what that agent is allowed to do. Identity, scope and auditability are left to whoever runs the server, and in practice a great many people have not added them.

This post covers what the protocol leaves open, what the research measured, and the smallest set of controls worth having before an MCP server touches anything that matters.

## The protocol does not verify who is calling

The clearest statement of the gap comes from protocol research rather than from vendor material. The paper [AIP: Agent Identity Protocol for Verifiable Delegation Across MCP and A2A](https://arxiv.org/abs/2603.24775) puts it flatly: "neither protocol verifies agent identity." The same abstract reports a scan of roughly 2,000 MCP servers in which "all lacked authentication".

That number deserves a moment. It does not say the servers were badly configured. It says authentication was absent, which is the expected result when a protocol does not require it and the quickest path to a working integration skips it.

For a small team the practical reading is this. If you stood up an MCP server to let an agent reach your database, your ticketing system or your file store, and you did not explicitly add authentication in front of it, you very likely have an unauthenticated tool endpoint. Whether that is exposed to the internet or only to your own network changes the severity, not the category.

## A session grant is usually wider than the task

The second problem is scope, and it is older than MCP.

An agent that connects to a server typically gets the server's whole tool surface for the duration of the session, because that is the simple thing to build. The task at hand might need one read-only lookup. The grant covers everything the server can do.

OWASP's entry on [excessive agency](https://genai.owasp.org/llmrisk/llm062025-excessive-agency/) names this directly, putting the root cause as "typically one or more of: excessive functionality; excessive permissions; excessive autonomy", and recommending that you "Limit the permissions that LLM extensions are granted to other systems" to the minimum necessary, with actions running at "the minimum privileges necessary".

The mitigation that matters most is the one about where the decision lives: "Implement authorization in downstream systems rather than relying on an LLM to decide if an action is allowed or not." An MCP server that exposes a delete tool and trusts the agent to use it only when appropriate has placed the access decision inside the model.

## Delegation is where it gets genuinely hard

Single-hop access is tractable. Chains are not, and this is the part most hardening checklists skip.

When an agent calls a server which calls another agent which calls a third server, the question is no longer whether the first caller was authenticated. It is whether the third server can tell on whose behalf it is ultimately acting, how many hops away that principal is, and whether the authority was narrowed at each step or passed along intact.

The AIP paper proposes Invocation-Bound Capability Tokens, combining identity, attenuated authorisation and provenance in a single token chain, and names attack categories that only exist in chains: delegation depth violation, where a chain runs deeper than policy allows, and audit evasion through empty context, where the provenance that should identify the original principal is simply absent.

You do not need to adopt that protocol to take the point. If your architecture has agents calling agents, write down what each downstream service knows about the original request, and check whether the answer is anything at all.

## The smallest set of controls worth having

Five things, in the order they pay off:

1. Authentication in front of every MCP server, including the ones you believe are internal. The scan above suggests the default state is none.
1. One server, one job, with the tool surface scoped to that job. A server that exposes read and write and delete because they were convenient to add together will hand all three to any session.
1. Authorisation enforced inside the downstream system, so a tool call outside policy is rejected by the thing that executes it rather than declined by the model that proposed it.
1. A log of every tool call with the identity it ran as and the request that prompted it. Without this you cannot answer the only question that matters after an incident, which is what the agent actually did.
1. A written decision about delegation depth, even if the decision is that no agent may call another agent yet.

Numbers two and three carry most of the weight. The first is the one teams discover late, usually while looking for something else.

## This sits next to the injection problem

Scoping is one half of the pairing. The other is that an agent reading hostile content can be persuaded to call a tool it has legitimate access to, which no amount of authentication prevents, because the call is properly authorised and still wrong.

Narrow permissions are what make that survivable, since an agent restricted to the one tool its task requires can be manipulated into misusing exactly that one tool and nothing else. We have published [a set of prompt-injection test cases](/blog/prompt-injection-test-cases) for probing that behaviour, and [guardian agents and runtime oversight](/blog/guardian-agents-runtime-oversight) covers watching for the sequences a single permission check cannot see.

If you are putting an MCP server in front of systems that hold patient, student or financial records, [tell us about the project](/contact).
