NIST's ten design tenets for agent identity, read as an engineering checklist
NIST's NCCoE proposed ten design tenets for agent identity. What each asks for, which you can meet today, and where AI coding tools fall short.
On 27 October 2026 NIST's National Cybersecurity Center of Excellence published ten design tenets for agent identity management. It is the second post in a series on agent identity, authentication and authorisation, and it turns a broad principle, that agents need identities of their own, into a list specific enough to check a system against. The tenets are not a standard or a requirement. They are an initial proposal, drawn from public comments on an NCCoE project and from discussions with industry, and NIST says plainly that not all of them can be met with today's standards and technology. That makes them a useful map: what good looks like, and how far your AI tools are from it.
Where this comes from
The first post in the series, from 27 August, made the case. People giving their own credentials to agents "has quickly become a common pattern", and sharing credentials creates accountability gaps. Agents should be "first-class entities" with their own identifiers, credentials and entitlements, bound to the person or system operating them. For enterprises it points to existing protocols such as OAuth 2.0 and SPIFFE, and emerging work such as WIMSE.
The NCCoE project page says the eventual deliverable is an SP 1800-series practice guide with example implementations, and that a concept paper published in February 2026 drew over 600 responses. The tenets will be "the guideposts" for the project's demonstrations.
We covered NIST's earlier, broader work on agent security in What NIST is saying about AI agent security. This post is narrower and more concrete.
The ten tenets, grouped
The tenets fall into three groups.
Who the agent is
- Distinct agent identification. Each agent has a unique, cryptographically verifiable identity, distinct from human users and service accounts, ideally tied to a workload, environment and approved configuration.
- Linking, delegation and attenuation. Agents are cryptographically linked to whoever started the task, and authority narrows as it passes to sub-agents: a downstream agent "can never claim more authority than the parent".
What it may do
- Least and zero standing privilege. No persistent rights when idle; access bounded to the task, with separation of duties.
- Short-lived, dynamic and revocable authorisation. Just-in-time, time-bounded, audience-specific grants, with runtime checks on each tool call, and no long-lived bearer tokens or static secrets.
- Human-in-the-loop triggers. Defined risk thresholds that escalate to a person, designed with "consent fatigue" in mind, so approvals don't become habit.
- Mandates and constraints. Signed statements from the task originator that define the intended outcome and limits, which downstream services can verify.
How it is checked and recorded
- Separation of policy from reasoning. What the agent tries to do is decided apart from what it is allowed to do, so prompt injection can't expand its permissions. NIST is blunt: "Guardrails alone are insufficient."
- Deterministic access decisions. Probabilistic signals can inform a decision, but not make it.
- Continuous monitoring, with agent-specific metrics and thresholds.
- Immutable evidence. Tamper-evident, append-only records of the agent's identity, delegated intent and actions, kept independently of the agent.
NIST also notes that tenets work in combination. Its example is the "confused deputy" attack, where a prompt injection persuades an agent with broad access to do something it otherwise wouldn't. Linking and delegation help, but so do least privilege, separating policy from reasoning and deterministic decisions.
Reading it against today's AI coding tools
NIST's first post names the common pattern for coding agents directly: agents deployed locally with the user's own account and entitlements, helping with tasks such as software development. It warns that this lets the agent impersonate the user with broadly scoped access, undermines non-repudiation, and encourages static credentials stored in local files. Against the tenets, that pattern falls short on the first two: the agent has no identity of its own, and nothing separates what the person did from what the agent did on their behalf.
Some tenets are within reach now, without new standards:
- Zero standing privilege and short-lived grants (3, 4). Write access to sensitive systems can be granted per task, for hours rather than permanently, with an approver who isn't the requester.
- Separation of policy from reasoning (7, 8). Permission checks that sit outside the agent, in a gateway or proxy, enforce rules that no prompt can change.
- Human-in-the-loop triggers (5). Approval for destructive tools is a common feature. The harder part is NIST's warning about consent fatigue: if every call needs approval, approvals stop meaning anything.
- Immutable evidence (10). Logging every tool call outside the agent, where it can't edit the record, is achievable today.
Others are genuinely hard. Cryptographically linked delegation chains and signed mandates (2, 6) have no settled standard, and few AI tools could carry them through to the services they call.
What it means for engineering and security leaders
- Use the tenets as an assessment, not a mandate. NIST frames them as a way to assess current capabilities and build a roadmap. A gap analysis against the ten is a reasonable exercise for any team rolling out agents.
- Start with the ones that need no new standards. Standing privileges, approvals and independent logging are configuration and architecture choices you control.
- Watch the practice guide. The SP 1800-series guide will show reference implementations. That is when these tenets are likely to start appearing in audit questions.
Practical takeaways
- List where agents act with a person's credentials, and which of those systems can change things.
- Remove standing write access to production systems where you can, and replace it with time-limited grants approved by someone else.
- Put permission checks outside the agent, so they apply whatever the prompt says.
- Make sure every agent tool call is logged somewhere the agent can't modify.
- Review approval volumes: if people approve almost everything, the trigger thresholds are wrong.
In SpanDock's MCP gateway, each person gets only the connectors and tools they're allowed, every call passes your rules on your server rather than inside the AI tool, and every call is recorded. On Enterprise, and in the trial, a connector's write tools can be nobody's standing access: people request them for up to 8 hours with a reason, an approver they can't be themselves grants them, and the grant ends by itself, with every step in the change management report.