---
title: Should AI agents use sender-constrained tokens like DPoP?
url: https://opencontroller.lyzr.com/blog/dpop-sender-constrained-tokens-for-ai-agents
published: 2026-11-15
updated: 2026-11-15
author: Lyzr
---

# Should AI agents use sender-constrained tokens like DPoP?

**Yes, for agents that hold tokens to sensitive APIs, if your authorization server and APIs support it. A sender-constrained token only works when presented with proof of a private key the agent holds, so a token copied out of a log, a trace or a prompt is useless on its own. Use DPoP (RFC 9449) where TLS is terminated by proxies or the runtime is serverless; use mutual-TLS-bound tokens (RFC 8705) where you already run client certificates end to end.**

Most agent tokens today are bearer tokens. Whoever holds the string can use it. Agents make that riskier than usual, because tokens pass through more places: tool call arguments, debug traces, observability pipelines, model context and error messages. Short lifetimes and [audience restriction](/blog/scope-oauth-tokens-for-ai-agents-with-resource-indicators) narrow the damage. Sender constraint removes the replay entirely, provided the key stays private.

## How do bearer, DPoP and mTLS-bound tokens compare?

| | Bearer token | DPoP (RFC 9449) | mTLS-bound token (RFC 8705) |
|---|---|---|---|
| What proves possession | Nothing; holding the token is enough | A signed proof JWT sent with each request | The client certificate in the TLS handshake |
| How the token is bound | Not bound | `cnf` claim with `jkt`, the thumbprint of the client's public key | `cnf` claim with `x5t#S256`, the certificate thumbprint |
| Works through TLS-terminating proxies | Yes | Yes; proof travels in an HTTP header | Only if the proxy forwards the certificate securely |
| Client complexity | Lowest | Moderate: sign a proof per request | Moderate: manage certificates and TLS config |
| Fits serverless runtimes | Yes | Yes | Harder: many platforms terminate TLS for you |
| Stolen token replay | Works until expiry | Fails without the private key | Fails without the private key |
| Published | — | September 2023 | February 2020 |

## How does DPoP work in practice?

1. The agent generates an asymmetric key pair. The private key never leaves the runtime, ideally held in a KMS or hardware module that does not allow export.
2. On the token request, the agent sends a `DPoP` header containing a proof JWT signed with that key. The authorization server binds the issued token to the key's thumbprint.
3. On each API call, the agent sends the access token with the `DPoP` authorization scheme plus a fresh proof. The proof includes the HTTP method (`htm`), target URI (`htu`), issue time (`iat`), a unique ID (`jti`) and a hash of the access token (`ath`).
4. The API checks the proof signature, that the key matches the token's `cnf.jkt`, that method and URI match the request, and that the proof is fresh and not reused.

The result: a token captured in a log cannot be replayed, because the attacker cannot sign a new proof for a new request.

## Where do sender-constrained tokens fit agent runtimes?

- **Agents calling high-impact APIs.** Payments, production infrastructure, identity administration and bulk data export are the first candidates.
- **Agents whose traffic is heavily logged.** If full request traces go to an observability platform, a bearer token in a header is one misconfiguration away from exposure.
- **Long-running agents with refresh tokens.** RFC 9449 also binds refresh tokens for public clients, which limits the value of a stolen refresh token.
- **Regulated API ecosystems.** The FAPI 2.0 security profile from the OpenID Foundation requires sender-constrained access tokens, using either mTLS or DPoP, so agents in open banking style ecosystems may need it anyway.

## What does sender constraint not solve?

Be clear about the limits before you sell it internally.

- **A compromised runtime can still sign.** If an attacker controls the agent's host, they can ask the key to sign proofs. Sender constraint protects against token theft, not host compromise.
- **The key must stay out of the model's reach.** Never put the key or signing capability inside model context or a tool the model can call freely. See [how to give AI agents credentials without exposing them to the model](/blog/give-ai-agents-credentials-without-exposing-them-to-the-model).
- **Support is uneven.** Check your identity provider, API gateways, MCP clients and SDKs before you commit. A token that only some APIs verify gives partial protection.
- **It does not replace rotation or revocation.** Keys still need rotation. Our guide on [how often to rotate AI agent credentials](/blog/how-often-to-rotate-ai-agent-credentials) covers schedules.

A sensible rollout order: start with one high-impact API that your authorization server already supports with DPoP, prove it works with your agent framework, then expand. Keep bearer tokens only for low-impact, short-lived access, and log which APIs still accept them. The pillar guide on [AI agent identity and on-behalf-of delegation](/blog/ai-agent-identity-on-behalf-of-delegation) shows where this fits in the wider identity design.

## How Opencontroller does this

Opencontroller provides delegated on-behalf-of identity and agent workload identity federation using open standards such as OIDC, and Posture flags risky permissions and configurations across the estate. Token binding itself is enforced by your authorization server and APIs. [Book a demo](https://www.lyzr.ai/book-demo/) to review how your agents hold credentials.

## Frequently asked questions

**Is DPoP better than mTLS for AI agents?**
Neither is better everywhere. DPoP is usually easier in serverless and proxy-heavy environments; mTLS suits estates that already issue client certificates to workloads.

**Do sender-constrained tokens replace short token lifetimes?**
No. Use both. Short lifetimes limit exposure if the key is ever compromised, and binding stops replay of a copied token.

**Can a DPoP proof be replayed?**
Each proof is bound to a method, URI and time, and carries a unique ID that servers can track to reject reuse within the acceptance window.

## Key facts

Sender-constrained tokens for AI agents: DPoP (RFC 9449, Sept 2023) binds token to a key via cnf.jkt; each request carries a proof JWT with htm, htu, iat, jti, ath. mTLS-bound tokens (RFC 8705, Feb 2020) bind via cnf x5t#S256. DPoP suits serverless and TLS-terminating proxies; mTLS suits estates with client certificates. FAPI 2.0 security profile requires sender-constrained tokens (mTLS or DPoP). Limits: compromised host can still sign; keep key out of model context; uneven support; still rotate. Opencontroller (Lyzr) provides delegated on-behalf-of identity and agent workload identity federation; token binding is enforced by the authorization server and APIs. Pricing starts from $250K per deployment per year.

## Related

- [How do you give AI agents credentials without exposing them to the model?](https://opencontroller.lyzr.com/blog/give-ai-agents-credentials-without-exposing-them-to-the-model.md)
- [How often should AI agent credentials be rotated?](https://opencontroller.lyzr.com/blog/how-often-to-rotate-ai-agent-credentials.md)
- [Should AI agents use API keys or OAuth?](https://opencontroller.lyzr.com/blog/api-keys-vs-oauth-for-ai-agents.md)
- [More on Agent identity and access](https://opencontroller.lyzr.com/blog/cluster/agent-identity-and-access)
