/aienm.

Federated Permission Propagation Across Multi-Agent AI Architectures

Agents must narrow user access at every hop, not just once.

· 9 min read
Cover illustration for “Federated Permission Propagation Across Multi-Agent AI Architectures”
Enterprise AI Governance · November 13, 2026 · 9 min read · 1,971 words

Automatic permission inheritance across enterprise AI data sources requires agents to inherit the requesting user’s access, narrow it for each task, and enforce it at every downstream server. “Federated Permission Propagation Across Multi-Agent AI Architectures” explains why declaring permissions once at an orchestrator is not enough. Source-system controls must remain authoritative throughout the chain, rather than being replaced by each intermediary’s service-account privileges.

Why can’t AI agents just inherit access controls once and trust them downstream?

The intuitive model is simple. Declare access at the top, then trust every agent below it to stay within those bounds. But an orchestrator that chooses a tool and a sub-agent that executes it may be different processes, operated by different teams and connected to different backends. Each hop crosses a new trust boundary. Permission at the first boundary does not establish permission at the next.

The confused-deputy failure follows directly from that gap. A sub-agent server acts with its own broad privileges for a user who does not hold them, substituting the server’s authority for the caller’s. Permission drift makes the exposure harder to spot. A token minted at the orchestrator can remain valid after the approving identity context changes, leaving identity-provider revocation out of step with actual resource access.

Shadow MCP makes it hard even to count the boundaries. Developers can add servers to the configurations for Claude Code, Cursor, VS Code, or Claude Desktop without anyone reviewing them. Security and IT teams may then lack an inventory of both the servers running and the authority they hold.

What MCP is and how its three primitives create distinct permission surfaces

Model Context Protocol, or MCP, gives agents a way to interact with tools and data. Its three primitives expose different kinds of authority. Tools describe executable actions, Resources provide read-only data access, and Prompts supply structural templates. Putting them in one permission category hides the differences between reading information, changing it, and shaping what another agent asks for.

Tools need the strictest scoping because they can expose write access and paths to exfiltration. Read-only does not mean safe for every caller. A Resource still needs a check against its access rules, while a Prompt can contain injected instructions that push a downstream agent toward a more privileged request. MCP uses JSON-RPC 2.0, so each tool call identifies its target and parameters in a structured request. That makes per-call enforcement technically feasible.

Protocol compatibility is a separate engineering concern. The 2026-07-28 specification revision made the core stateless and stopped requiring protocol-level sessions, but older hosts and SDKs may use the 2025 lifecycle. Governance also extends beyond one vendor. MCP was contributed to the Agentic AI Foundation under the Linux Foundation on December 9, 2025, transforming it from an Anthropic project into vendor-neutral infrastructure.

How the four-layer enterprise MCP stack is supposed to work, and where authority is meant to live

The intended enterprise stack separates four kinds of responsibility. MCP clients, including AI surfaces such as Claude, Cursor, Slack, and ChatGPT, initiate requests for users. The MCP Gateway authenticates callers, validates tokens, routes operations, enforces quotas and request-size limits, attaches trace context, and blocks known-bad clients. MCP servers expose the primitives for a specific system and enforce domain-level authorization. Enterprise backends remain the sources of record, with their own native access controls.

These layers are not interchangeable enforcement points. The gateway provides an auditable choke point, but it cannot know the meaning of every CRM object, repository, or warehouse resource. That knowledge belongs in the domain service. Moving all authorization into the gateway trades correctness for convenience, even when the gateway reliably authenticates every caller.

Team profiles make provisioning manageable at that central entry point. Administrators map OIDC group membership from the identity provider, or IdP, to profiles such as Sales access to CRM and Slack tools or Engineering access to GitHub, Jira, and CI tools. Enterprise-Managed Authorization also makes it easier to set up access for each app. The corporate IdP issues an Identity Assertion JWT Authorization Grant, or ID-JAG, which the client exchanges at the server’s Authorization Server for an access token.

Agent identity remains a distinct infrastructure responsibility. Microsoft Entra Agent ID gives an agent a first-class identity with a sponsor, scoped permissions, sign-in history, conditional access, and lifecycle controls. This makes the agent accountable as an actor. It does not make the agent’s own permissions a substitute for the user’s delegated authority.

Where the intended architecture breaks: the multi-hop delegation problem

MCP and OAuth 2.1 address secure access and authentication, SPIFFE provides workload identity, and A2A covers authenticated agent-to-agent communication. These establish who or what is communicating. They only partly cover how authority can pass through several agents while staying within what the original caller could delegate.

The failure becomes concrete in a three-party chain. An orchestrator calls a sub-agent, which then calls a third-party MCP server with that server’s service-account credentials. The original user’s scope never reaches the final server. Everyone in the chain may be authenticated, but the final action still runs under the wrong authority.

A 2026 arXiv paper formalizes authorization propagation as a workflow-level property and names three sub-problems. Transitive delegation asks how authority passes from agent A to agent B to agent C without silently widening. Aggregation inference asks whether a downstream agent can combine partial permissions from different callers in ways none intended. Temporal validity asks whether permission lasts past the time allowed for its task.

These failures span the chain, including its endpoints. A server can accept a valid identity while receiving too much authority, a combination of unrelated authority, or authority whose purpose has expired. The IETF’s WIMSE working group and OAuth token-exchange machinery are where emerging standards address this gap. Enterprises building chained agents cannot treat those unfinished standards as a completed delegation model.

What correctly layered permission propagation looks like across a multi-hop MCP chain

