Tool permissions for AI agents
Tool permissions for AI agents: read, write and confirm tiers, Stop, and why actions need a person's approval
An agent becomes dangerous when it can act, not when it can talk. How Klyroe decides, in code and never in the model, which actions run, which ask, and which always need a person to slide to approve.
What we say Klyroe does was checked against our code on the day of writing. We describe each control in general terms and leave out exact limits, so they are harder to work around. Where something is planned rather than built, we say so. No control here makes misuse impossible; together they make it slower, louder and easier to stop.
The problem: the model proposes, something must decide
A language model on its own produces text. Give it tools and that text becomes actions: a file is written, an email goes out, a page is submitted. Every route from a chat to a cyber attack runs through that step, which is why the OWASP Top 10 for LLM applications lists excessive agency as its own risk: an agent with more functions, more permissions or more autonomy than the task needs.
The rule we build around is simple. The model proposes a tool call. Code on our servers decides whether it runs, asks, or is refused. Nothing the model writes, and nothing a web page it read writes, can change that decision.
Three tiers, fixed in code
Each in-app action Klyroe can take is its own typed tool with a strict input schema, and each tool has one tier, written in a table in our code. The model cannot pick or change a tier.
| Tier | What happens | Examples |
|---|---|---|
| Read | Runs at once | List my things, open a page in the app |
| Write | Runs at once, unless outside text reached this reply; then it asks | Create, rename or move a chat or project, draft an agent |
| Confirm | Always asks; the person slides to approve, one action at a time | Delete anything, publish or deploy an agent, run or schedule a routine |
Two details matter more than the table. First, the per-chat "Always allow" never applies to confirm-tier actions, so one careless click can't turn every later delete into a silent one. Second, the tier is chosen by what an action can cost or expose, not by how big it sounds. Pausing a routine only stops spending, so it is a plain write with Undo. Resuming it starts unattended runs, so it slides.
The input schemas do quiet work too. Unknown fields are refused, names are trimmed and length-limited, and control and formatting characters (the kind that can hide or reverse text on screen) are rejected. Links an action card shows come from an allowlist of in-app pages, never from an address the model wrote.
Taint: when outside text arrives, writes ask
The hardest case is not a malicious user. It is an honest user whose agent reads something written by someone else: a web page, an attached file, a search result, another tool's output. If that text contains instructions, the model may follow them, and a create or rename it asks for looks exactly like one the user asked for.
So each reply carries a server-side record of what outside text has reached it. Only the server adds to it, and nothing the model writes can clear it. Once anything from outside the user's own words is in the turn, write-tier actions stop running on their own and ask instead, and the card says what was read (for example, a web page).
The list in code is of tools that do not taint (the model's own drafts, the user's own answers). Every other tool taints, including tools added later. A new tool is treated as risky until someone decides otherwise, which is the safe default for a list that grows.
- Input schemaUnknown fields are refused, sizes are bounded and hidden control characters are rejected.
- TierRead, write or confirm, fixed in code for each tool. The model cannot change it.
- Outbound checkWhere the call goes and what it carries: blocked destinations, credentials and personal data.
- TaintIf outside text has reached this reply, a risky write asks again.
- The personAllow, or slide to approve for confirm actions. A slide is single use and never becomes Always.
- LogA call that runs, runs as the signed-in person and is recorded with secrets removed.
Approvals that can't be widened
Approving every action one by one quickly trains people to click Allow without reading. So Klyroe lets a person approve a tool once, for one chat or task, on one site, or always, and keep rules in their settings. The limits on that are the safety part.
- Built-in tools that move money, send messages, place calls or delete data can't be approved in advance.
- The server sends the answers a card may offer and checks the reply against them, so a hand-made request saying "always" counts as Allow once.
- Once outside text has reached the turn, an earlier approval for a risky tool does not skip the card.
Several independent checks run before a tool call goes ahead: taint, the outbound check, the person's own "ask first" rules, steps that always confirm, and our base policy. A saved approval can only skip a card when none of them objects, and no check can loosen what another has already refused.
The browser agent's own rules
When Klyroe's agents work in their own cloud browser, a second set of rules sits in front of every click and keystroke:
- Some kinds of page are off limits whatever the settings: online banking and payments, checkout, crypto, government ID services, password and security settings, and medical portals.
- The agent never types into password, one-time-code or card fields, and never types a card number anywhere. When a site needs a sign-in, the person takes over and does it themselves.
- Anything that submits, books, sends, posts, buys, accepts or deletes waits for the person's approval of that exact action, even when the action is otherwise allowed.
- After a page that addresses the AI directly, every action asks.
Stop, Undo and the kill switch
A person must be able to end a run, not only decline the next step. Stop is a server-side request, not a button that only hides the stream: the run is aborted on the server.
Most write actions can be undone for a day, if nothing changed since. Deletes have no Undo, which is why they are confirm-tier. And the whole feature has an operator switch: setting app actions to off turns them off for every account, without a deploy of new code.
Rate limits sit underneath all of this, per person and per tier, with a tighter limit the more an action can change. They are not the main defence. They are there so that a loop, whether a bug or an attack, runs into a wall quickly.
Why a person, and not a second model
It is tempting to replace the approval card with another model that judges each action. A second model helps as a signal, and we use rule-based detectors that way. But a judge model reads the same untrusted text as the agent, so the same instructions can reach it. A person approving a card that the server wrote from the real object ("Delete the chat Q3 notes, 12 messages") is outside that loop.
The NCSC makes the same point about prompt injection in general: it should be treated as a risk to be reduced and contained, not a bug that one filter removes. Limiting what an agent may do without a person is the containment.
What this does not cover
These tiers govern actions inside Klyroe and the browser agent. They do not stop a person from asking a model for text and then misusing it by hand; that is the job of the model's own rules and our acceptable use policy, covered in the overview article. Nor do approvals help if the person approving is the attacker. For that case the controls that matter are the account limits, the outbound check and the activity log.