Skip to main content
Back

AI Agents Are Leaking Permissions and This Framework Formally Stops It

A new formal framework treats AI agent delegation as a contractual primitive, solving the recursive permission chain problem that OAuth and IAM systems can't handle.

Paper, Full Access
  • Core problem: Existing IAM systems and OAuth cannot handle recursive AI agent delegation chains, scope attenuation, or dynamic authorization.
  • Key idea: The paper reframes delegation as a contractual primitive with formal semantics, not just a token hand-off.
  • Compositional operator: A new overlay operator adds agentic governance rules (recursive delegation, scope bounds) on top of existing authorization policies without rewriting them.
  • Scope attenuation enforced: Each hop in a delegation chain can only reduce permissions, never expand them -- formalized as a monotone constraint with proofs.
  • Validated on financial systems: The framework is empirically applied to a financial domain, demonstrating correct enforcement of delegation bounds and accountability traceability.
  • No code released: The paper is a formal specification; no SDK or production implementation is currently available.

Every time an AI agent hands off a subtask to another agent, something subtle and dangerous can happen: permissions leak, accountability chains break, and no existing system has a formal way to stop it. A new paper from Amjad Ibrahim and Yong Li proposes a compositional governance framework that treats delegation itself as a first-class, contractual primitive, rather than a side effect of token passing.

The gap nobody plugged

The shift from AI models to AI agents changed the security threat model entirely. AI agents call APIs, execute code, manage files, and make decisions with minimal human oversight. That autonomy is the point, but it creates a structural problem for authorization systems that were designed around humans clicking consent screens.

Agents are ephemeral, operate at massive scale, form complex multi-hop delegation chains, and collaborate across domains and clouds. The standard toolkit was not built for this. OAuth has no concept of delegation chains, and in practice OAuth primarily treats tokens as impersonation rather than delegated authority. When Agent A spawns Agent B which calls Agent C, accountability chains fracture -- no system tracks which agent authorized which sub-agent to act or what permissions were passed along.

The deeper problem is structural. Every trust domain requires its own authorization server, with no mechanism for cross-domain token verification without pre-established federation. OAuth tokens are opaque to intermediaries: delegation via token exchange produces a new token with no record of the original authorization chain. And OAuth provides no holder-side scope attenuation -- only the authorization server can narrow scopes at issuance time.

Architecture diagram showing delegation flow, hierarchical scoping, and containment relationships between user, agent, delegates, session, scope, and resource entities

Delegation as a contract, not a token

The core conceptual move in this paper is reframing what delegation means. Rather than treating it as a credential hand-off (the OAuth model), the authors treat it as a contractual term with explicit semantics: who is delegating, what scope is being granted, for how long, and what accountability obligations transfer with it.