AI agent permissions answer a simple question with surprisingly complex consequences: what is this agent allowed to do? Most teams start with API scopes — the agent's key can call the refunds API, so it can refund. That's access, not permission. Real permission depends on the amount, the customer, the time, and who's asking. Getting this right is central to AI agent security.
Access is not permission
An API scope says which endpoints an agent can reach. It rarely says under what conditions. A support agent with refunds:write can issue a $5 refund and a $50,000 refund with the same key. Human employees work the same way in theory — but they also have judgement, training, and a manager who'd notice. Agents need those conditions written down and enforced.
Three levels of AI agent permissions
A practical model gives every action one of three permission levels:
- Autonomous — the agent may do this alone. Low-risk, reversible, within normal bounds: look up an order, draft a reply, refund under $100.
- With approval — the agent may request it, and a named person decides. Above a threshold, unusual, or customer-facing: refunds up to $1,000, pricing emails, production restarts.
- Never — the agent can't do this, whatever it's told. Bulk data export, deleting production resources, granting admin roles.
The same tool can carry all three, depending on its arguments. That's why permissions belong at the level of each action, not each API.
Who decides the permissions
Engineering can implement permissions, but shouldn't decide them alone. The owner of each process sets the limits — finance for money, support for customer contact, security for access changes — and engineering reviews how they're enforced. Writing permissions as readable rules lets both sides sign off. Our guide to AI agent policy covers how to structure that.
Writing permissions as rules
A permission rule should be specific enough for a machine to check and clear enough for a process owner to approve:
policy "refunds" {
allow when amount <= 100
require_approval when amount <= 1000 approver = "finance-lead"
deny otherwise
}
Good rules use facts the checkpoint can see: the action, its arguments, the agent, the user, and context like daily totals or customer tier. More examples are in the use case library.
Common mistakes
- Reusing a human's credentials. The agent inherits everything that person can do. Give agents their own identity with narrow access — see least privilege for AI agents.
- Permissions only in the prompt. "Don't refund more than $100" can be talked past. Enforce limits outside the model.
- One agent, every tool. Split broad agents into narrower ones, each with a clear job.
- No review cycle. Permissions that made sense at launch drift as agents gain tools. Review them when tools change.
Where Gaten fits
Gaten enforces AI agent permissions on every tool call: allow, require approval, or deny, based on rules your process owners can read. See how policies work.
Frequently asked questions
What are AI agent permissions?
The rules that define which actions an agent may take on its own, which need a person's approval, and which it may never take — under specific conditions like amount or data type.
Aren't API scopes enough?
Scopes control which endpoints an agent can reach. They usually can't express conditions like amount limits, customer tier or time of day, which is where most agent risk lives.
How often should agent permissions be reviewed?
Whenever an agent gains a new tool or a new use case, and on a regular schedule — quarterly is common — for agents that handle money or customer data.

