Home/Blog/Why per-request identity is the new linchpin for secure, scalable ai tool integrations

Why per-request identity is the new linchpin for secure, scalable ai tool integrations

October 2, 2026

Why Per Request Identity Is The New Linchpin For Secure Scalable Ai Tool Integrations

AI tool integrations become difficult to secure when an agent, plugin, or background worker can reuse a credential long after the context that justified it has changed. Per-request identity addresses that gap by making the identity and authorization proof part of each tool invocation, rather than relying on a broad session assumption or a reusable bearer token.

For teams operating MCP-connected agents and multi-agent workflows, this is increasingly the practical security boundary: a tool should be able to evaluate who or what made this specific call, which workload holds the required key material, and whether the request is valid now. The standards and platform guidance are converging on short-lived credentials, proof-of-possession, token exchange, and request-level verification as the foundations for secure scale.

Per-request identity makes every AI tool call independently verifiable

Direct answer: Per-request identity means attaching verifiable identity evidence to every protected tool call so the receiving service can authorize that call independently. It reduces reliance on reusable bearer tokens, supports short-lived and federated credentials, and gives AI platforms a security model that works across agents, tools, plugins, and background workloads.

The distinction matters because an AI workflow is rarely a single, stable client-server session. A user may begin a task in one interface, an orchestrator may route it to a specialist agent, and that agent may invoke several internal and third-party tools. Each hop can involve different execution environments, scopes, audiences, and risks.

A traditional bearer token answers a limited question: does the caller possess a token that the resource server accepts? If that token is copied or intercepted, another party may be able to present it. Sender-constrained authorization raises the bar by requiring the legitimate presenter to hold the private key associated with the token or request proof.

Identity should travel with the tool call, not remain an assumption inherited from an earlier session.

RFC 9449 defines Demonstrating Proof of Possession (DPoP) for this purpose. A DPoP proof is carried with an HTTP request, binds the access token to the client’s key, and helps reduce replay risk if a token is stolen. Crucially, the RFC requires a unique DPoP proof for each HTTP request. That moves verification from a session-level convenience to a request-level property.

That model is particularly relevant to AI tool integrations because a tool call is the moment at which data is read, a workflow is triggered, a record is changed, or an external action is taken. It is the point where an authorization system needs the clearest possible evidence.

Why bearer-token assumptions break down in agentic workflows

Bearer tokens remain useful in many systems, but their reuse characteristics can conflict with the way agent fleets operate. An agent platform may run parallel tasks, execute unattended jobs, invoke tools on behalf of different users, and scale across ephemeral infrastructure. A long-lived shared secret or broadly reusable token does not naturally express those distinctions.

Agent workflows create more credential paths

In a simple application, one client may call one API. In an orchestration environment, credentials can be introduced through user authorization, service accounts, workload identity, delegated access, token exchange, or tool-specific configuration. The more paths exist, the more important it is to avoid treating possession of one static credential as permanent authority.

  • Delegated requests

    need to preserve the difference between a user’s authority and an agent’s permitted task.

  • Background workloads

    need an identity model that does not depend on a human browser session remaining active.

  • Specialist agents

    need narrowly appropriate access rather than a platform-wide tool credential.

  • Cross-environment execution

    needs a way to establish trust without distributing the same long-lived secret everywhere.

  • High-impact tools

    need the resource server to evaluate the request presented at the time of use.

Per-request proofs do not make authorization policy unnecessary. They make enforcement more reliable by providing stronger evidence about the requester at the point a policy is evaluated. The resource server can still assess scopes, audience, tenant boundaries, user delegation, task constraints, and the sensitivity of the requested operation.

OAuth guidance positions DPoP for situations where sender-constrained tokens are needed, typically high-security deployments, because the resource server verifies the proof on each request. This is a useful framing for AI tools: not every read-only, low-risk integration requires identical controls, but tool calls that cross trust boundaries or can change systems deserve a stronger default than a reusable bearer credential.

Replay resistance is relevant to tool invocation

Replay is not an abstract protocol concern when a tool call can create a ticket, approve an action, access a dataset, or send an external communication. Binding a token to key possession means a stolen token alone is less useful to an attacker. A unique proof for each request further aligns the credential mechanism with the discrete nature of tool invocation.

