How to Keep an AI Agent from Acting Beyond Its Authority
Keep an AI agent from acting beyond its authority by controlling capability outside the model. Give it a unique identity, expose only the tools and data required for its job, authorize each action against the user and target, require human approval for consequential steps, enforce spending and usage limits, record every action, and maintain a tested stop mechanism.
Instructions such as “never send without approval” are useful, but they are not a security boundary. A manipulated, mistaken, or ambiguous model output must still encounter controls that cannot be talked around.

Define authority as a concrete contract
For each agent, document:
- Purpose: the business outcome it may pursue.
- Information: the data sources, records, fields, and time range it may read.
- Actions: the exact tools and operations it may call.
- Targets: the accounts, recipients, environments, and resources it may affect.
- Limits: spending, volume, rate, duration, and iteration ceilings.
- Approvals: which actions require which named role.
- Stop conditions: uncertainty, conflicting evidence, unusual requests, and policy boundaries.
- Owner: the person accountable for permissions, exceptions, review, and retirement.
If these terms cannot be stated, the agent is not ready for action authority.
Put seven controls around the model

1. A unique identity
Do not hide agent activity behind a shared employee login or general-purpose credential. A distinct identity makes access review, attribution, monitoring, and revocation possible. Record when it acts on behalf of a particular person.
2. Least privilege per tool
Grant the smallest useful capability. An agent that drafts an email does not need send permission. A ticket creator does not need ticket-system administration. A CRM updater may need write access to three fields, not every customer record.
Microsoft’s agent-security guidance recommends least privilege per tool and warns against a broad standing identity. NIST’s current agent-identity design tenets similarly call for minimum task scope and little or no standing privilege when the agent is idle.
3. Authorization on every action
Logging in once should not authorize everything that follows. The execution boundary should recheck the actor, action, resource, current state, and task scope. This prevents an agent from using its own privilege to do something the requesting user could not do.
4. Approval by consequence
Require a fresh human decision for high-impact, irreversible, sensitive, or externally binding actions. Examples include sending, deleting, purchasing, changing permissions, moving money, deploying to production, or exposing protected information.
The reviewer needs the proposed action, target, evidence, cost or exposure, and alternatives. Too many low-value approvals create consent fatigue, so reserve them for meaningful decisions. See what human-in-the-loop should actually mean.
5. Hard limits
Enforce allowlists, rate and volume limits, spending caps, step ceilings, operating windows, and recipient restrictions in code or platform policy. The agent can decide within the box; it cannot enlarge the box.
6. Action-level evidence
For every tool call, preserve the initiating user or event, agent identity, policy decision, approved scope, action, target, inputs and result, timestamp, correlation identifier, and final business state. A transcript alone is not enough to reconstruct what changed.
7. Revocation and containment
Maintain a fast way to disable the agent, invalidate tokens, remove access, block tools, and stop new work. Test that path. A “kill switch” that leaves active credentials or downstream access in place is only a label.
Use an authority ladder
| Level | Agent may… | Appropriate when… |
|---|---|---|
| Observe | read approved data | access is narrow and logged |
| Propose | draft or recommend | a person owns the decision |
| Prepare | create a reversible pending item | validation is strong |
| Execute with approval | act after a fresh authorization | consequence is material |
| Execute within limits | act autonomously inside hard boundaries | outcomes are low-risk, monitored, and recoverable |
Start lower than the demo suggests. Increase authority only after operating evidence shows acceptable outcomes, exceptions, and recovery. Re-review access whenever the purpose, tools, data, users, or environment changes.
Test the boundary, not only the task
Include cases where the agent is asked to:
- use an unapproved tool or record;
- act for a user without permission;
- exceed a financial or volume limit;
- follow instructions hidden in a document or webpage;
- send to a new external recipient;
- continue after uncertainty or conflicting evidence; and
- operate after its access has been revoked.
The correct result is a safe refusal, escalation, or contained failure—not a clever workaround.
Authority is a system property, not a personality trait. Clear instructions help the model behave, but identities, permissions, policies, approvals, logs, and revocation determine what it can actually do.
For related controls, see What Information Should an AI Agent Be Allowed to See? and How to Design an AI Workflow That Fails Safely.
Explore more practical guidance in the Governance, Safety & Reliability hub.
Sources and further reading
- Microsoft Azure: AI agent shared responsibility model
- Microsoft Learn: Identity, access, and least privilege
- NIST: Design tenets for agent identity management systems
Build agents you can govern
Agentrepreneur: Building Your AI Agent Business in 28 Days connects safe authority with the broader work of operating an agent-enabled company. This article provides the boundary checklist; the book goes deeper into building a managed business system.
MEDIA