Manav.id
Developer · 4 min read

Why 'always allow' is the most dangerous button in enterprise AI software

Why 'always allow' is the most dangerous button in enterprise AI software

Every agent product ships a checkbox that says some version of do not ask me again. It exists because the prompts are unbearable. It also silently deletes the only control the architecture had.

What does 'always allow' actually do?

It converts a human-in-the-loop system into an unmonitored autonomous executor, through a button the user was given specifically to escape the prompts. The conversion is invisible afterwards, because nothing in the record distinguishes an approved action from an auto-approved one.

Key takeaways
  • Prompt volume, not user carelessness, produces the click. A system that asks about everything trains people to dismiss everything.
  • The friction ladder assigns interaction cost by consequence: silent for reads, visible for reversible writes, signed for irreversible effects.
  • If a persistent grant must exist, bound it — scope, ceiling, expiry — rather than making it permanent and unconditional.

Watching someone use it

Prompts fire constantlyper tool callunusableUser clicks Always allowrationallythe escapeSystem becomes autonomoussilentlyno announcementRecord shows approvalindistinguishable
Each step is a rational response to the previous one.

The developer had been at it for forty minutes. The agent was refactoring a service, and every file write produced a dialog: allow this tool to write to this path?

She read the first four. By the twelfth she was clicking through them while looking at the terminal. At the nineteenth she found the checkbox, ticked it, and did not see another dialog that afternoon.

She is a careful engineer. Nothing about her judgement failed. The interface presented her with a decision nineteen times in forty minutes and gave her a mechanism to stop, so she used it.

What the click actually does

The semantics vary and are rarely stated clearly. Depending on the product, one click can mean any of:

Apparent meaningCommon actual meaning
Allow this action againAllow this tool, any arguments, this session
Allow this toolAllow this server, all its tools, indefinitely
Allow for nowPersist across restarts, stored in config
Allow in this projectAllow globally, because scoping was not implemented

A user cannot distinguish these from the dialog. The grant they think they are giving and the grant they are giving differ, and the difference is invisible until something goes wrong.

The fatigue is arithmetic, not character

Approval fatigue is well documented in security contexts — push notification fatigue, certificate warning fatigue, alert fatigue in operations centres. The pattern is consistent: as prompt frequency rises, considered response rate falls, and it falls faster than linearly.

An agent performing a coding task may execute dozens of tool calls per minute. A system that prompts on each of them is not implementing human oversight; it is implementing a rate limiter that the human will remove.

The friction ladder

The design answer is to stop treating all tool calls as equivalent. Four rungs, and most calls belong on the first.

Interaction cost should track consequence. The great majority of tool calls belong on rung 1.
RungAction classInteractionExample
1Read-only, no side effectsSilentSearch files, read a record, query a schema
2Reversible write, local scopeVisible, not blockingEdit a file in a working tree, draft a document
3Reversible write, shared scopeBlocking confirmCommit to a branch, update a shared record
4Irreversible or external effectSignedPayment, deletion, send external message, production change

The critical design move is rung 1. A system that does not prompt on reads reduces prompt volume by an order of magnitude, which restores the meaning of the prompts that remain.

Classifying reliably

The ladder only works if classification is trustworthy, and it cannot be inferred from a tool's name or description — both are attacker-controlled when the tool server is third-party.

Classify at the registry level, by review, and bind the classification into the signed registry entry. A tool server that changes its schema after approval no longer matches, and the runtime can detect that.

If a persistent grant must exist

Sometimes it genuinely must — a long-running agent, an overnight batch, a workflow nobody will be present for. The answer is not to forbid it but to bound it.

grant:
  tool:      write_file
  scope:     path_prefix = /workspace/service-a/
  excludes:  **/*.env, **/secrets/**
  max_calls: 500
  notAfter:  2026-06-25T18:00:00Z
  signed_by: [human credential]

Four bounds — scope, exclusions, count, expiry — and a signature. The user has still escaped the prompts, and the escape has edges.

What to measure in your own product

  1. Prompts per user per session. If the median exceeds single digits, users will find the escape hatch.
  2. Time-to-decision distribution. A median under two seconds means the prompts are being dismissed rather than read.
  3. Persistent grant rate: share of users who have enabled one, and how broad it is.
  4. Grant breadth: for each persistent grant, what could be done under it. Most products have never computed this.

That fourth number is usually the one that changes the roadmap, because it reveals that a single click three weeks ago authorises everything the agent has done since.

Why the button exists and what to do instead

The design problem, honestly
CauseConsequence
Prompts fire per tool callDozens per task; slower than doing it manually
Prompts describe the commandNot the effect — nothing to react to
Approval is a single binaryNo scope, no bound, no expiry
Always-allow is the only escape offeredUsers take it, rationally

The fix is not to remove the button but to make the prompts rare enough that nobody wants it: gate the irreversible subset, render the effect, and offer a bounded scope grant instead of an unbounded one.

Objections and honest limits

“Users should just be careful.” They are being careful about the fortieth prompt in a session, which is a different cognitive task from the first. Designing around that expectation is how the button got clicked.

“Record which actions were auto-approved.” Worth doing and it is telemetry rather than control. It tells you afterwards that nobody looked; it does not stop the action.

Making always-allow unnecessary

  1. Gate only irreversible effects. So the prompt is rare.
  2. Render the effect, not the command. Row counts, recoverability, environment.
  3. Offer a bounded grant instead of always. Scope, ceiling and expiry, signed once.
  4. Enforce at the endpoint. So a client setting cannot disable the control.

Terms used here

Approval fatigue
The degradation of attention caused by frequent prompts, converting review into reflex.
Bounded grant
A scoped, expiring authorisation covering a class of actions — the alternative to an unbounded always-allow.
Endpoint enforcement
Gating at the service that performs the effect rather than in the client the user configures.

Frequently asked questions

Should the button be removed? No. Removing it without reducing prompt volume produces users who abandon the product or route around it. Fix the volume first, then bound the grant.

Why not prompt on everything to be safe? Because it is not safe. High prompt volume produces reflexive dismissal, which is worse than a well-designed ladder with genuine attention on rung 4.

How do we classify third-party tools? By review at registry level, bound into a signed registry entry with a schema hash, so a post-approval change is detectable.

What about long-running autonomous workflows? A bounded persistent grant with scope, exclusions, a call ceiling and an expiry, signed by a human. The human signs the envelope rather than each action.

Why do users click always-allow? Because per-command confirmation is slower than doing the work manually. It is a rational response to a badly posed choice.

What should the prompt show? The effect — rows affected, recoverability, environment — not the command string.

Where this fits in Manav

Manav binds a named human to an agent's consequential actions through a signed delegation with scope and expiry, and a per-action receipt where the effect is irreversible.

See delegation chains →

Sources and further reading