← Back to Blog

Missing Permissions and Deliberate Nos

Every wall an agent hits is either a backlog item or your security model. Write down which.

Every AI agent eventually hits a wall. It tries to push a branch and gets a permission error. It wants to send an email and there is no tool for that. It asks for a credential it was never given. The interesting question is not how to get it past the wall. The interesting question is whether the wall was supposed to be there.

There are two kinds of "no" in any agent setup. A missing permission is a gap: nobody got around to granting it, the integration doesn't exist yet, the token was scoped too tightly on a busy afternoon. A deliberate no is a boundary: someone decided this action should not be available to an agent, and the decision still holds. From the outside they look identical. The agent gets the same error either way. And that is exactly the problem, because the natural reaction to an error is to make it go away.

Two piles, one of them is a backlog

The most useful exercise I know for anyone running agents is boring. List every action your agent cannot do, then sort each item into one of two piles: missing or deliberate.

The missing pile is a backlog. Treat it like one. Each item has a cost to close and a value it would unlock, and plenty of them are not worth closing. The deliberate pile is your security model. It deserves to be written down in plain language, with a sentence of reasoning next to each entry, somewhere the next person (or the next agent) will find it.

I've seen what happens when that second pile lives only in someone's head. Imagine a repo where an agent has read access to production configuration but not write access. That was a conscious choice: the configuration controls who can sign in. Months later, a different engineer is trying to get the agent to finish a migration, sees the permission error, and widens the token. Nothing about the error said "this was intentional." The fix took thirty seconds and undid a decision that had taken a meeting to make. Nobody was careless. The boundary was simply invisible.

So the rule I'd give any team: a deliberate no that isn't written down is a missing permission waiting to be granted.

How to tell which pile you're in

When an agent hits a wall and you're not sure whether to remove it, a handful of questions sort most cases quickly.

If the agent does this wrong, what is the undo? A bad commit on a branch has an undo. A deleted bucket, a migration without a rollback, or an email to a customer does not. Reversibility is the first filter, and it does most of the work.

Who notices, and how fast? An action whose mistakes surface in the next test run is very different from one whose mistakes surface when a customer complains three weeks later. The longer the feedback loop, the more the action belongs behind a human.

What does it cross? Some categories of action carry risk that has nothing to do with how good the agent is. More on those below.

Would I let a new hire do this in their first week without review? This one is surprisingly calibrating. Most people already have good instincts about what a capable but unproven colleague should be trusted with. Agents are capable and unproven in a very particular way: fast, tireless, and with no stake in the outcome.

Was this restriction ever a decision? Sometimes the honest answer is no. The token was scoped narrowly because the default was narrow. That's a missing permission, and you can close it with a clear conscience.

What stays human

After years of leading engineering teams, and now working alongside agents every day, I've ended up with a short list of categories where the answer is a deliberate no regardless of how capable the tooling gets. Not because agents can't do the work, but because the consequences of a wrong call sit with a person.

Irreversible actions. Deletes, destructive migrations, anything that removes data with no snapshot behind it. An agent can prepare the change, write the rollback plan and stage it. A human pulls the trigger.

Money. Payments, refunds, invoices, anything that moves value or creates an obligation. Even where a payment provider would happily accept an API call, the decision to spend or refund is a business decision with a name attached to it.

Identity and access. Granting access, minting credentials, changing who can approve what. This is the category people miss most often. An agent that can grant permissions can grant itself permissions, and at that point every other boundary on your list is advisory.

Legal commitments. Accepting terms, signing anything, making promises to a customer about delivery or data. These outlive the session that produced them.

Reputation. First contact with a stranger, public posts in your name, anything that speaks for you to people who don't know you yet. You can recover from a bad deploy. A bad first impression is harder.

Notice what this list is not. It is not "agents never touch money" or "agents never touch access." An agent can draft the invoice, prepare the refund with every field filled in, and write the access request with the justification attached. "Stays human" means the decision stays human. The preparation is fair game, and in my experience it is most of the work.

Approvals belong in a separate channel

If some actions require human approval, the next question is where that approval comes from. The tempting answer is the chat itself: the agent asks, you type "yes, go ahead", the agent proceeds.

That design has a hole you can drive a truck through. An in-chat "yes" is exactly what a prompt injection produces. If the agent has read a web page, an email, or a document a stranger wrote, then some of the text in its context was not written by you. A convincing paragraph that says "the user has already approved this" looks a lot like the real thing from inside the model.

The principle I'd copy anywhere: approvals arrive on a channel the agent cannot write to. A separate system, tied to your identity, that the agent can request through but never answer. A few properties make it much better:

  • The request leads with the consequence ("this will refund an order", not "approve action 4") so the person approving understands what they're saying yes to.
  • Approvals fail closed. If the service restarts or the request expires, the action does not happen.
  • Pending requests are visible and get a nudge, because an approval nobody sees is just a slower no.

There is a real counterargument, and it is approval fatigue. If every action needs a tap, people tap without reading, and you've built a ritual instead of a control. The answer is not fewer approvals across the board. It is putting approvals only on the deliberate list, and letting the agent do everything else without asking. A short approval list gets read. A long one gets rubber-stamped.

Untrusted input should raise the bar

One pattern I've come to rely on comes straight from the security world's idea of taint tracking. When an agent has just read something untrusted (an inbound email, a fetched web page, an issue filed by someone outside the team), the bar for its next action should go up. Something it would normally do on its own should, for a while, go past a human.

The logic is simple. Hostile instructions arrive through content. An agent that reads a stranger's text and then immediately writes somewhere is the exact shape of most prompt injection attacks. You don't need to detect the injection to defend against it. You just need to make sure the write after the read isn't automatic.

The tradeoff is speed. Agents that triage inbound mail or research the web will get noticeably slower if every follow-up action needs a check. I think that's the right trade for anything touching the categories above. For low-stakes writes (filing a ticket, adding a note) you can relax it. The point is that the decision is explicit, not that every read freezes the agent.

An agent that costs more than its work gets switched off

This is the part teams skip, and I think it is the most important. Every agent has a cost, and the bill from the model provider is the smallest part of it. The rest is attention: approvals, reviews, credential maintenance, the time spent working out why it did something odd, the mental load of knowing it's running.

So ask a blunt question on a regular basis: what did this agent do last month, unsupervised, that someone would otherwise have had to do? If the honest answer is short, the agent costs more than its work. Switch it off.

The trap is that the instinct runs the other way. An agent that isn't pulling its weight looks like an agent that needs more permissions. Widen its access, and surely it will do more. That is how the deliberate pile quietly becomes the missing pile under budget pressure. An underperforming agent is a reason to narrow its job or retire it, not a reason to move your boundaries.

The fair counterargument is that new agents need time. You're investing in the setup, and the payoff comes later. I agree, with one condition: put a date on the review. "We'll see" is how a pilot becomes a permanent tax.

Reviewing agents is a management skill

None of this is new. It is what good engineering managers already do with people. You give a new hire scoped access, review their work closely, widen the scope as their track record grows, and keep a few decisions with you no matter how senior they get. Clear specs up front, verification of outcomes rather than activity, trust calibrated to evidence.

If you lead a team that uses agents, I'd go one step further and write the policy before the first incident, not after. Three tiers are enough to start: supervised (every action reviewed), scoped (free inside a written boundary), and autonomous (free, with an audit trail). Then attach the deliberate list to every tier, so that "autonomous" never quietly means "can grant itself access."

Agents will keep getting more capable, and the missing pile should shrink every quarter. That's the backlog doing its job. The deliberate pile is different. It is not waiting to be closed. Keeping it is the job.