An agent does not simply need access. It needs an identity, a named source of authority and a permission path that changes with the action it is attempting. Users should be able to see when the agent is acting for them, what it can do, where its authority ends and how to stop it. Those are product decisions as much as security controls.
Access is not the same as authority
Most enterprise permissions were designed around people using applications and services calling other services. Agents complicate that model because one interaction can involve a user, an agent runtime, several tools and a sequence of downstream systems. Authentication may establish who each participant is. It does not, by itself, establish whose authority governs the action or how far that authority should travel.
The distinction between delegation and impersonation is useful. RFC 8693 describes delegation as an actor retaining its own identity while representing another party. Impersonation makes the actor indistinguishable from that party within the authorised context. For agentic work, delegation is usually the more accountable product posture because the record can preserve both the user who authorised the task and the agent that performed it.
Microsoft's agent identity model makes a similar separation between human and software identities. It supports agents acting autonomously through rights assigned directly to the agent, or acting on behalf of a user through delegated access. The wider implication is not that every organisation needs one vendor's identity product. It is that an agent should be a governable participant with its own lifecycle, sponsor, policies and retirement path, rather than a shared service account wearing the user's permissions.
Broad access erases the permission experience
Imagine a procurement agent asked to prepare a supplier renewal. It needs to read the current contract, compare usage, draft a recommendation and create a review task. It does not need permanent access to every contract, the ability to change bank details or authority to approve payment. Giving it the user's complete application session may make the demonstration smooth, but it collapses several different decisions into one invisible grant.
The problem becomes more serious as the agent crosses systems. A permission that appears narrow in one application can become broad when combined with data retrieved elsewhere and a tool that can create an external effect. The effective authority is the complete chain, not the label on one access token. A product team therefore needs to model the proposed action, target resource, data scope, consequence and time window together.
NIST's zero-trust guidance removes implicit trust based on location or ownership and focuses access decisions on users, assets and resources. That principle transfers well to agentic products. An authenticated agent should not inherit general trust because it is internal, approved or attached to a known user. Authority should be evaluated for the specific resource and action being attempted.
Design a permission path for each consequential action
A useful permission model begins with the path an action takes through the product. It should preserve the human subject, the acting agent, the intended resource and the granted action as distinct facts. It should then narrow authority as the work becomes more specific. Reading a supplier record, drafting a recommendation, creating a task and submitting a change are not one permission merely because they belong to one user objective.
RFC 9396 provides a technical example of richer authorisation by attaching structured details such as actions, locations and transaction data to a grant. The Model Context Protocol specification similarly uses resource indicators, minimal initial scopes and incremental step-up authorisation. These mechanisms do not define the WQA framework below. They demonstrate that authorisation can carry more decision context than a broad role or reusable scope.
For each material action, record six elements. Together they make the authority path explicit enough to design, enforce and audit:
- Subject: Which person, team or organisation owns the intended outcome?
- Actor: Which agent identity and runtime will perform the action?
- Resource: Which exact system, record or tool may be used?
- Capability: Is the agent reading, drafting, creating, changing, approving or communicating?
- Condition: What purpose, value, data state, time limit or policy must remain true?
- Recovery: How can authority be revoked, the action stopped and the outcome reconstructed?
Make authority legible at the moment it matters
A secure permission model can still produce a poor product if the user cannot understand it. A request such as ‘allow access to procurement’ is too abstract when the real authority includes multiple systems and actions. The experience should explain what the agent is about to do, which records it will use, whether it will communicate externally and what will happen after approval. It should also distinguish a one-off action from an enduring permission.
Legibility does not require exposing token formats or policy syntax. It requires translating the permission path into the user's decision. ‘Read this contract and create a private draft for this renewal’ is materially different from ‘manage supplier contracts’. The first statement names the resource, action and immediate consequence. The second asks the user to trust an implementation boundary they cannot inspect.
The product should retain the distinction after approval. Activity history should show that the agent acted for a named user or team, identify the granted capability and link the result to the original request. When an agent delegates to another agent or tool, the experience should not silently replace that chain with a generic automation label. Clear identity is part of how users judge whether an outcome is legitimate.
Put confirmation at consequence boundaries
Requiring approval for every tool call makes an agent slow and teaches users to approve without reading. Requiring approval only when the workflow begins can leave later changes outside the decision the user thought they made. The better design places confirmation where consequence changes: before external communication, commitment of money, alteration of an authoritative record, use of a more sensitive source or expansion into a new resource.
OpenAI's Agents SDK demonstrates the underlying control pattern by allowing selected tool calls to pause, present their details and resume after approval or rejection. The useful product lesson is selective interruption. Approval should be attached to the proposed action and its arguments, not used as a ceremonial checkpoint around the agent as a whole.
Some workflows can earn lower-friction operation. Repeated actions may proceed under a maintained policy when their scope, value, destination and evidence remain within an approved boundary. A new recipient, larger value or changed record state should trigger step-up authorisation. This creates progressive authority: routine work can move efficiently while meaningful departures become visible decisions.
Revocation and recovery complete the experience
Permission design often ends when access is granted. Agentic work continues after that point. Tasks may pause, retry, call additional tools or resume from stored state. A user can leave a role while an agent retains a token or queued instruction. A tool can change its permission model. A previously acceptable action can become inappropriate because the underlying record or policy has changed.
The product therefore needs an operational answer to four questions: which agents currently hold authority, what work is active, how quickly can that authority be withdrawn and what happens to work already in progress? Token expiry helps, but RFC 8693 notes that revocation propagation is implementation-specific rather than an automatic consequence of token exchange. Retirement and cancellation need deliberate system behaviour.
Recovery also needs evidence. Keep enough information to identify the subject, actor, resource, granted capability, relevant condition, approval event, tool result and final outcome. The goal is not indiscriminate surveillance. It is the ability to explain and correct a consequential action. If the organisation cannot reconstruct the permission path, it cannot reliably learn from failure or prove that the agent stayed within authority.
Start with one action, not an enterprise role model
There is a reasonable counterargument that this level of design will slow adoption. Existing role-based access is familiar, and broad delegated sessions can make early prototypes easier to build. The answer is not to redesign enterprise identity before testing any use case. It is to choose one consequential action and make its permission path explicit before production.
Name the subject and actor. Limit the resource and capability. Decide which conditions can be enforced automatically and which require confirmation. Define expiry, revocation and recovery. Then test whether users understand the grant and whether the system can reconstruct the outcome. Expand only when adjacent actions can inherit the same control without inheriting broader authority.
Identity and permissions are often treated as constraints on the agent experience. Designed well, they are part of what makes the experience dependable. They allow the product to say who is acting, why the action is allowed and where it will stop. That clarity creates a stronger route to useful autonomy than asking users to approve an agent first and discover its authority later.
- Subject: Which person or organisation owns the authority and remains accountable for the outcome?
- Actor: Which agent, application or person will exercise that authority?
- Resource: Which record, system, account or environment can the actor reach?
- Capability: What may the actor read, propose, change, communicate or commit?
- Conditions: Which scope, value, destination, time or policy limits must be enforced automatically?
- Confirmation: At which change in consequence must a person review the proposed action and its arguments?
- Duration: When does the authority expire, and how can it be narrowed or revoked while work is active?
- Recovery: Can the system reconstruct, stop and correct the action without collecting evidence indiscriminately?
Sources and further reading