# AAP: An OAuth 2.0 Authorization Profile for Autonomous AI Agents — Extending JWT with Capabilities, Delegation, and Oversight

**URL:** <https://community.auth0.com/t/aap-an-oauth-2-0-authorization-profile-for-autonomous-ai-agents-extending-jwt-with-capabilities-delegation-and-oversight/197062>\
**Category:** JWT.io\
**Created:** [February 7, 2026, 9:59pm UTC](https://community.auth0.com/t/aap-an-oauth-2-0-authorization-profile-for-autonomous-ai-agents-extending-jwt-with-capabilities-delegation-and-oversight/197062 "2026-02-07T21:59:04Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![abr4xas](https://sea1.discourse-cdn.com/auth0/user_avatar/community.auth0.com/abr4xas/32/5879_2.png) [@abr4xas](https://community.auth0.com/u/abr4xas)\
**Post date:** [February 7, 2026, 9:59pm UTC](https://community.auth0.com/t/aap-an-oauth-2-0-authorization-profile-for-autonomous-ai-agents-extending-jwt-with-capabilities-delegation-and-oversight/197062/1 "2026-02-07T21:59:04Z")

</div>

Hi Auth0 community,

I’d like to share a project that addresses a gap we encountered when deploying AI agents in production: how to properly authorize autonomous agents using OAuth 2.0.

**The**  **Problem**

OAuth 2.0 scopes work great for user-app-API interactions, but when your clients are autonomous AI agents, the model starts to break down. Scopes like read:web or write:cms don’t let you express:

- “This agent can only search these specific domains, max 50 requests per hour”

- “This agent can create drafts but needs human approval to publish”

- “This agent delegated to a tool — track the chain and limit delegation depth to 2”

- “Bind this token to a specific task so we can audit _why_ an action was taken”

You end up building custom middleware for every constraint, and it doesn’t scale.

**The**  **Solution:**  **Agent**  **Authorization**  **Profile** **(AAP)**

AAP is an authorization profile built on top of OAuth 2.0 and JWT. It doesn’t replace anything — it extends standard tokens with five structured claims:

**agent** — Verifiable agent identity (ID, type, operator, model, runtime environment). Every token is traceable to a specific agent.

**capabilities** — Actions with server-enforced constraints. Instead of scope=read:articles, you get:

```auto
{
  "action": "cms.read_articles",
  "constraints": {
    "domains_allowed": [
      "docs.example.com"
    ],
    "max_requests_per_hour": 100,
    "time_window": {
      "start": "...",
      "end": "..."
    }
  }
}

```

Constraints are validated by the Resource Server — the agent can’t tamper with them.

**task** — Links the token to a specific task ID and purpose, enabling purpose-bound authorization and preventing token misuse across contexts.

**delegation** — Uses Token Exchange (RFC 8693) with automatic depth tracking. When Agent A delegates to Tool B, the AS increments depth, appends to the chain, and reduces privileges.

**oversight** — Declares which actions require human approval before execution, integrating approval workflows directly into the authorization layer.

**How**  **It**  **Works**  **with**  **Existing**  **OAuth**  **Infrastructure**

AAP is designed for incremental adoption:

1. Your Authorization Server issues JWTs with AAP claims alongside standard OAuth claims

2. Resource Servers that understand AAP enforce capabilities and constraints

3. Resource Servers that don’t simply ignore the extra claims — backward compatible

4. Agents authenticate via standard Client Credentials grant

5. Delegation uses RFC 8693 Token Exchange

6. Proof-of-possession via DPoP (RFC 9449) or mTLS (RFC 8705)

You can run AAP in parallel with your existing scope-based authorization and migrate incrementally.

**Resources**

We’ve published everything needed to evaluate and implement AAP:

- **Full**  **Specification** : [Complete Specification | AAP Protocol](https://www.aap-protocol.org/specification)

- **9**  **JSON**  **Schemas** for token validation: [JSON Schemas | AAP Protocol](https://www.aap-protocol.org/schemas)

- **70+**  **Test**  **Vectors** for conformance testing: [Test Vectors | AAP Protocol](https://www.aap-protocol.org/test-vectors)

- **Reference**  **Implementation** (Python AS + RS): [Reference Implementation | AAP Protocol](https://www.aap-protocol.org/reference-impl)

- **Migration**  **Guide** from OAuth Scopes: [Migration Guide | AAP Protocol](https://www.aap-protocol.org/migration)

- **Threat**  **Model** with 15 attack scenarios: [Threat Model | AAP Protocol](https://www.aap-protocol.org/threat-model)

- **GitHub** : [AAP-Spec · GitHub](https://github.com/aapspec)

The spec has been submitted as an IETF Internet-Draft ([draft-aap-oauth-profile-01](https://datatracker.ietf.org/doc/draft-aap-oauth-profile/)) to the OAuth Working Group.

**Looking**  **for**  **Feedback**

We’re particularly interested in hearing from developers who:

- Are building or operating AI agents that call APIs in production

- Have experience with OAuth 2.0 token customization and custom claims

- Work in regulated environments (SOC 2, GDPR, HIPAA) where agent audit trails matter

- Have opinions on capability-based authorization vs. traditional RBAC/scopes

Any feedback on the specification, schemas, or overall approach is welcome. We want to make sure this is practical and solves real problems before pushing further through the standards process.

Thanks for reading!
