An MCP server can put an AI assistant next to your email, customer records or production tools. That is useful only if the server can answer a harder question than “Can this model call this tool?”: Who authorized this client to act, which resource is the token for, and what is this agent allowed to do now? In his MCPCon talk, Anthropic's Den Delimarsky traces how the Model Context Protocol has moved from developer-defined authorization toward shared OAuth rules, official SDKs and operational guidance. The next challenge is making those boundaries work when no person is sitting at a consent screen.
For a sensitive remote MCP server, validate the token's issuer, audience, expiry and required scope; never forward the client's token to a downstream API; and give each client a clear, reviewable authorization path. Start from a maintained SDK and test the real deployment. Enterprise-managed access is an available extension. DPoP and agent workload grants are promising directions, but their MCP adoption and standardization should not be described as finished requirements.
Watch Den Delimarsky's Talk
The MCPCon program identifies the speaker and session. The supplied transcript is used for his examples and timing; protocol requirements below are checked against the current published specification.
Security Has Three Pillars, Not One Checkbox
At 00:40, Delimarsky divides the work into the versioned specification, SDKs developers actually install, and deployment best practices. Early MCP left authorization largely to individual implementations. That made each connection a custom integration and increased the chances of inconsistent token storage, consent and validation. OAuth-based authorization gives HTTP clients and servers a common path, but a protocol rule is useful only if libraries implement it and operators configure it correctly.
He cites 4.17 billion cumulative SDK and reference-server downloads in the talk. Treat that as his point-in-time ecosystem estimate, not a count of secure installations or unique users. The security implication is clear without the number: a mistake in a popular SDK or setup guide can repeat across many projects. The official conformance suite and coordinated SDK maintenance are therefore part of the security story, not an appendix.
What Authorization Actually Protects
The published MCP authorization specification covers HTTP-based transports. In that flow, the MCP client is an OAuth client, the protected MCP server is a resource server, and an authorization server issues tokens. OAuth 2.1 is still an IETF draft; MCP selects a defined set of OAuth requirements rather than inventing a new login system. An unauthorized call receives a 401 challenge; protected-resource metadata tells the client which authorization server to use. The client obtains a token for that particular MCP resource and sends it in the Authorization header, never in the URL.
The server then checks that the token is valid for this server. That means more than a valid signature: it includes the intended audience, issuer, expiry and scopes or permissions needed for the operation. A missing or invalid token calls for 401; insufficient scope normally produces a 403 and a scope challenge. The official walkthrough illustrates this discovery and step-up flow. Authorization is optional in the protocol, but it is strongly recommended for remote servers handling user-specific data or administrative actions. Local stdio servers use a different credential model, usually the process environment, and should not have a remote OAuth flow copied onto them blindly.
Four Failures the Talk Wants You to Avoid
| Failure | What can go wrong | Control to check |
|---|---|---|
| Confused deputy | An MCP proxy reuses a third-party OAuth client identity while a newly registered MCP client benefits from an old consent cookie. | For affected proxy/Dynamic Client Registration flows, record consent per user and MCP client before forwarding to the third party; show the client, scopes and redirect URI. Official attack and mitigation. |
| Token passthrough | A server accepts a token meant for another API and forwards it unchanged, collapsing resource boundaries. | Verify the token is for this MCP server and obtain a separate downstream credential or proper exchange. The spec forbids accepting or transiting other tokens. |
| Issuer mix-up | A client redeems an authorization code at the wrong token endpoint when several authorization servers are in play. | Bind the flow to the discovered issuer and validate an authorization response's iss when advertised, as required by the 2026-07-28 update. |
| Over-broad scopes | A stolen token can invoke unrelated read, write or admin tools because all privileges were granted up front. | Request the minimum scope needed and use step-up for more sensitive operations. Review both token scope and application policy for every tool. |
These are not interchangeable attacks. In particular, the per-client consent scenario applies to a specific proxy configuration, not to every MCP server. And a valid OAuth token does not make a tool result trustworthy: fetched pages, documents and tool responses still need to be treated as untrusted input when an agent decides what to do next.
Why SDKs and Conformance Matter
At 09:02, Delimarsky argues that developers depend on SDK behavior, not a hand-rolled reading of every protocol RFC. Maintainers coordinate security reports across language implementations so a flaw found in one SDK can be checked in the others. At 13:10, he describes conformance tests as an enforceable contract. The suite has versioned requirement sets and authorization scenarios for clients and servers. Its README gives commands for testing a server against the 2026-07-28 requirements.
Use the SDK version that supports the protocol revision your host and server negotiate, run its required conformance checks, and keep dependencies patched. A passing suite establishes protocol behavior under its scenarios; it does not certify your tool's business authorization, secret handling, outbound network policy or resistance to prompt injection. For a vulnerability, use the relevant project's private security-reporting route, not a public issue containing an exploit.
When There Is No Human to Click Approve
Long-running agents make the original browser-consent pattern awkward. Delimarsky sketches four building blocks at 15:52; they are at different stages of maturity.
| Building block | Job | Status at this article's cutoff |
|---|---|---|
| Enterprise-Managed Authorization | An administrator's identity provider governs which employees can access approved MCP servers without individual per-server prompts. | Stable MCP extension. It uses ID-JAG token exchange; central approval does not remove the need for policy and auditing. |
| DPoP | Constrain a token to a holder that can prove possession of its private key, reducing replay from a token leak alone. | Established OAuth RFC; MCP-wide support is roadmap work. DPoP does not inherently require a hardware chip and does not help if the signing key is also stolen. |
| Workload identity federation | Use an identity asserted by the workload platform instead of installing a long-lived shared secret in every service. | Active MCP agent-identity direction, with extension work tracked separately from the core authorization rules. |
| Workload Authorization Grant | Give an agent a short-lived assertion with an agent identifier and policy-relevant claims, then let an authorization server decide what access token to issue. | Individual IETF Internet-Draft, updated 2 November 2026; not an approved standard or mandatory MCP feature. |
The claim in the talk that a Slack-based Anthropic agent uses workload-grant ideas is an account of that team's implementation. It does not mean every Claude or MCP deployment already has agent-specific grants. The more durable design principle is to make agent identity, delegated authority and the calling context visible to the service making the authorization decision, instead of sharing one human's static credential among many agents.
A Production Review You Can Run This Week
| Check | Evidence to ask for |
|---|---|
| Inventory every tool and resource | Owner, data classification, read/write capability and the real approval point for each operation. |
| Verify remote authorization | Protected-resource metadata, trusted issuer, exact audience, expiry and per-operation scopes; negative tests for invalid and cross-resource tokens. |
| Trace downstream credentials | Proof that the MCP client's incoming token is never forwarded as the downstream API token; separate credentials and redacted logs. |
| Test consent and client identity | For proxies, inspect per-client approval and redirect URI handling; for enterprise access, verify IdP policy and offboarding. |
| Run conformance and abuse tests | Results for the negotiated protocol version, plus tests for prompt injection, unexpected tool output, excessive scopes and blocked outbound destinations. |
| Plan agent autonomy explicitly | Short-lived, scoped identities; auditable actions; human review for high-impact writes; and a way to revoke or stop a running agent. |
This checklist is our implementation synthesis of the talk and the linked official guidance. It is a starting point for a security review, not a certification or a substitute for an assessment of your own deployment.
Video Chapters
| Time | Topic |
|---|---|
| 00:00 | Why MCP security matters |
| 00:40 | Specification, SDKs and best practices |
| 01:23 | Early authorization choices |
| 03:14 | Why the protocol became opinionated |
| 05:45 | Making secure choices easier |
| 07:38 | Scale and security responsibility |
| 09:02 | SDK vulnerability coordination |
| 10:39 | Consent and token-handling mistakes |
| 12:03 | Lessons from deployments |
| 13:10 | Conformance testing |
| 15:52 | Consent without a waiting human |
| 17:00 | Enterprise-Managed Authorization |
| 18:21 | DPoP and proof of possession |
| 19:16 | Workload identity federation |
| 20:25 | Workload grants and agent identity |
| 22:07 | From human to agent workflows |
| 22:42 | Community and vulnerability reporting |
Sources and Limits
The talk and supplied transcript establish what Delimarsky said. The current authorization spec, security guidance, EMA extension, conformance project, MCP roadmap and WAG draft establish publication status and normative detail. We did not audit a live MCP server or reproduce an exploit. Evidence cutoff: 17 November 2026.