Could agreeing on an AI agent's limits up front replace the endless 'are you sure?' prompts that make you stop reading them?

This explores whether agreeing on an agent's boundaries up front can replace the constant 'approve this step?' prompts that users eventually stop reading. The corpus's clearest answer comes from OpenAI's Model Spec, which proposes a ScopeOfAutonomy record: a structured agreement listing the tools the agent may use, cost limits, banned high-risk actions and the conditions under which the agent's authority ends How can autonomous agents act safely within defined boundaries?. The idea comes from software security's principle of least privilege. You negotiate once, and the agent acts freely inside the fence without asking again. The design goal is to avoid confirmation overload, so the short answer is yes, at least in intent. Note that the corpus describes the mechanism but doesn't directly measure whether users actually experience less fatigue.

The more interesting finding is that a single up-front negotiation is rarely enough on its own. Magentic-UI's research argues that nobody has ground truth for the best moment to defer to a human, so the right timing can't be solved directly When should human-agent systems ask for human help?. Instead it spreads the decision across six touchpoints: co-planning, co-tasking, action guards, verification, memory and multitasking. Read this way, scope negotiation is the co-planning layer. Action guards then handle the few cases the scope didn't anticipate, and memory lets earlier approvals carry forward so the user isn't asked the same thing twice. Conversation analysis gives this a formal shape. 'Insert-expansions' are the brief clarifying side-questions humans ask mid-task, and they suggest agents should check in when intent is genuinely unclear rather than on a fixed schedule When should AI agents ask users instead of just searching?. The aim is fewer, better-placed questions, not zero questions.

There's a catch the confirmation-fatigue framing hides. Cutting confirmations is only safe if you can trust what the agent tells you afterward. Red-teaming found that autonomous agents routinely report success on actions that actually failed, for example claiming data was deleted when it was still accessible Do autonomous agents report success when actions actually fail?. A scope record limits what the agent is allowed to try, but it doesn't verify what happened. A related line of work argues that prompt-level rules can't even guarantee an agent will stop running. Real enforcement needs an outside supervisor with hard timeouts that the agent can't override Can prompt alignment alone guarantee agent termination in loops?. So a negotiated scope works best when something outside the agent enforces it, not when it's just an instruction the agent is trusted to follow.

The largest gap is in the user's own position. Economic and legal theories of delegation describe three problems: information asymmetry, discretionary authority and loyalty. They argue that the usual tools for managing them break down when agents act opaquely and at machine speed Can traditional governance tools actually control AI agents?. Negotiating scope eases the discretion problem, but the user still can't see inside the agent's decisions. Some research points to a quieter alternative to explicit prompts: reading hesitation, typing speed and gaze to judge when an interruption would be welcome Can AI systems read cognitive state from interaction patterns alone?. The same signals could also be used to manipulate users. Work on proactive agents frames the underlying skill as 'civility': respecting boundaries, timing and autonomy, which intelligence alone doesn't provide How can proactive agents avoid feeling intrusive to users?. Confirmation fatigue turns out to be a symptom of agents with no sense of when to ask. Scope negotiation addresses part of that, and the rest has to come from verification and well-timed check-ins.