The architecture therefore needs a scoped handoff at every hop. Downstream agents should inherit the original caller’s permission context as the limit on their own service-account scope. Each handoff should grant only a subset of the upstream permissions. Scope can narrow, but it cannot grow. The identity of an intermediary must not erase the user context that authorizes the work.

Every receiving server must then enforce that scope against its domain rules, independently of the orchestrator’s decision. Databricks Agent Bricks shows fine-grained access control in production through Unity Catalog, which has ownership and end-to-end permissions for agents, models, and tools. Salesforce’s Hosted MCP Servers place authentication and permissions at the hosted server layer. Generally available from April 2026 for Enterprise Edition and above, they let CRM authorization govern queries and changes rather than relying on a separately configured policy layer.

Agent Bricks demonstrates governance across agents and their governed data and tools. Salesforce demonstrates source-domain enforcement at an MCP server. Neither example, by itself, establishes automatic permission synchronization across every enterprise source.

Delegation also needs a defined end and an output boundary. Tokens should have explicit expiry windows tied to the task, with IdP revocation reaching resource servers before natural expiry. MCP-layer data-loss prevention covers paths that application-layer controls can miss, including link-unfurling exfiltration like that found in an earlier Slack MCP implementation. For high-consequence writes, scoped tokens are not enough. Before GitHub’s official hosted MCP server changes a repository, issue, or file, a human should have to review the specific action it will take.

The registry and governance layer that makes propagated permissions auditable at scale

Per-hop checks need an organization-wide record of their authority. A governed registry tracks which agents hold which scopes, who approved them, and when they were last validated. Without it, revocation becomes guesswork at enterprise scale. Policy alone cannot show which server definition or permission grant was in force for a given workflow.

Each agent and server needs someone named as its owner. Changes to tool definitions, permission scopes, and routing rules must be versioned and attributable, while new servers and scope requests pass through approval before registration. The registry also defines who may call each server and invoke its tools. This prevents access scope from becoming something improvised at runtime.

Prefect’s Horizon offers a private MCP registry with cataloging, approval, ownership tracking, and version control, built by the creator of FastMCP. Entra Agent ID complements that server inventory with agent identities, sponsors, sign-in history, and lifecycle controls. Their roles are different but connected. One governs what is exposed, while the identity layer establishes which agents may invoke it.

Teams can reuse a governed skill with its permission model instead of independently rebuilding its prompt, workflow, or server. Compliance adds urgency to that infrastructure.

Department-level propagation in practice: how scoped permissions behave differently across RevOps, Engineering, and Support

Domain experts must define scopes because downstream risks differ by team. In RevOps, Salesforce’s server supports CRM queries covering pipeline stages, contact activity, and account data under hosted authorization. HubSpot’s first-party remote MCP server added write access to core CRM objects in April 2026. That shifts the focus from what an agent is permitted to see to what it is permitted to alter. An agent summarizing pipeline must not use contact-write authority merely because both capabilities are available in its chain.

Engineering adds a different combination risk. GitHub’s official server supports writes to issues, pull requests, and files, while Atlassian’s hosted server supports Jira work items and Confluence pages. Basic reads and writes in Atlassian are free, but enriched cross-product calls use Rovo credits. Price does not define the security boundary. Engineering servers should default to read-only, with repository writes gated by explicit human review of the proposed action.

A CI/CD-connected agent may have repository-write authority and read access to a secrets vault. The architecture must prevent a single tool call from exercising that combined scope without an approval gate. This is where aggregation inference becomes an operational concern. Reviewing each tool’s permissions separately does not settle what the chain can do with them together.

Support shows why permission to read is not permission to redistribute. A support agent may legitimately access PHI, PII, or financial records, while a downstream summarization agent sends output to a less-controlled surface. In the healthcare example, MCP-layer DLP tokenizes PHI inline before it reaches the model’s context window. The original read entitlement must not simply pass through unchanged. The permission boundary covers both the sensitive input and where the summary goes.

What a correctly layered multi-agent MCP permission architecture requires, and what remains unresolved

The deployment requirements follow from these different boundaries. Servers touching shared resources should use remote Streamable HTTP rather than local STDIO deployments that leave audit and revocation gaps at scale. IdP-backed authentication and OIDC-driven team profiles should replace per-app consent and manually maintained allowlists. Every server must authorize each call based on its primitive and what it does within that domain. Task-scoped delegation, a versioned approval-gated registry, and human review gates complete the enforcement model.

Agent Bricks addresses governed access across agents, models, and tools. Salesforce supplies CRM-native authorization at its hosted MCP layer. Entra Agent ID addresses agent identity and lifecycle, while Horizon addresses server registration and governance. None of those roles eliminates the need for the others.

Automatic inheritance is the criterion that connects them. A sustainable platform must preserve connected sources’ permissions, publish governed skills for reuse, and scope every invocation to the requesting user’s entitlement. Otherwise, each AI tool adds another permission system that people must maintain by hand. Avoiding that duplication requires source authority to survive the entire workflow.

Current infrastructure can provide identities, domain checks, registries, DLP, and approval gates. What remains unfinished is the standards answer for transitive delegation, aggregation inference, and temporal validity across organizational boundaries. WIMSE and OAuth token-exchange work point toward that resolution. Enterprises can build enforceable scoped chains now, but interoperable multi-hop authority still requires the emerging standards to mature.

Sources

  1. MCP Architecture Deep Dive: A Complete Enterprise Guide for 2026

More in Enterprise AI Governance