NIST’s latest guidance reinforces a clear direction for agentic AI security: strong agent identity, secure delegation, granular authorization and continuous control across the full workflow.
As AI agents take on more enterprise work, they increasingly access data, call tools, interact with other systems and execute actions autonomously. Securing those workflows requires controls that can follow the agent as the context changes.
In its latest Cybersecurity Insights blog, NIST identifies the next critical challenge for enterprise AI: establishing identity and authorization for autonomous agents.
Solving it requires a new approach to identity and control, built for how agents actually operate.
IndyKite provides the identity, context and trust layer purpose built to keep agents secure and governable. It brings together identity, delegation, enterprise context and policy to determine what an agent can access, which tools it can use and which actions it can take throughout the workflow.
The direction NIST is setting closely reflects the architecture IndyKite has been building for delivering trust and control for agentic systems.
Give AI agents their own identity
NIST holds a fundamental requirement for AI agent identity: agents should be treated as distinct entities rather than operating through shared human credentials. This creates a clear distinction between the person or system delegating authority and the agent performing the work.
IndyKite maintains this distinction throughout an agentic workflow. Humans, agents and systems are represented separately, while the relationships between them provide the context needed to understand who is acting, on whose behalf and under what authority.
This identity context becomes part of every subsequent authorization decision.
Use modern identity and delegation standards
NIST points to established standards such as OAuth 2.0 and SPIFFE as foundations for AI agent identity and delegation, alongside emerging standards designed specifically for increasingly complex agent interactions.
IndyKite is built to work with modern identity infrastructure rather than replace it. Knowledge-Based Access Control (KBAC) supports open standards including OAuth/OpenID and AuthZEN, while the Agent Gateway preserves identity and delegation context as agents interact with tools, data and other services.
The result is a continuous chain between the original user, the agent acting for them and the resources involved in the workflow.
Use secure, tightly scoped credentials
Agentic AI increases the consequences of static API keys, long-lived tokens and broadly scoped credentials. NIST recommends dynamic, tightly scoped and audience-restricted credentials that reflect the temporary and task-specific nature of many agent interactions.
Credential security provides an important foundation. IndyKite adds runtime authorization on top of it.
Rather than assuming possession of a valid credential determines everything an agent can do, IndyKite evaluates each request against the context in which it occurs. Permissions can therefore remain precise as an agent moves between systems, accesses new information or takes different actions.
Enforce least privilege and granular AI access control
NIST identifies broadly scoped access as a particularly significant issue for AI agents. Agents can explore tools, data and execution paths at a speed and scale far beyond human users, increasing the importance of least privilege and granular authorization. It specifically points to developments such as Rich Authorization Requests for dynamic authorization.
This is central to IndyKite’s AI access control model.
KBAC evaluates identity alongside relationships and contextual information to make fine-grained authorization decisions at runtime. AgentControl extends that control across agent interactions, determining which data an agent can retrieve, which tools it can use and which actions it can execute.
Authorization can adapt as the context changes rather than relying on a broad permission established at the beginning of a session.
Carry authorization context across agent workflows
AI agent authorization becomes more complicated when a task moves through multiple agents, tools and systems.
NIST highlights Transaction Tokens as one emerging approach for carrying authorization context across human and agent call chains, allowing authority to be constrained as it is delegated. It also points to AuthZEN as a standard interface between policy enforcement and policy decision points.
IndyKite addresses the same architectural requirement by maintaining context throughout the workflow.
Identity, delegation, relationships, data sensitivity, provenance, purpose and other relevant signals can remain available as the transaction progresses. This allows each authorization decision to reflect both the immediate request and the wider chain in which that request occurs.
Externalize authorization decisions with AuthZEN
NIST’s inclusion of AuthZEN is particularly significant for agentic AI security.
As agents operate across many applications, APIs and data sources, authorization needs to be applied consistently across those environments. AuthZEN provides a standardized interface for separating policy enforcement from policy decisioning.
IndyKite provides native AuthZEN API support. KBAC acts as a dynamic policy decision layer, using connected enterprise context to determine whether a request should proceed.
This allows enterprises to externalize authorization and apply consistent policy across agents, APIs, tools and data without recreating access logic inside every application.
Apply control across the full agentic workflow
The security decision cannot end when an agent authenticates or receives a token.
An autonomous agent may retrieve data, call an API, invoke another agent and trigger a business process as part of a single task. Each step changes the context in which the next decision occurs.
AgentControl places runtime control throughout that execution path. Fine-grained authorization can be applied at agent-to-agent, model-to-API and model-to-data interactions, with permissions evaluated as the workflow develops.
This creates a continuous control model for agentic AI rather than a single authorization decision at the start of the workflow.
Control AI agent actions at runtime
NIST also highlights an important consequence of agent autonomy: agents can operate faster and at a greater scale than people can practically supervise.
IndyKite addresses this by turning enterprise context into an enforceable decision at the moment of action.
When an agent queries data, calls a tool or triggers a workflow, AgentControl evaluates live signals including identity, relationships, provenance, data sensitivity and current context. The resulting policy decision determines whether the action should proceed.
Runtime authorization makes policy part of execution itself.
Reduce dependence on Human-in-the-Loop approvals
NIST also cautions against treating Human-in-the-Loop approval as the primary mechanism for AI agent security. Repeated approval requests can create consent fatigue, weakening the accountability those controls are intended to provide.
AgentControl allows defined policies and contextual controls to be enforced automatically throughout agent execution. Routine decisions can be resolved at runtime, while organizations can still define situations that require escalation or human intervention.
This supports greater agent autonomy within clearly defined boundaries.
Maintain traceability and accountability
Identity and authorization ultimately need to answer another question: what happened?
For agentic systems, understanding an action requires visibility into the identity involved, delegated authority, data used, applicable policies and the context in which the decision was made.
IndyKite captures this information as part of the decision process. Agent actions can be traced back to data provenance, context and policy decisions, creating a record of why an action was permitted and what informed it.
Decision traceability gives security, governance and compliance teams visibility across the full agent workflow rather than a collection of isolated events.
Building the security foundation for agentic AI
NIST’s message is clear: secure agentic AI depends on getting identity and authorization foundations right. Distinct AI agent identities, delegated authority, least privilege, granular authorization and externalized policy enforcement all become increasingly important as agents gain greater autonomy.
The IndyKite Platform was purpose built with these foundations with a runtime control layer designed for how autonomous AI actually operates.
Identity establishes who is acting. Delegation establishes whose authority they carry. The live context graph connects that information with relationships, provenance, sensitivity, policy and other enterprise signals. AgentControl then applies that context at runtime to determine what an agent can access, which tools it can use and which actions it can take.
The result is agentic AI security that follows the workflow from identity and delegation through authorization, execution and decision traceability.
If you want to learn more, check out the Whitepaper: Zero Trust Architecture for Agentic AI.
