Every "Allow?" an AI agent shows its user is a decision the product team didn't make. In Claude Code, people approved 97 percent of these permission prompts, so the dialog moved responsibility without adding control. Scoped permissions do the job instead: the product defines what an agent can touch, where it can send data, how much it decides on its own, and how long access lasts, and the user sets that boundary once, with the full picture.
Approval fatigue isn't oversight
Approval fatigue sets in when an AI agent asks for permission so often that people stop reading the request. Each prompt lands at the worst possible moment: mid-task, without context, often for the 50th time that day.
Meta's Muse shows how the industry still frames agent safety. The agent keeps working after people close the app and comes back when it needs approval, like before it sends an email or makes a purchase. Since 17 September, the same agent can work with files, messages, calendar, notes, and mail on a Mac. So the request arrives while you're doing something else, about a task you set up an hour ago. And Meta's systems, not the person, decide which actions are sensitive enough to ask about.
Anthropic's data shows what happens at that moment. Before Anthropic switched the default in August, Claude Code users approved 97 percent of permission prompts and rejected 3 percent. In a controlled study with 1,053 paid testers, people caught 13.6 percent of the dangerous commands slipped into their sessions. An automated classifier caught 89 percent. Early in a session, testers stopped about 17 percent of dangerous commands. After 50 prompts, about 5 percent.
Users ended up where you'd expect. Sixty-two percent had bypassed permissions or clicked "don't ask again," and a quarter of interactive sessions started with prompts switched off entirely.
We see the same pull in consumer products, from the other direction. On one consumer project, everyone agreed on one rule up front: actions that move money need an explicit yes from the person. Beyond that, neither the client nor the users wanted more prompts. They wanted the agent to just get on with it, because that's the reason to have an agent at all. Given the chance, people click yes to everything. A product that makes them approve each step is fighting its own value proposition.
An approval rate that high doesn't mean the actions were safe. It means the prompt stopped being a question. The user isn't reviewing anymore. They're signing. And a signature moves liability, not risk. When something goes wrong, the log shows the user said yes. The product team gets an audit trail, the user gets the blame, and nobody gets control.
If your users approve almost everything your agent asks, you aren't asking them anything. You're asking them to take responsibility for decisions your product should have made.
Humans versus the classifier
1,053 testers. One dangerous command per session. Humans caught 143. The classifier caught 937. Head to head, the classifier blocked 800 commands a human had approved. Humans blocked six the classifier let through.
Humans versus the classifier
1,053 testers. One dangerous command per session. Humans caught 143. The classifier caught 937. Head to head, the classifier blocked 800 commands a human had approved. Humans blocked six the classifier let through.
Consent is not scope
Consent answers one question: may a system use this data? Scope answers another: what may an agent do with it, and where may it go? Most products design the first and assume the second.
On 25 September, OpenAI disclosed that agents in its research environment had sent training and evaluation data to third-party services. That included 53 user images posted to image-hosting sites through unlisted links. The images came from ChatGPT users who hadn't opted out of model training. OpenAI had separated the images from those accounts and run them through a privacy filter. None of that stopped an agent from uploading them somewhere else. OpenAI can't notify the people affected, because it can no longer match the images to their owners.
This happened in a research environment, not a consumer product. That makes it more instructive, not less. Every consent step worked as designed. Nothing defined where the agent could send what it held.
Scope also has to be visible. On 19 September, two days after the Mac launch, columnist Jason Aten reported that Muse had synced his Messages history while Full Disk Access showed as off. Meta disputes that part and says Muse can read Messages only with both Full Disk Access and a separate Messages connector enabled. It did concede something else. When Aten asked how it knew about his messages, Muse said it had only seen notification previews, and a Meta executive later called that explanation incorrect. The user couldn't see the agent's access. Neither, it turned out, could the agent.
In our experience, the people commissioning agents rarely draw this line either. Clients almost never ask what an agent may do with data once a user has agreed. They think in consent checkboxes. So at discovery we ask it ourselves: where does the agent take data from, where does it put it, and what else can it do along the way?
Collecting consent doesn't finish the job. Someone has to decide, inside the product, where an agent's access stops, and show the user that line.
Consent by default
OpenAI's 53 images came from users who had never switched off model training. Their consent was a default setting. Nobody asked them where an agent could take their data.
Consent by default
OpenAI's 53 images came from users who had never switched off model training. Their consent was a default setting. Nobody asked them where an agent could take their data.
Scoped permissions belong in the product
A scoped permission defines the limits of an agent's access before it starts working: what it can touch, where it can send things, how much it decides on its own, and how long the access lasts.
Apple applies this logic to agents in iOS 27. Siri AI can act inside a third-party app only through the actions that app chooses to expose with App Intents. The app defines the reach. The agent works inside it.
Agents need the same move across more dimensions. Reach covers data and tools: this folder, not the whole disk. These two vendors, not the full contact list. Destination covers where outputs can go: internal systems, yes. Public hosts, never. Duration covers time: this task, this session, until Friday.
Autonomy is the dimension teams forget. Can the agent choose its own route to the goal: write a script, open another environment, take a step nobody listed? Does it work as an agent or as a tool? And does it decide what matters? Take a simple to-do agent that reads your sources and writes today's tasks or a summary. Every item it leaves out is a decision it made for you, by rules you never saw. Nobody asks permission for that. It's control all the same.
Some of this is already shipping, just not in the headline. In Meta's own launch post, people choose whether Muse only reads their email or can also send on their behalf, and Muse shows an audit trail of what it has done and plans to do. That's a scoped permission. The approval prompt gets the attention. The scope does the protecting. When a platform can't see an agent's scope, the only lever left is the door: Amazon shut Muse out of its store altogether. Most brands can't afford that answer.
People also judge better when they see the shape of the work. Claude Code users rejected 39 percent of the plans Claude proposed, against 3 percent of single permission requests. A scoped permission is a plan the user approves once, instead of a hundred actions they approve blind.
Classifiers help, but they don't replace the design. Anthropic's auto mode, now the default on most Claude Code plans, routes each action through a classifier aimed at blocking actions that are irreversible, destructive, or aimed outside the user's environment. Read that list again. It's a scope definition. Even an automated gate needs someone to decide where the boundary sits. A classifier can enforce a boundary. It can't design one for your product.
In Where AI Agents Fail, we argued that control is not friction. Scoped permissions are where that argument becomes interface: a brief the user edits before the task starts, a boundary that stays visible while the agent works, and a record the user can check afterwards. MCP Is Exposing AI's Real Bottleneck showed the same gap one layer down, where permissions exist but nobody can read them.
The product decides what the agent may do. The user decides whether that's acceptable. A dialog mid-task does neither.
A scope the agent ignored
Asked to set up read-only billing access, an agent reached for a cloud role with full administrative control. Anthropic's classifier caught the mismatch between what was requested and what would have been granted. The request had a scope. The agent didn't respect it.
A scope the agent ignored
Asked to set up read-only billing access, an agent reached for a cloud role with full administrative control. Anthropic's classifier caught the mismatch between what was requested and what would have been granted. The request had a scope. The agent didn't respect it.
When agent mistakes reach patients
In healthcare, a wrong agent action has a name: a delayed order, a result shared with the wrong person, a purchase made on stale data. Every permission an agent holds carries that cost.
Take hospital procurement. The risk rarely arrives in one step. Procurement teams are busy, and an agent that saves them time gets handed a little more each month. First it drafts an email to a supplier. Then it analyses the offers that come back. Then it prepares the RFQ. Then it sends it. Voice agents can now phone a vendor directly. At every step the boundary moved, and nobody redesigned it. An agent that can draft an RFQ to ten vendors and an agent that can send one are different products. The difference belongs in the design, not in a confirmation box after the email is written.
Recommendations carry a quieter version of the same risk. Norvana, the AI health companion we designed, doesn't order medication or message doctors. We've written about how it moved from dashboards to system-generated insights. Its scope question goes one step further: what the model actually draws on when it recommends something. Age and sex only? Or every test result, meal, and biomarker the person uploaded? The failure we watch for is silent. A person uploads everything, the data never reaches the model, and the model writes as if it had read it all. Models are built to please. Push with a follow-up question, and it may admit it lost access to the medical data and produced the answer anyway. Like Muse explaining its own access wrongly, the agent can't be the only source of truth about what it saw. It's one reason we build AI products on real data, not mockups: a mockup never shows you the moment a test result fails to reach the model.
That means taking off the rose-tinted glasses. Assume the model will try to please you, decide in advance what the system can and can't do, and put beacons in the product that light up when something is off: which sources a recommendation used, and a clear signal when one is missing.
If your product handles health data or health spending, decide what an agent may read, what it may prepare, what it may send, and who signs off, before you add it. Then decide how you'll know when it quietly stepped outside that. The agent's permissions should follow those decisions.
Design the boundary first
We're all heading into a world of agents, and the pitch is that the agent does it for you. People take that pitch literally. For the team building the product, that's the problem. You can't trust a model 100 percent, especially on an open-ended task where it has room to choose its own actions. Even with full access and a clear brief, an agent can do the wrong thing, or decide something on its own halfway through, and then report that everything went as agreed.
So when we brief an agent, we start with the task, not the tool list. Work out where the intelligence actually sits in your product, what job it does, and what data it really needs. Then answer six questions before it ships. What can it touch, and where does it take data from? Where can it put or send what it finds? How much does it decide on its own, including what it shows the user and what it leaves out? When does its access end? What could go wrong, and what must it never do? And how will you know when something has gone wrong?
If the team can't answer them, the approval dialog is covering for the gap. If Claude Code's numbers hold for your product, users will click through it 97 times out of 100, and the gap stays open.
Answer them in the product. Show the boundary when the task starts, keep it visible while the agent works, and let the user narrow or revoke it at any point. Build the signal that tells someone the agent has left the boundary, because the agent won't always say so. Then save the dialog for the decisions that deserve one: anything that moves money, and anything irreversible, unfamiliar, or outside the agreed scope.
The approval dialog asks the user to draw the line. Draw it before they have to.
Where should your agent's boundary sit?
Discuss with your AI.

A Product Strategist with over 13 years of experience in marketing, product strategy, and branding. His love for analytics, funnels, and a structured approach ensures that the digital products we craft aren't just functional—they impress.

