An agent can start with permission to draft a production change and still have no permission to deploy it.
That sounds obvious. In practice, many authorization designs treat the agent’s initial task as the security boundary. Once approved, the agent is free to discover data, call tools, and adjust its plan.
That’s where control weakens.
A runtime decision should follow the action, not just the task description.
Consider an agent asked to prepare a production configuration change.
At the start, the request may look safe:
- The user is identified.
- The agent is assigned a drafting task.
- The target system is known.
- The expected output is a proposed change.
The agent reads configuration data, checks deployment status, discovers that the change affects a wider set of services, and produces a deployment command.
The agent’s plan has changed. The final action is no longer “draft a change.” It’s “apply a change to production.”
That should be a new authorization decision.
The policy engine needs to evaluate the agent, the user, the tool, the resource, and the current context. It may allow the draft, deny the deployment, or request approval from an authorized person.
The important part is that the decision happens at the point where authority changes.
A useful buyer test is simple:
Can your system answer these four questions for every meaningful agent action?
- What did the agent intend to do?
- What policy allowed or blocked it?
- What had changed since the previous decision?
- Who, or what, approved the next level of authority?
If the answer is only stored in a final conversation transcript, you’re missing the operational evidence.
A transcript can show that an agent said, “I’m going to deploy this.” It doesn’t prove that deployment was authorized in the context that existed when the action occurred.
Runtime authorization needs a decision record attached to the execution step. The record should explain the reason for the outcome, not just store allowed: true.
That distinction matters during an incident, an audit, or a dispute over accountability. Teams need to know whether an action was allowed because the resource was in scope, because a user approved it, or because a policy failed open.
The practical design rule is this:
Treat every material change in plan, target, tool, or context as a fresh authorization boundary.
An agent may be allowed to investigate. It may be allowed to prepare. Deployment still needs its own decision.
That is how autonomy becomes bounded authority instead of inherited permission.
Top comments (0)