AI Agent Identity and Delegation: How to Trace an Agent's Action Back to the Person Who Authorized It
Shared service accounts hide who authorized an AI agent's action. What NIST's 2026 agent identity work says about delegation, and how government programs can specify agent identities, on-behalf-of tokens, and audit records.
When an AI agent changes a record in a government system, the system’s access log names whoever presented the credential. In many agent deployments today that is a shared service account. The log shows that the agent platform made the change. It does not show which agent, working on which task, for which person.
That gap matters for incident response and for an authorizing official reviewing the system. This post covers what the National Institute of Standards and Technology (NIST) has published on agent identity in 2026, and how a program office or security team can write requirements for it.
What NIST has published so far
In February 2026, the NIST National Cybersecurity Center of Excellence (NCCoE) released a concept paper, Accelerating the Adoption of Software and AI Agent Identity and Authorization. It proposes a project to demonstrate how existing identity standards apply to agents, and it asks questions that most deployments have not yet answered, including:
- “How do we handle delegation of authority for ‘on behalf of’ scenarios?”
- “How do we bind agent identity with human identity to support ‘human-in-the-loop’ authorizations?”
- “How do we ensure non-repudiation for agent actions and binding back to human authorization?”
On September 29, 2026, NIST announced that more than 600 commenters had responded and published a summary of the comments. The first demonstration will cover agents in the software development lifecycle.
The summary is not yet guidance, but it shows where practitioners agree. Four points are useful for anyone writing requirements now:
- Most commenters preferred building on existing standards over a new agent-specific stack.
- Agents should have distinct, verifiable identities, with a stable identity anchor and short-lived credentials bound to it.
- Delegated authority should narrow at each hop, so that a sub-agent “never inherits more access than required.”
- Authorization decisions should come from deterministic policy. The summary reports “very strong opposition” to using language models “as the primary or sole arbiter of authorization decisions.”
Three ways an agent can reach a system
The practical question is what credential the agent presents when it calls a system, and what that system can learn from it. There are three common patterns.
| Pattern | What the target system’s log records | What limits the agent’s access | Can one task be revoked? |
|---|---|---|---|
| Shared service account | The platform account only | Whatever the account was granted, for every user and task | No. Disabling the account stops all agents |
| User’s own token passed to the agent | The user, as if they acted directly | Everything the user can do | Only by ending the user’s session |
| Delegated token naming both parties | The person who authorized the task and the agent that acted | The scope written into the token for this task | Yes. The token is specific to the task |
The second pattern is impersonation. The agent can never exceed the user’s rights, but the record cannot distinguish what the person did from what the agent did, and the agent carries the person’s full access into every tool call.
The third pattern is delegation. The distinction is defined in RFC 8693, OAuth 2.0 Token Exchange, published in 2020: under delegation, the acting party “still has its own identity” separate from the party it acts for, and the token carries an actor claim that records the delegation. Commenters to NIST listed token exchange among the highest-priority building blocks, alongside workload identity frameworks such as SPIFFE for authenticating the agent’s software itself.
What to require of an agent identity
Federal identity programs already issue credentials to non-person entities such as servers and service accounts. An agent differs in two ways: its actions are not fully predictable in advance, and one platform may start and stop many agent instances in an hour.
A stable anchor per agent, registered before use. The anchor ties the agent to the software artifact that implements it, the organization that operates it, and the account of the person who approved its deployment. One commenter quoted by NIST proposed a minimum identity record that includes model version and provenance, the governing authorization policy, the parent agent in a multi-agent pipeline, and the human account that authorized deployment.
Short-lived credentials per task. The credential is issued when a task starts, names the task, and expires when the task ends or times out. Compromise of one credential then exposes one task.
Delegation that names both the person and the agent. Each token carries the authorizing person as its subject and the acting agent as its actor. When an orchestrating agent hands work to a sub-agent, the sub-agent receives a new token with a narrower scope and the full chain of actors.
A decision point outside the model. A policy engine evaluates each request against written rules, using the token’s contents. The model can propose an action. It does not decide whether the action is permitted.
Records that capture authority as well as action. For each call, the log holds the subject, the actor chain, the scope, the policy decision, and any human approval. This extends the audit record described in our earlier post on scoped authority and approval tiers, and it relies on the same enforcement point as the gateway in our post on securing agent tool connections.
An illustrative example: a dependency patch in a software factory
Consider a hypothetical government software factory. A release engineer asks an orchestrating agent to update a library with a known vulnerability in one service. The orchestrator assigns the code change to a coding agent and the rollout to a deployment agent. All names and durations here are illustrative.
With a shared service account, the repository shows that “agent-platform” pushed a commit and the deployment system shows that “agent-platform” started a rollout. Three months later, an incident review asks who authorized that change. Answering means matching timestamps against the agent platform’s own logs, if they were kept.
With delegation, the sequence is different:
- The engineer signs in and approves the task. The identity service issues the orchestrator a token with the engineer as subject, the orchestrator as actor, scope limited to that one repository, and a 30-minute lifetime.
- The orchestrator exchanges that token for a narrower one for the coding agent: write access to a single branch, no merge rights.
- The deployment agent receives a token that permits rollout to the staging environment only. Production is outside what the engineer’s approval can delegate, so that step waits for a second named approver.
- The repository and deployment logs each record the engineer, the agent instance, and the token identifier.
The incident review reads the answer from those records. If the coding agent had been manipulated into attempting a push to another repository, the policy engine would have refused it, because the token did not cover it.
Questions for suppliers of agent platforms
- Does each agent instance have its own identity, or do all agents share a platform credential?
- When an agent calls our systems, does the token identify both the authorizing user and the agent?
- Does scope narrow when one agent delegates to another, and where is that enforced?
- Can we revoke a single task’s credentials without stopping other work?
- Is the authorization decision made by a policy engine that we can inspect and test, separately from the model?
- Which existing standards does the product use, and can it work with our identity provider?
NIST’s practice guide is still to come, and details will change. Requirements written around distinct agent identities, task-scoped delegation, and deterministic policy follow the direction the comment summary describes.
How this connects to our work
AEGIS coordinates AI agents for cyber inspection and defensive validation, with each conclusion bound to an evidence chain and operations under human supervision. MissionGuard checks the outputs of autonomous planning against declared mission contracts and records a structured fault card when one is violated.
If your program is deploying AI agents and needs to show who authorized each action they take, we would be glad to talk through agent identities, delegation, and audit requirements. Contact QuantumWorks.