NIST AI Agent Identity and Authorization: What It Means for Your Infrastructure
This post describes where NIST’s work stood in mid-March 2026. Dates, comment counts and the comment window are as of then.
NIST wants AI agents treated as identifiable entities, not anonymous automation running on shared credentials. If you build agent infrastructure, read the concept paper.
On February 17, 2026, NIST’s Center for AI Standards and Innovation launched the AI Agent Standards Initiative. The NCCoE published a concept paper called “Accelerating the Adoption of Software and Artificial Intelligence Agent Identity and Authorization.” Its public comment period was set to close in early April 2026. It’s the first time the U.S. federal government has stepped in at the national level to set interoperability and security standards for autonomous agents.
What NIST published
The initiative has three parts: industry-led standards, community-led open source protocols (with an explicit nod to MCP), and research on security and identity. A Request for Information, published in the Federal Register on January 8, 2026, drew 932 comments before it closed on March 9.
NIST sorted the work into six areas:
- Agent identity and authentication. Agents are first-class identities, not service accounts.
- Stricter authorization. Deny by default, with scopes checked on each action.
- Monitoring after deployment. Trust is checked continuously, not once at launch.
- Prompt injection as an architecture problem. Not only a model problem or an input-validation problem.
- Interoperability. Identity that travels across platforms, whatever the model or framework.
- Human-agent interaction. Clear session boundaries, delegated authority and revocation.
The protocols it names are OAuth, OpenID Connect, SCIM, SPIRE and NGAC. They’re ordinary identity infrastructure, not AI inventions. NIST is putting agent identity in the same category as human identity.
What the RFI respondents said
The OpenID Foundation’s response put it this way: “The most urgent AI agent security risks are not technical failures, but failures of trust.”
They argue for a “trust fabric” that checks credentials automatically, because without automatic checks, systems default to allowing everything. That describes a lot of what’s deployed today: shared API keys, service accounts with admin access, and agents running with whatever permissions the person who set them up had.
NIST has also shown interest in MCP as a candidate interoperability standard. MCP has adoption but, on its own, no authorization policy or audit log. The W3C governance discussion (issue #96 on the WebMCP repo) bears on this too. If you build MCP servers now, plan for an identity layer you can slot in later. Adding one afterward costs more than designing it in.
Where this is likely heading
Legal analysts who follow NIST’s AI work describe a pattern. Voluntary guidelines become industry standards. Standards become sector rules. Rules become litigation risk.
NIST’s AI Risk Management Framework went from voluntary publication to being cited in executive orders and state AI laws within about 18 months.
Cloud security followed the same path. NIST SP 800-53 started as guidance, became the baseline for FedRAMP, then the de facto standard for anyone selling to the federal government, then an influence on commercial frameworks. The voluntary stage was the time to get ahead. Agent identity looks to be on a similar track. That’s a forecast, not something NIST has said.
What NIST’s asks mean for your infrastructure
Strip away the policy language and the concept paper reads like a list of infrastructure requirements.
A unique, lasting identifier per agent
Not a shared API key. Not a service-account token that fifteen agents use. Each agent gets its own identifier, tied to the user it acts for, the organization it belongs to and the permissions it holds. That’s identity binding.
Lifecycle management
Agents need provisioning, updates and revocation, like human users do. When an employee leaves, their agent’s access ends. When a role changes, the scopes narrow. When a project ends, the credentials are revoked. None of that works on a shared API key, because there’s no identity to revoke.
Scoped permissions per agent
The authorization asks fit deny-by-default: an agent starts with no permissions and gets only the scopes granted to it. The paper warns about agents inheriting their user’s full privileges. An agent running on its own at machine speed shouldn’t hold the same trust as a person making a deliberate choice.
So the agent’s permissions should be a strict subset of the delegating user’s. If the user has tool:crm:read, the agent can’t escalate to tool:crm:write. RFC 8693 already describes this pattern for token exchange. NIST is backing it at the policy level.
Authenticated agent-to-agent calls
When an agent hands work to a sub-agent, every hop needs authenticated identity: user to orchestrator to sub-agent to tool, with attribution kept at each step. The three-party problem turns into a four-party problem, then five. Without identity passed along, you lose the trail after the first hop.
Authorization that adapts at runtime
Static roles checked at session start don’t meet the bar. The paper describes runtime authorization: a check on each call that takes context and earlier actions into account. An agent that ran three harmless CRM queries and then tries to export the whole contact list should get a different answer on the fourth call.
How agents authenticate today
Most agent deployments use one of three patterns:
- Shared API key. One key for everyone. No attribution, no per-user log.
- Service account. The agent authenticates as itself, not as the user it acts for, so the chain of delegation breaks.
- User token passthrough. Better, but it usually hands the agent the user’s full permissions.
Each misses something NIST asks for. Pattern 1 has no identity. Pattern 2 has the wrong identity. Pattern 3 has the right identity with too many permissions.
The fourth pattern is delegated identity with restricted scope. Here’s how it looks with GatewayStack, the open source library behind ACP:
// Pattern 4: Delegated identity with scope restriction
import { identifiabl } from "@gatewaystack/identifiabl";
app.use(identifiabl({
issuer: process.env.OAUTH_ISSUER!,
audience: process.env.OAUTH_AUDIENCE!,
}));
// Every agent request now carries:
// req.user.sub → "auth0|8f3a2b1c" (verified user)
// req.user.scope → "tool:crm:read" (restricted scope)
// req.user.org_id → "org_acme_corp" (tenant context)
// agentName → "sales-bot" (agent attribution, via x-agent-name)
The token is verified, the scope is narrower than the user’s, and each call is attributed. The pattern isn’t new. RFC 8693 has existed since January 2020. What’s new is a federal standards body signaling it matters.
Prompt injection as architecture
NIST puts prompt injection next to identity and authorization, not next to model safety. That moves the defense. Input validation lives in the application. Architecture lives in the layer between the agent and your backend.
If you treat injection as a model problem, you work on prompts, fine-tuning and guardrails inside the model. If you treat it as an architecture problem, you add policy checks on each tool call, you limit what a tricked agent can reach, and you keep a log that shows what was tried and what was blocked. A control plane does the second kind of work. It reduces what a successful injection can do. It doesn’t stop the model from being fooled.
You don’t need to wait for the final standard
NIST was still taking comments, and finished standards are likely months or years away. But the direction is stable. Agent identity, deny-by-default authorization, per-call checks, attributed audit logs and authenticated agent-to-agent calls show up across NIST, the Cloud Security Alliance, OWASP and most serious analyses of agent design. Compliance details will change. The architecture probably won’t.
Where to start
Three steps, in order.
-
Audit how your agents authenticate. Shared keys, service accounts or user token passthrough? If any agent request reaches your backend without a verified user attached, you have the gap NIST is aiming at. Understand the identity problem.
-
Move toward deny by default. Grant agents scopes explicitly, as a subset of the user’s access, and check them on every call, not at session start. See what runtime authorization looks like.
-
Start an attributed audit trail now. The first thing an auditor will ask for is who accessed what through which agent, and which rule applied. It’s far easier to log that from the start than to add it later. What security teams need to know.
GatewayStack is one implementation of the Agentic Control Plane pattern. It covers JWT-based identity, per-call policy checks and attributed audit logs. It’s not the only way to meet these asks, and NIST’s final requirements may differ from what’s described here. For compliance work, treat any tool as one input to your own evidence.
Get started free · Reference architecture
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:
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
irm https://agenticcontrolplane.com/install.ps1 | iex