This does not eliminate every threat. A compromised workload that still has access to its private key remains a serious incident, and authorization rules can still be too broad. Per-request identity should therefore be treated as one layer in a design that also includes least privilege, short credential lifetimes, constrained delegation, auditability, and sound workload isolation.

DPoP and sender-constrained authorization fit AI tool calls

DPoP is a concrete standards-backed mechanism for request-level proof-of-possession. Under RFC 9449, the client provides a proof with each HTTP request, and the access token is bound to the client’s key. The receiving resource server verifies the proof, rather than relying solely on the token as a bearer artifact.

For platform engineers, the important design insight is not that every tool must use one protocol feature in exactly the same way. It is that tool authorization should recognize the presenter of a credential, not just the credential string. That is the core goal of sender-constrained authorization.

What changes at request time

  1. A workload obtains an appropriate credential.

    This can be through an authorization flow, token exchange, or a federated workload identity source.

  2. The workload produces proof associated with its key.

    With DPoP, the proof is specific to the HTTP request and is unique per request as required by RFC 9449.

  3. The tool or resource server verifies the credential and proof.

    The service checks that the request is presented by the party that holds the relevant private key.

  4. The service evaluates authorization for the requested operation.

    Identity evidence supports, but does not replace, decisions based on the resource, scope, delegation, policy, and task.

  5. The platform records meaningful security context.

    The resulting event can connect an invocation to a workload, tool, request, and authorization outcome.

This sequence is a better match for tool-backed AI than a model in which a powerful token is configured once and silently reused by every agent execution. It permits credentials and proofs to be issued, exchanged, and checked closer to the action.

Mutual TLS (mTLS) is another sender-constraining approach referenced in emerging agent authorization work. The right choice depends on client capabilities, operational environment, certificate management, partner requirements, and the resource server’s supported mechanisms. The enduring architectural requirement is request-level validation of a binding, whether the binding is established through DPoP or mTLS.

Agent authorization is shifting from user sessions to task-aware requests

AI systems need to distinguish several identities that older application designs may have collapsed: the end user, the calling application, the agent, the executing workload, and the task being performed. A secure design does not assume these are interchangeable.

Recent IETF work is explicit about this direction. A draft for delegated AI agent authorization says resource servers MUST verify the DPoP proof or mTLS binding on every protected request. The Agent Authorization Profile similarly includes DPoP or mTLS validation rules and adds agent identity validation plus task binding validation before protected requests are accepted.

Why task binding matters

An authenticated agent is not automatically authorized for every action it could technically request. In an enterprise workflow, the same agent identity may be allowed to summarize a document, retrieve approved data, or create a draft, while being prohibited from changing permissions or initiating an irreversible external action without additional controls.

Task binding is important because it narrows the question from “is this a recognized agent?” to “is this recognized agent performing an approved task under this authorization?” It helps an authorization layer connect identity to intended work instead of granting a generic, durable capability.

  • Validate the

    workload or client identity

    that presents the request.

  • Validate the

    agent identity

    when an agent-specific identity is part of the model.

  • Validate the

    delegated authority

    when the agent acts for a user or another principal.

  • Validate the

    task context

    when policy needs to restrict the purpose or operation.

  • Validate the

    proof binding on every protected request

    when sender-constrained authorization is used.

Not every integration has sufficient protocol support to express all of these signals today. That is a real limitation, not a reason to return to unmanaged shared keys. Teams can begin by separating user, agent, and workload identities in their internal control plane, then progressively adopt tool interfaces and authorization servers that can carry and verify richer context.

The IETF’s active work on agent grants, first-party applications, and browser-based clients with DPoP support reinforces that this is becoming a practical engineering concern. It is not merely a theoretical ideal for identity architectures.

Stateless MCP raises the value of request-level authentication

Stateful protocols can sometimes lean on the continuity of a connection or session, although they still require careful authentication and authorization. Stateless protocols remove much of that implicit continuity. When each interaction is independent, the request itself needs to carry enough trustworthy context to be authenticated and authorized.

Google Cloud’s IAM MCP guidance says MCP version 2026-07-28 changes MCP from a bidirectional, stateful protocol to a stateless protocol. In that model, independently authenticating each request becomes more important because the protocol no longer provides the same stateful channel assumption.

