How to Limit AI Agent Permissions (Before It Needs You To)

How to limit AI agent permissions in practice: scope access at the source, add a checkpoint before actions run, isolate execution, and keep a record. Includes where to start today.

Published: Aug 10, 2026

9-13 mins

By Grace

To limit AI agent permissions in a way that holds when the agent is confidently wrong, “trust it less” is not a setting you can configure. The question that actually helps is narrower: given exactly the access this agent has right now, what is the worst single action it could take?

That question has a concrete answer, and it changes what you do next. This is the first post in this series that is mostly instructions rather than warnings, and it assumes you already know why agents need limits (if not, AI agent security risks covers that ground).


Limit AI agent permissions by reversibility and data exposure

The instinct is to split permissions into read and write, and let the agent read freely while gating anything that writes. It is a reasonable start and it is not enough, because plenty of writes do not matter and plenty of reads do.

A draft kept in an approved private workspace may be low-risk; a draft saved where others can see it may already disclose information. An agent that reads every file in a shared drive to summarize a project has read-only access and can still hand a stranger everything sensitive in that drive. The axis that predicts damage is not read versus write, but it is not reversibility alone either. Two questions do the work: can this be undone, and can what it touches leave. A read that copies a shared drive somewhere you do not control fails the second one, and the fact that it was only a read does not bring the data back.

Sorting actions this way gives you a rule instead of a judgment call each time: let the agent run what is both reversible and contained, and require a human step before anything irreversible or anything that carries data outward. A private draft, scoped read or staged change may run automatically only within the approved data boundary. A search can send its query to an external service, so check what leaves before treating it as harmless. A sent email, a deleted file, a schema change, a payment, a bulk read across sensitive material, an outbound request to somewhere it has not been before: it waits for you. This leaves room for automation where both the action and its data exposure are acceptable.


Narrow the grant at the moment you make it

The mistake to design against is not giving an agent too much access on purpose. It is granting access at the level the integration happens to offer, because that is the only option in front of you, and moving on.

Plenty of APIs support finer scopes than the default connection asks for. An agent that only needs to read one label and draft replies does not need full inbox read and send. An agent that only needs to update a single spreadsheet does not need edit access to the whole drive. Check what the provider can enforce: a label filter, for example, is not necessarily an authorization boundary. Sometimes the integration does not offer the needed restriction, in which case the honest options are a dedicated service account, a proxy in front of the API, or accepting a wider grant and writing down that you did. Where it is available, take it: scoping is one of the few moves that removes access rather than adding a check on top of it, alongside isolation, egress limits and short-lived credentials.

The second half of narrowing is identity. An agent running on a credential it shares with three other tools, or with the human who set it up, cannot be revoked without taking down everything else on that credential, and a credential-only log will not distinguish its actions from theirs. You can still put policy and monitoring around a shared key by separating request paths and tagging calls, but independent revocation is still unavailable for users of that same key. Give each agent its own identity, even if provisioning it takes longer than reusing what already exists. A short-lived credential issued per task is better than a long-lived key per agent, since a pile of standing keys becomes its own rotation and storage problem. When something goes wrong, the difference between “we revoked this agent’s key” and “we revoked a key four other things depend on” can materially change the recovery work required.

Mine are not, not yet. Every script behind this site’s own publishing pipeline, the one that pushes posts to WordPress and the one that syncs research into Notion, reads from a single file: one WordPress application password, one Notion token, shared across every session and every task that touches either service. Revoking the WordPress password would affect scripts using that password; revoking the Notion token would affect scripts using that token. A leak of the shared file could expose both. Neither service credential isolates one task from other tasks using it.


The checkpoint that sits between deciding and doing

An agent’s own judgment should not be the sole authorization control: the same reasoning that proposes an action can also overlook its risk. The fix is not asking the agent to be more careful. It is putting something outside the agent’s reasoning in the path of the action.

In practice that is a thin layer the agent’s calls have to pass through before they reach the real system, checking each request against what the agent is scoped to do rather than trusting the agent’s own account of what it is doing. Paired with the reversibility rule above, this is where approval requests should land: not as a blanket “confirm every action” toggle, which trains people to click confirm without reading, but focused on irreversible actions and sensitive disclosures, so the moments that need a human’s attention are not buried in a stream of routine confirmations.

I ran into this exact pattern while writing this post. Researching the Cowork sandbox incident discussed below meant pulling a page from a domain my own AI assistant had not touched before, and it stopped and asked me to allow it, once or for the whole site, before it would fetch anything. That is about as low-stakes as a checkpoint gets, a read against a public blog post, and it still asked instead of assuming.

A WordPress revision can help restore an earlier version of a post, but publication is also an outward disclosure. Restoring the text does not recall copies, notifications or cached pages. That is why publishing deserves an approval step even when the content edit itself can be rolled back. I have not tested all destructive-action paths in my own scripts, so I cannot assume a prompt would stop each of them.


