Est.

Graduated MCP Authorization Models That Let Developers Ship Fast Without Handing Security Teams a Blocker Role

Tiered MCP checks let low-risk tools ship fast while guarding destructive actions.

· 9 min read
Cover illustration for “Graduated MCP Authorization Models That Let Developers Ship Fast Without Handing Security Teams a Blocker Role”
AI Risk & Compliance · November 13, 2026 · 9 min read · 1,952 words

Graduated MCP authorization lets developers ship low-risk tools quickly while reserving stricter checks for actions that can cause lasting harm. For enterprise security teams tackling shadow MCP usage, a gateway registry and execution logs provide visibility limited to connections routed through that gateway. Proportional enforcement is needed at each tool call, backed by identity controls and protection for the paths a gateway cannot see.

Why MCP's missing authorization layer turns developer velocity into organizational risk

MCP has a delegation gap when a server acts for the caller using its own credentials. The agent can then exercise privileges that the developer never explicitly granted and security never explicitly reviewed. Connection becomes an implicit grant of power. Without tool-level scoping, permission to use a server can mean permission to use everything it exposes, even when the task needs only a small part.

The NSA’s May 2026 advisory said that MCP cannot enforce consent, privacy, or tool-safety principles through the protocol alone. It specifically flagged authorization and credential isolation as unstandardized. That leaves the code around the protocol to make key decisions. A working connection proves only that an agent can reach a capability, leaving the appropriateness of its use for this caller, resource, or task unverified.

Security teams therefore have sound reasons to delay deployments. Developers also have reasons to avoid a review process that treats a harmless lookup like a destructive operation. Local or unauthenticated servers let developers get around that review process, which creates shadow MCP usage outside the approved path. Resolving the standoff requires a better permission model.

What the threat surface actually looks like when authorization is absent or binary

A read-only discovery tool and a payment tool do not deserve identical controls. Discovery has no write-side blast radius, while a payment can create an irreversible consequence. Reversible record changes sit between those extremes. Read access still needs limits on the data it exposes, but treating every action as equally dangerous makes authorization either obstructive or toothless.

Tool poisoning complicates that gradient because exposure begins before execution. Malicious instructions in a tool description can influence an agent as soon as the description enters its context, even if the tool is never called. Pillar Security documented an August 2026 campaign in which a server stayed harmless for its first three tool calls, then instructed the agent to collect SSH keys and cloud credentials. Initial approval was not enough to contain it. Tool shadowing creates a related problem when one server’s description redirects the behavior of a trusted tool, such as send-email.

Dolt MCP versions 0.3.1–0.3.6 returned errors for invalid tokens but continued processing requests, a flaw fixed in 0.3.7. The Grafana MCP server accepted any well-formed caller-generated session ID and had an SSRF vulnerability reaching cloud metadata endpoints, assigned CVE-2026-19516 with a CVSS score of 9.1. These flaws show why authorization depth must reflect both what a tool can do and whether the implementation actually enforces its checks.

The two-gate authorization model and what each gate is actually doing

Separating capability admission from execution authorization replaces the single approve-or-block decision with two distinct questions. Gate 1 asks whether a capability should be available to this agent at all. It is a catalog decision made at registration. Gate 2 asks whether this call should go ahead with the current identity, context, and target resource. It runs for every call.

Admission limits what enters the agent’s operational reach before backend authorization begins. Execution authorization then controls how an admitted capability is used. Neither gate substitutes for the other one. A single Jira server may expose read-only tools, tools that create public content, and tools that delete projects, so approving the server as a unit defeats proportional control. Per-tool role-based access control, or RBAC, with default deny blocks any tool that has not been explicitly approved.

A human must confirm destructive or irreversible actions at Gate 2. The gateway can pause file deletion, payment initiation, schema changes, or external communications before the server executes them. Tool shape also affects the decision. restartApprovedService(serviceId) keeps sensitive logic in deterministic code, while executeCommand(cmd) exposes an open execution surface. These gates constrain available power, but they do not make poisoned descriptions safe. Admission needs protection against later changes as well.

How credential hygiene and token scope enforce the tier model at the identity layer

Credentials must enforce the same limits as the gates. MCP servers should begin with minimal discovery or read-only scopes and request more privilege only for a specific task, with that expansion deliberately logged. CoSAI’s Agentic IAM framework specifies that scope should narrow at each hop and must never expand beyond the delegating principal’s effective permissions. Actor and subject claims preserve who is acting and on whose behalf.

Zero Standing Privilege makes those limits temporary as well as narrow. Just-in-time credential issuance creates a credential for an authorized operation and lets it expire afterward, rather than leaving a long-lived credential available for reuse. Agent identity also needs a version boundary. The framework binds credentials to the agent’s code and model through a signed manifest, so an altered version fails attestation and is blocked from high-impact actions.

Token handling must preserve those boundaries downstream. RFC 8693 token exchange produces a new token scoped to the operation and an auditable exchange record instead of passing the user’s original OAuth token through the chain. The 2025-06-18 specification update required RFC 8707 Resource Indicators so that tokens are bound to a specific server. Issuer validation under SEP-2468 and RFC 9207 deals with a different risk, that a client might trust the wrong authorization server. Both bindings are needed in a multi-server client.

FastMCP’s OAuth wrappers before 4.1.2 neither accepted nor forwarded the issuer parameter, allowing a malicious server to redirect client credentials to its own authorization server. Remediation requires upgrading, explicitly configuring the issuer, and rotating credentials that may have reached an untrusted endpoint. Shared credentials leave another gap even with correct token handling. A gateway log may name the user while the downstream log records only a service account, breaking attribution across the boundary. Gateway logging alone does not repair that compliance gap.