This is a useful principle even where a deployment uses a different MCP version or a non-MCP tool interface: design tool invocations so that authorization does not depend on invisible inherited state. A receiver should be able to decide whether to accept a protected call based on valid credentials, proof, policy, and the request context it receives.

What an orchestration control plane should carry

An orchestration workspace should avoid becoming a place where broad credentials are simply stored and replayed across agents. Instead, it can coordinate identity propagation and policy enforcement while preserving the distinction between the actor, the agent, the task, and the target tool.

  • Route the invocation with the identity context required by the destination tool.

  • Request or exchange short-lived credentials for the specific execution path where supported.

  • Attach sender-constraining proof or use mTLS where the tool endpoint supports it.

  • Preserve correlation between the originating workflow, specialist agent, tool call, and authorization outcome.

  • Prevent one agent’s broad credential from becoming the default credential for unrelated agents or tasks.

There is an important operational boundary here. An orchestration layer can carry context and acquire credentials, but it should not claim to be the sole source of truth for every downstream permission. The resource server remains responsible for accepting or rejecting its protected request. Keeping that decision near the protected resource limits the damage caused by an overly trusting intermediary.

Federated workload identity scales better than shared secrets

Per-request identity becomes practical at scale when the workload can obtain short-lived credentials without operators manually distributing secrets to every runtime. That is the value of workload identity federation: a running workload presents a trusted identity from its environment, then exchanges it for credentials accepted by the target service.

OpenAI documents workload identity federation for API access using several short-lived identity sources: Kubernetes projected service account tokens, AWS identity federation, Azure managed identity, Google Cloud metadata tokens, GitHub Actions OIDC, and SPIFFE JWT-SVIDs. These options reflect a common pattern: establish workload identity from the environment where work actually executes, then use that identity to obtain limited-lived access.

Federation changes the credential distribution problem

With a shared API key, a team must decide where to store it, how to expose it to every worker that needs it, how to rotate it, and how to determine which workload used it. More agents and more execution environments generally mean more copies or more centralized dependency on the same secret.

With federation, the workflow begins from an identity assertion associated with the workload environment. The target service can issue a short-lived credential after validating that assertion. This does not eliminate configuration: trust relationships, allowed audiences, token exchange policy, and runtime identity controls still need careful setup. It does reduce the need to place a long-lived shared secret in every agent runtime.

  1. Choose a trustworthy identity source for each runtime environment.

  2. Configure the target authorization system to recognize the issuer and intended audience.

  3. Limit which workloads can exchange their environment identity for target credentials.

  4. Issue short-lived credentials appropriate to the workload and requested access.

  5. Use request-level proof where supported, and log the resulting tool invocation.

This pattern supports elasticity. Ephemeral jobs, containerized workers, and automation pipelines can establish identity when they run rather than relying on credentials embedded in images, repositories, or static configuration. It also supports cleaner revocation and incident response because a credential with a short lifetime is less likely to remain useful indefinitely.

Federation is not a substitute for authorization design. If every federated workload can exchange for a highly privileged token, the secret-sprawl problem may improve while over-authorization remains. Scope, audience, task boundaries, and tool-level policy must still be deliberately constrained.

OAuth 2.1-compatible tool access is more workable than custom key injection

Tool integration constraints matter when choosing an identity pattern. OpenAI’s MCP authentication guidance notes that ChatGPT cannot present custom API keys or customer-provided mTLS certificates. The guidance instead emphasizes OAuth 2.1-compatible identity provider capabilities such as discovery, client registration, and token exchange for tool calls.

The practical lesson is to design integrations around supported, standards-oriented identity exchanges rather than expecting every AI client to handle an organization’s bespoke credential format. OAuth-compatible discovery and registration reduce friction in connecting clients to authorization infrastructure, while token exchange provides a mechanism to obtain an access token suited to a downstream call.

Use the right mechanism for the execution model

A browser-mediated user interaction, a hosted AI client, a server-side orchestrator, and an unattended workload do not have identical identity capabilities. Treating them as though they do can lead to brittle integrations or insecure workarounds.

  • Interactive tool calls

    may need an OAuth-based flow compatible with the client’s supported registration and discovery model.

  • Server-side agent execution

    may use workload federation and token exchange to obtain short-lived access.

  • High-security protected resources

    may require sender-constrained tokens using DPoP or mTLS.

  • Certificate-capable environments

    can use certificate-backed patterns where supported by both client and API.

