Analysis • November 13, 2026

When an AI assistant sends a calendar invitation, an employee can usually tolerate an error. When it changes a payment destination, deletes customer records or delegates to another agent, the same vague instruction becomes an audit problem. Who empowered that exact action, what limits applied, and what evidence remains if the agent later says it was following orders? The answer cannot simply be an account name or a chat transcript.

On October 27, the US National Institute of Standards and Technology published ten initial design tenets for agent identity management. They include distinct cryptographic agent identities, narrower delegated authority, zero standing privilege, short-lived authorization, deterministic access decisions and independently maintained evidence. The document is a blog proposal to inform future demonstrations, not a final NIST standard or binding procurement requirement. Its more consequential implication is architectural: businesses need to prove individual agent actions were authorized, not merely identify the software that performed them.

The distinction between identity and permission

A verified employee badge proves something about an identity. It does not authorize access to every warehouse, refund, bank account or customer database. AI agents create a more confusing version of the same problem because they interpret broad human objectives and choose intermediate steps. A user might ask an agent to reconcile a supplier invoice. The agent could read an email, inspect purchase orders, query bank details, call another service and submit a payment request. Each step has different risk and should have separately enforceable scope.

NIST's first tenet is distinct agent identification: agents should be cryptographically distinguishable from humans and conventional service accounts, ideally linked to a workload and approved configuration. Its second, delegation and attenuation, calls for a traceable chain from the originator through downstream agents, with delegated permissions that cannot exceed the parent authority. Those concepts are related but not interchangeable. A unique agent certificate without a valid delegation chain could make an unauthorized action easier to attribute without preventing it.

One practical test illustrates the difference. A customer-support agent is authorized to issue credits up to $50 for an identified order. It delegates language analysis to a sub-agent and pricing lookup to another. Neither sub-agent should receive blanket refund or customer-export privileges merely because they were summoned by the support agent. An authorization service should test each proposed tool call against the amount, target order, allowed purpose and remaining authority. The model's statement that a step is useful should not itself expand the grant.

The permission receipt as a missing product layer

Our thesis is that the economically useful unit of trust in agent systems will be a transaction-specific permission receipt: a verifiable record that binds an action to the originator, delegated scope, time window, resource, policy decision and outcome. This architecture is Nextwith.ai’s synthesis of established authorization and audit ideas, not a claim to have invented permission receipts or a named NIST requirement. Public comments below NIST’s post also discuss receipts and revocation evidence; those comments are contributions by readers, not official tenets or an existing universal industry protocol.

Such a receipt would answer six questions. Which principal initiated the task? Which agent and software instance acted? What narrowly defined outcome was permitted? Which resource and operation were targeted? Which deterministic policy granted or denied the request? What happened afterward, including reversals and revocations? For higher-impact transactions, it should also preserve proof of genuine human approval for that exact operation, not a general checkbox clicked hours earlier.

The distinction matters across organizations. Imagine a travel-planning agent employed by one platform requests a change to an airline booking hosted by another. The airline can verify an account token, but it may have no visibility into the travel agent's original instructions or its subcontracted tools. The receiving service needs a basis for deciding whether the requested modification falls within a mandate. Our earlier analysis of United Airlines and AI assistants examines the technical trust problem alongside website access rules; that internal article is background analysis, not independent evidence of a new airline announcement. The receipt cannot magically force an airline to accept an agent; it could make the request assessable.

NIST's tenets imply separation of powers

The full numbered tenet text, rather than the reader-comment section, is the basis for the numbering used here. Items 1 and 2 cover identification and attenuated delegation; items 3 and 4 address standing privilege and revocable authorization; item 5 addresses human review and consent fatigue. Three further tenets sharpen the engineering response. The seventh calls for separating policy enforcement from probabilistic reasoning so malicious documents or prompts cannot rewrite the rules. The eighth favors deterministic access decisions, even when model outputs contribute evidence. The tenth calls for independent, append-only, tamper-evident evidence of identities, delegated intent and actions. Together, these suggest an architecture in which the model proposes a tool action but a separate service decides whether it is allowed and records what occurred.

Consider an invoice-processing deployment. The model can extract the supplier name and suggest a payment. A deterministic policy layer checks whether that supplier is approved, whether the account is verified by an independent record, whether the amount is within limits, and whether two-person approval is required. The resulting receipt records the requested payment and the policy result. An administrator can revoke a short-lived permission without persuading the model to stop. This is considerably stronger than a prompt telling the agent to be cautious.