How do security teams get visibility into MCP connections without reviewing every deployment?

A centralized gateway puts authentication, per-tool RBAC, the server registry, and execution logging at one trust boundary. It terminates client connections and streams logs to monitoring and SIEM. This reduces duplicated work across server teams. Without it, each team must independently implement OAuth 2.1, access controls, and auditing, making enforcement depend on its available expertise and time.

That registry and telemetry support visibility into governed MCP use, but their limits need to be explicit. A connection that bypasses the gateway is not made visible by its execution logs. Coverage must not be confused with completeness. For shadow MCP remediation, the architectural benefit is an approved path where tools are already authenticated, logged, and access-controlled. Developers who use that catalog can deploy without another security review each time, which gives them less reason to look for workarounds.

Bifrost Enterprise applies guardrails before tool execution and after results return, using CEL rules that match the MCP client, tool, and arguments. Its administrative audit logs use HMAC signing and export to JSON, JSON Lines, or Syslog. TrueFoundry offers per-tool RBAC, full audit logging, and self-hosted VPC and on-premise deployment options. Those are concrete criteria for comparing implementations.

The gateway itself still needs to be checked and audited. Envoy AI Gateway’s agent-router session-resume flaw dropped a JWT subject claim without checking it against the current caller, and its default Helm chart used a seed known to the public for session ID encryption. Central placement does not excuse insecure defaults. Authorization also leaves malicious packages and prompt injection through tool results to be dealt with. The gateway is the common enforcement point within a broader defense.

Designing the tier boundaries: how to map tool calls to authorization depth in practice

Diagram: Three Authorization Tiers: From Read-Only to High-Impact. Visualizes: Visualize a ranked three-tier authorization model showing how tool calls are classified by reversibility and impact.

Reversibility provides the starting point for tier assignment. Discovery, schema inspection, and ordinary record retrieval have no write-side impact, while record creation and tag assignment can be reversible. Deletion, payments, schema changes, and external communications need stricter treatment. The classification follows actual access and consequences.

Tier 1 uses lightweight controls for bounded, read-only work. This includes tool discovery, database reads, file reads from approved paths, and searches of internal knowledge bases. Controls include an OAuth client credential flow or a short-TTL API key, read-only scope, and audit logging. No human approval step is required here. That lets low-risk integrations ship on the developer’s current deployment timeline without making them unauthenticated.

Tier 2 covers reversible writes with a known target and limited reach. Record creation, tag assignment, non-public page creation, and reversible state-changing API calls fit this tier. They use SSO-tied identity, scoped write credentials issued just in time, gateway-enforced per-tool RBAC, and logs with actor and subject claims. Security review happens when the capability enters the catalog. It does not repeat for each deployment that uses the approved capability.

Tier 3 needs explicit authorization each time a high-impact action runs. File deletion, payment initiation, schema changes, external email or webhook dispatch, and actions touching PII at scale belong here. The controls include just-in-time credentials for the specific operation, human approval at Gate 2, tamper-proof audit logs with full OTEL tracing, and RFC 8693 token exchange in place of user-token pass-through. Intended use does not override an open execution surface. A free-form executeCommand(cmd) belongs in Tier 3, while a constrained restartApprovedService(serviceId) may qualify for Tier 2.

Version pinning anchors the reviewed implementation, but every version change needs a fresh tier decision because descriptions or network destinations may change. Tool-description fingerprinting complements that review at runtime. A changed definition should be detected, logged, and blocked before it reaches the agent.

What the authorization model must do beyond the gateway to remain valid under real attack conditions

The tier model holds only when its surrounding controls protect what execution authorization cannot see. Poisoned descriptions enter context before a call, and malicious packages bring supply-chain risks that the permission decision itself cannot cover. User-visible success is not proof of safety. The logging attack hidden in poisoned descriptions often succeeded while barely changing how well tasks were completed, which shows why ordinary behavioral checks can miss it.

Development servers also need protections that do not follow automatically from tier assignment. The @modelcontextprotocol/server-everything reference server bound to all interfaces with wildcard CORS and no authentication, while its get-env tool exposed the entire process environment. Any browser tab could complete the cross-origin MCP handshake and collect API keys and database credentials. Version 2.0.1 fixed the flaw, but exposed development deployments need the upgrade. A reference implementation is not automatically a safe deployment.

Localhost binding is not a complete boundary either. Basic Memory’s SSE transport was reachable through DNS rebinding because Host and Origin validation were missing. FastMCP provides HostOriginGuardMiddleware, but the guard is off by default. Those checks protect a different boundary from tool authorization. They are conditions for keeping a local service local in practice.

Delegation and auditing must preserve the policy after entry. A subagent must not inherit broad access unchanged merely because the first agent received it for a task. For Tier 3, the audit record must reconstruct which agent version acted, on whose behalf, with which tool and arguments, supported by full OTEL tracing and tamper-proof logs that retain their integrity through SIEM export. These controls make the policy durable across handoffs.

With those conditions in place, security teams can set tier boundaries, high-impact triggers, and approval workflows without having to review every deployment. Developers ship against a known policy. As tools and attacks change, the organization can revise the relevant boundary without turning every integration into a new negotiation.

Sources

  1. Security Best Practices - Model Context Protocol
  2. After RSAC™ 2026: The MCP Security Question Everyone Kept Asking - Coalition for Secure AI

More in AI Risk & Compliance