OpenAI also documents a certificate-backed token exchange workflow in which an X.509 certificate is used to obtain a short-lived bearer token, after which the bearer token and an accepted client certificate are sent to an API mTLS endpoint. This demonstrates that short-lived token issuance and client-certificate authentication can work together rather than being competing approaches.

Teams should not infer that one mechanism universally replaces the others. DPoP is valuable where HTTP request proofs are practical; mTLS can be appropriate where certificate operations and endpoint support are available; federation is especially useful for establishing workload identity; and OAuth-oriented flows address interoperability for delegated access. The architecture should select supported controls for each trust boundary while preserving the central rule: verify identity and authorization as close to each tool request as possible.

How to implement per-request identity without disrupting every integration

A complete migration rarely happens in one release. Existing tool ecosystems may include APIs that only accept bearer tokens, vendor services with fixed authentication methods, and legacy automations built around static secrets. The goal is to improve the highest-risk paths first while establishing an architecture that can adopt sender-constrained and federated patterns over time.

Start by mapping the identity behind each call

For every sensitive tool, identify the end user if applicable, the agent, the executing workload, the authorization server, and the resource server. Then identify whether the credential is shared, how long it lives, whether it is audience-bound, and whether the recipient can verify proof of possession on each request.

That inventory often reveals a key problem: one credential may be standing in for multiple identities. For example, a single integration secret can obscure which agent acted, which workflow initiated the call, or whether the request was user-delegated. Separating these concepts in the control plane is an immediate improvement even before every endpoint supports DPoP or mTLS.

Prioritize the tool calls with the greatest consequence

Focus first on tools that expose sensitive information, mutate production systems, execute financial or operational actions, or cross organizational boundaries. These calls benefit most from short-lived credentials, narrower scopes, explicit task context, and per-request verification.

  1. Remove unnecessary shared credentials

    from agent prompts, source repositories, and broadly available runtime configuration.

  2. Adopt federated workload identity

    where a supported environment identity source is available.

  3. Use token exchange

    to issue access that is short-lived and targeted to the receiving service.

  4. Enable DPoP or mTLS

    for protected APIs that support sender-constrained authorization.

  5. Enforce agent and task checks

    where agent-specific authorization context is available.

  6. Instrument decisions

    so security teams can associate tool calls with workflows, workloads, agents, and outcomes.

Design for graceful capability differences

Some external tools will not yet support DPoP, mTLS, token exchange, or the agent-context claims a platform would prefer. Avoid weakening every integration to the lowest common denominator. Instead, classify integrations by their available security capabilities and apply compensating controls to lower-capability paths, such as tighter scopes, shorter token lifetimes where possible, isolated connectors, restricted network placement, and explicit approval boundaries for sensitive actions.

Equally, avoid turning a request-proof rollout into an opaque platform feature. Product and operations teams need clear answers to practical questions: which agent can call which tool, under what delegated authority, with what task limitations, and what will happen when a credential cannot be exchanged or a proof fails validation. Reliable controls are controls that can be operated and investigated.

What secure, scalable AI tool integration looks like in practice

A mature design does not treat agent identity as a label added for logging after a tool call has already been authorized. It treats identity as input to authorization, and it treats the request as the unit at which access is evaluated.

In practice, that means an orchestration system routes work to specialist agents without giving every agent unrestricted standing access to every tool. Workloads establish identity through supported federation methods, acquire short-lived credentials through appropriate exchanges, and present request-level proof or mTLS bindings where required. Resource servers validate the protected request and apply policies that account for the workload, agent, delegated user, task, and target operation.

The result is not zero trust in the marketing sense and not a guarantee against compromised code or bad policy. It is a more defensible chain of evidence for every action: the caller had a valid identity, held the required key or certificate where sender-constraining applied, obtained access through an approved path, and made a request that matched the tool’s policy.

Per-request identity is becoming the linchpin because AI integrations are becoming more distributed, more autonomous, and more dependent on tools that act on real systems. Build identity into the invocation path now: use short-lived federated credentials where possible, adopt DPoP or mTLS for sender-constrained access where supported, and make agent and task context first-class inputs to tool authorization.