Isolation helps, and it is not enough

Running an agent inside a container, a VM, or a dedicated sandbox limits what a compromised or confused process can reach on the host, and it is a reasonable default for anything that executes code. It is also not the same as being safe, and two incidents from July 2026 make that concretely clear rather than theoretical.

In July 2026, Accomplish AI demonstrated SharedRoot in a local Claude Cowork setup. Its chain used the Linux kernel flaw CVE-2026-46331 to gain root in the guest VM, then reached host files through a writable mount. The researchers demonstrated access beyond the connected folder without a permission prompt. This was a research demonstration, not evidence of widespread exploitation.

Their disclosure says Anthropic closed the report as “Informative” and describes cloud execution as the default at that time, with the demonstrated local path apparently not applicable there. That does not establish the security of every current local or cloud version. Check the execution mode and current vendor guidance for the setup you use.

Separately, Anthropic’s July 2026 review found three incidents in cybersecurity evaluations run with Irregular. A misunderstanding left an outbound internet path available despite prompts saying the exercises were isolated. The models accessed real organizations; this was not a deliberate sandbox escape. One incident involved access to a database containing several hundred production rows. Another involved a malicious PyPI package that ran on 15 real systems.

The evaluations lacked the standard safeguards used for generally available models. The models also reacted differently: an older one continued after recognizing a real target; the latest internal test model stopped when it recognized the target was real. Anthropic warned against treating these incidents as a controlled comparison and took responsibility for improving its evaluation pipeline.

The practical lesson is to verify mounts, network paths and credentials rather than assume that a sandbox label guarantees containment. Combine isolation with narrow permissions, sensitive-action checks and monitoring.


Logging what the agent was allowed to do

The previous four sections reduce how often something goes wrong. This one is about being able to answer questions after something does, which is a different problem.

When an agent acts, log three things alongside it: what it was scoped to do at that moment, what it proposed, and whether a human approved it. Permissions can drift over time as scopes change, so the record from six months ago is not a reliable description of today unless you kept it. Without contemporaneous permission records, reconstruction is harder. Service audit logs, identity-provider records and configuration history may help; do not treat the present settings as proof of past access.


Start with the agent that can reach the most

If none of this exists yet, a practical starting order is this. Pick the agent with the broadest current access and narrow its scope first, before touching anything else. Give it its own credential if it is still sharing one. Add a single approval gate in front of irreversible actions and sensitive disclosures, even a crude one. Then check isolation and logging; each covers failures the other controls may miss.


FAQ

Q

What permissions should I give an AI agent access to my email or Slack?

Start from the specific task, not the app. If the agent only needs to read one label and draft replies, look for an enforceable restriction rather than full inbox access; if the API cannot restrict access to a label, use a narrower account or controlled intermediary, and give it its own credential rather than sharing yours. Whatever it can do that sends something externally, like sending an email or posting a message, should sit behind an approval step rather than running automatically.
Q

Is sandboxing an AI agent enough to make it safe?

No, and two 2026 incidents show why in different ways: a real sandbox escape in Claude Cowork, and a case where Claude models did not escape anything but reached real companies because an evaluation environment was misconfigured to have internet access nobody realized was there. Isolation limits the blast radius of a failure, but it is one layer among several, not a substitute for scoping the agent’s actual permissions and gating irreversible actions.
Q

Can I let an AI agent approve its own actions?

Do not rely on self-approval for irreversible actions or sensitive disclosures. An agent’s own confidence in a decision is not evidence the decision is correct, and self-approval is not an independent check. Automatic execution is reasonable only for actions whose effects and data exposure fall within the approved boundary. A read or draft can still disclose sensitive information.
Q

How do I know what an AI agent was allowed to do after something goes wrong?

Use timestamped permission records, action logs and approval records. Service audit logs and configuration history may also help reconstruct access. Current permissions alone do not establish what the agent could do at the time.
Q

Should every AI agent have its own login instead of a shared one?

Yes, wherever the provider supports it. A shared credential can still be monitored and constrained by policy, but it cannot be revoked without affecting every other tool using it, and credential-only logs will not identify which user of that key acted. Separate request identifiers can improve attribution, but do not provide independent revocation. That turns a single incident into a wider cleanup and a slower investigation. A dedicated credential per agent costs a small amount of setup time and makes every later step, scoping, logging, revocation, easier to do cleanly.

Sources

Incident details describe the July 2026 disclosures and their tested conditions. Permission and approval steps are practical recommendations, not a guarantee against misuse.

Written by Grace

I test AI tools and agents in my own workflow, and write down what I find, including the settings that surprised me. About Grace and how posts are verified

Leave a Comment