Insights
Architecting agents with explicit authority
An engineering framework for delegated identity, scoped tools, approval boundaries, and accountable execution.
In brief
Who authorized the action, and where is that authority enforced?
- Represent delegated authority as a scoped, executable contract.
- Bind approval to the actual action and recheck policy when execution occurs.
- Test denial, escalation, and the record of external effects—not just successful tasks.
An agent can propose a useful action without having permission to perform it. Production architecture must preserve that distinction throughout planning, tool selection, execution, and recovery. The relevant question is what authority the system possesses at the moment it acts, on whose behalf, and under which constraints.
Explicit authority makes an agent’s behavior inspectable. It connects each action to a user or service identity, an approved purpose, a resource scope, and an execution record. This allows an organization to expand automation deliberately while retaining control over the operations that carry financial, operational, or information consequences.
Separate interpretation from enforcement
Language models are useful for interpreting requests and proposing sequences of work. Tool-using research such as ReAct explores the interaction between reasoning and external actions. In a production system, the component that proposes an action should not be the sole component deciding whether that action is permitted. ReAct.
An enforcement layer should validate identity, parameters, resource scope, and current policy before execution. The model receives structured feedback when a request is rejected. It can revise its plan within the available authority or ask for an authorized human decision.
This separation also limits prompt injection. A retrieved document may contain instructions, but it is evidence supplied to the task. It does not acquire the authority to expand tool permissions. The execution layer should evaluate a request according to the established policy regardless of the wording that led the model to propose it.
Represent authority as a concrete contract
A useful contract identifies the principal, delegated user, allowed operation, resource set, parameter constraints, validity period, and approval requirements. It may allow reading a particular project and creating a draft, while withholding the ability to publish externally or modify access controls.
The contract should distinguish service authority from user authority. A background indexing service may have permission to process a repository for a defined purpose. An interactive assistant answering a user may be limited to that user’s current access. Reusing the indexing service’s broad credentials in the answer path can accidentally erase that boundary.
NIST’s zero trust architecture centers access decisions on users, resources, and explicit authorization rather than presumed trust from network location. Agent architectures can apply that principle at each tool boundary. NIST SP 800-207.
A synthetic procurement workflow
Consider an agent asked to prepare a purchase request for replacement equipment. It can search an approved catalog, compare specifications, check an internal budget record, and draft a request. Submitting the order is a separate operation with a different consequence.
| Operation | Required authority | Evidence retained |
|---|---|---|
| Read catalog | Approved catalog access | Source and item version |
| Inspect budget | Department-scoped read access | Budget record timestamp |
| Draft request | Create draft for requesting user | Draft content and rationale |
| Submit order | Approved amount, vendor, and approver | Approval bound to exact order |
A general instruction to help with procurement should not silently become permission to spend any amount with any vendor. Conversely, once an authorized approval covers a specific order, the system should not repeatedly request the same permission. The approval record should make its scope clear enough for deterministic enforcement.
If the price or quantity changes after approval, the previous approval may no longer apply. The execution service should compare the final payload with the approved payload before submitting it.
Bind approval to the actual action
A weak approval asks whether the user wants to proceed while hiding what will happen. A stronger approval presents the target resource, parameters, expected side effects, and relevant constraints. The approval is then bound to a versioned action description or payload digest.
This protects against changes between review and execution. An agent may revise its plan after receiving new information. An external resource may also change. If the revised action falls outside the approved scope, the execution layer should require a new decision or stop with a clear explanation.
Approval should have an expiration appropriate to the workflow. A staffing schedule reviewed last month may be unsuitable today. A temporary access grant should not persist indefinitely because the conversation remains open. Validity is part of the authorization contract, rather than a detail inferred from chat history.
Design tools around narrow operations
A tool that accepts arbitrary commands exposes a much larger authority surface than a tool that creates a draft in a defined system. Narrow operations allow validation of identifiers, values, and allowed transitions. They also make logs and evaluations easier to interpret.
Narrowness should follow the task. Excessively fragmented tools can create complicated workflows with many failure points. A well-designed operation may perform several internal steps atomically while exposing a clear external contract. The goal is understandable authority with reliable execution.
Tool responses should separate data from control information. A retrieved page can be returned as untrusted content with provenance. A policy decision should come from the enforcement service. Mixing both into an undifferentiated text response makes it harder for the agent and auditors to identify which information carries authority.
Recheck policy when the action is executed
Permissions can change during a long-running task. A user may lose access to a project, a document may become restricted, or an approval may be revoked. Checking authority only when a session starts leaves a gap between the original permission and the eventual action.
The execution boundary should evaluate the current policy and resource state. For consequential writes, optimistic concurrency checks can prevent an operation from overwriting changes made after the agent read the resource. A rejected version check should trigger reconciliation, rather than an unconditional retry.
Long-running jobs need a defined delegation model. They may stop when the initiating user’s authority expires, or continue under a separately approved service identity. Either approach can be valid when explicitly designed. An accidental mixture makes accountability difficult.
Evaluate denial and escalation paths
Authority tests should include permitted actions, prohibited actions, ambiguous requests, revoked permissions, and attempts to redirect the agent through retrieved content. Evaluate whether the system selects the correct boundary and explains the outcome without revealing restricted information.
A denied action should not lead the agent to search for a more permissive tool that achieves the same prohibited effect. The policy should apply to the underlying resource and operation across available interfaces. Tests should therefore include equivalent actions expressed through different tools.
Escalation also needs an operational owner. If approval is required, the request should reach an authorized reviewer with enough context to decide. If nobody is available, the task should remain pending or expire according to policy. The system should not treat elapsed time as consent.
Keep an accountable execution record
For each action, retain the task identifier, initiating principal, effective authority, policy decision, approved payload where relevant, execution result, and external resource identifier. Logs should avoid unnecessary sensitive content while preserving enough information to reconstruct the event.
The record should distinguish a proposed action, an attempted action, and a confirmed effect. These states answer different questions during an incident. A successful model response does not prove that an external system accepted the operation, and a timeout does not prove that nothing happened.
Explicit authority allows an organization to be ambitious about agents while remaining precise about responsibility. It turns a broad capability into a bounded operating system whose permissions, decisions, and effects can be inspected. That foundation supports more reliable automation as workflows become longer and tools become more powerful.