Skip to content
Agentic Control Plane

AI Agent Identity: How Your Backend Knows Who an Agent Acts For

David Crowe David Crowe · · 3 min read
identity
Share X HN LinkedIn

When a person logs in, your identity stack does its job. Okta or Active Directory checks who they are, enforces MFA, and writes the login to an audit trail. When an AI agent then acts for that person, most of that stops. Your backend sees a valid credential and has no idea which user’s request it is serving.

Three parties, not two

Traditional login has two parties. A user presents credentials to a service, and the service issues a token. OAuth 2.0, OIDC and SAML all assume that shape.

An agent adds a third party. The user signs in to an LLM app such as ChatGPT, Claude or Cursor. The model decides to call a tool on your backend. It makes that call with a shared API key or a service account token. Your backend sees a valid credential and does the work.

When a person calls an API, the token shows who they are. When an agent calls it for them, the token shows that the agent exists. It doesn’t show who the agent is acting for. That missing link between the user and the agent’s action is the three-party identity problem.

What your IAM stack doesn’t cover

Your identity provider handles user-to-application login well. It was not built for these:

  • Delegated agent identity. An agent acting for a user, with proof of the delegation.
  • Per-agent permissions. Giving an agent a subset of the user’s access instead of all of it.
  • Multi-hop identity. User, then orchestrator, then sub-agent, then tool, with the user still named at every step.
  • Agent-only revocation. Cutting off an agent without ending the user’s session.

OAuth 2.0 does have a standard that fits: token exchange (RFC 8693). It swaps one token for another with a different scope or audience, which is what agent delegation needs. From what we’ve seen, most MCP servers and agent frameworks don’t use it yet.

The OWASP Top 10 for Agentic AI lists tool misuse, privilege escalation and unauthorized actions. Several of those get worse when the backend can’t tell whose request it is serving.

What agent identity needs

Five things.

Identity binding. Each agent request carries a verifiable token tied to the user: their sub, scopes and tenant. No shared API key. The agentic control plane checks that token against your identity provider’s JWKS endpoint on each request.

Delegation context. The token says which agent is acting, for whom, and with what authority. A JWT with sub (the user), actor (the agent), scope (allowed actions) and aud (the target service) can carry that.

Scope inheritance. An agent never gets more than the user has. If the user holds tool:crm:read, the agent can’t pick up tool:crm:write.

Audit trail. The log shows user, agent, tool and outcome, with verified identity at each step. Identity-attributed audit logging lets you query it by user, agent, time window or action.

Revocation. You can cut off an agent without touching the user’s credentials. Rotating an agent token shouldn’t force a password reset.

Here is what identity binding looks like with GatewayStack’s identifiabl module:

import { identifiabl } from "@gatewaystack/identifiabl";

// Every MCP tool call passes through identity verification
app.use(identifiabl({
  issuer: process.env.OAUTH_ISSUER!,   // Your OIDC provider
  audience: process.env.OAUTH_AUDIENCE!, // Your API identifier
}));

// Downstream middleware receives verified identity:
// req.user = {
//   sub: "auth0|8f3a2b1c",
//   scope: "tool:crm:read tool:jira:write",
//   org_id: "org_acme_corp"
// }

With this in place, requests carry the verified identity of the user who started them, instead of a shared key.

Why compliance cares

SOC 2 Type II asks for access controls tied to a named identity. GDPR and CCPA give people rights over their personal data, including knowing who accessed it and how. None of them mention AI agents by name. All of them apply when an agent touches covered data for a user. “The service account did it” doesn’t answer any of those questions. We are not lawyers, so check the details for your case with yours.

Where to start

Ask one question. Does your backend know which user started each request an agent makes?

If the answer involves a shared API key or a service account, you have the gap. Close it in the infrastructure layer, not inside each app.

View identifiabl on GitHub → · See managed ACP pricing → · Get started →

Running coding agents? ACP records each tool call its hook sees and makes the dangerous shell commands (a force-push, destructive SQL, curl | sh) wait for you. One command, free up to 5 agents:

macOS · Linux · WSL
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
Windows · PowerShell
irm https://agenticcontrolplane.com/install.ps1 | iex

What the installer writes  ·  Getting started

Share X HN LinkedIn
Get the next data drop
What agents actually cost, new tool-surface captures, and the occasional incident post-mortem — sent when we publish something worth your inbox, not on a schedule. Unsubscribe anytime.
Share: Twitter LinkedIn
Related posts

← back to blog