The same boundary should govern what a tool may return. A webpage or invoice can contain text pretending to be a system instruction. If the model treats that material as authority, a prompt-injection attack may redirect a seemingly legitimate workflow. No single identity mechanism eliminates this risk; the proposed benefit comes from keeping untrusted content away from the enforcement machinery.

Why a signed receipt is still not enough

Cryptography is valuable but easy to overclaim. A signed instruction can prove that some key signed particular bytes. It cannot by itself prove that the human understood the consequence, that the signer was not compromised, or that the underlying data were true. In consumer scenarios, preserving privacy may also require minimizing personal information in any proof that travels across services. NIST explicitly recognizes privacy-preserving or pseudonymous transactions where appropriate.

A second limitation is human approval fatigue. NIST's fifth tenet acknowledges that frequent escalations can become ritual approvals. A system that asks a human to approve every harmless file read may encourage careless consent to the one irreversible transfer. Risk thresholds need separate classifications of action reversibility, amount, recipient, data sensitivity and unusual behavior, with rare high-impact approvals tied to a visible action summary.

Third, independent logs are not necessarily useful logs. A company may collect millions of records but be unable to reconstruct an agent's decision chain when a customer disputes a result. To be operationally valuable, evidence needs stable task IDs, timestamps, linked parent-child invocations, understandable policy versions and retention rules. It should record both permission denials and successful actions, not simply final model messages.

The skeptical case: existing IAM may already do the job

There is a respectable counterargument. Modern systems already use OAuth scopes, workload identities, service accounts, approvals and audited API gateways. Inventing a special agent-identity standard could create incompatibility and new credential brokers while old mechanisms remain underused. For tightly scoped automations, standard short-lived tokens and ordinary policy engines might be sufficient.

That criticism is useful because the right response is not to replace existing identity infrastructure with an AI-branded stack. It is to test where existing systems cannot express or verify delegation across changing tasks and autonomous sub-agents. An agent serving one enterprise through one API can often use familiar IAM. A consumer agent negotiating transactions across several independently operated services confronts a harder portability problem, especially when each service requires distinct proof of origin, purpose and revocation.

NIST's February concept paper asked for industry feedback on identity, authorization, auditing, non-repudiation and prompt injection. The October publication moves that discussion toward testable design properties, but it does not settle standards, liability or universal cross-platform acceptance.

What buyers and builders should test now

Rather than asking a vendor whether its agents are secure, buyers can commission a short set of outcome tests. Give a read-only agent a document that instructs it to export secrets, and verify the tool layer rejects the attempt. Start a task with a $50 credit limit and see whether a sub-agent can obtain a $500 limit. Revoke the user's mandate during execution and confirm that the next high-risk operation fails. Request an audit export and determine whether a different administrator can reconstruct what the system allowed, denied and changed. Finally, try an irreversible operation without a fresh scoped approval.

The tests should produce receipts from independent enforcement systems, not self-reported model explanations. Developers should use narrow credentials, explicit workload identities, versioned permissions and durable task-level logs. Product teams can make boundaries visible to users: a useful agent may say it can analyze invoices but needs explicit authorization before making transfers. That distinction is more informative than a vague claim of autonomy.

There are costs. Fine-grained policy enforcement creates latency and implementation burden, and third-party services may not support interoperable authorization. Evidence retention introduces its own privacy duties. Those trade-offs should be measured against the cost of unauthorized actions, dispute handling and lost customer trust rather than waved away by an agent-demo success rate.

The larger economic implication

Models will improve at choosing steps. That does not ensure companies can explain, constrain or reverse those steps. As autonomous software moves from drafting suggestions to committing transactions, the bottleneck shifts from generating plausible plans to making those plans governable. The companies best positioned to capture the next wave may not be those offering the most confident agent. They may be those that can demonstrate, for each consequential action, the authority that existed, the boundary that held and the independently verifiable record left behind.

Evidence boundary: NIST's October tenets and February concept paper are documented proposals. The permission-receipt architecture and business implications above are Nextwith.ai analysis; no claim is made that an industry-wide receipt format exists or that the tenets have regulatory force.

Sources