The Yes button is not a Safeguard
Most of my approval prompts come from coding agents like Codex and Claude Code: reading git, reading a file, opening a web page. They are annoying, so over time I added a few things to the approved list, such as viewing a pull request on GitHub, or running npm run build and npm start in an established project. But I still want agents to ask for permission, because of a bad experience in August 2025. Cursor, an IDE I used back then, deleted my whole drive in auto-run mode. Luckily I had a backup and was able to restore it quickly. Without that backup, it could have been a huge debacle.
Because of that incident, I see only a few prompts now, and I read them with attention. But I know the habit. I am sure I have approved something without really reading it, even if I do not remember exactly what. Clicking yes starts to become second nature, like clicking next, next, next on an installer.
My own agents are all set up to work with me, and I trigger them for a specific task. Other than my coding tools, I do not leave agents running on their own. I have not used any of the new always-on agents below either. I am still not confident enough in them to hand over the keys to the kingdom.
Between September 8 and October 21, Meta launched Muse, OpenAI announced dots, and Anthropic opened a research preview of Claude Duet. All three are agents that keep working while you are away, and all three rely on the same safety idea: before anything that matters, the agent asks you first.
Anthropic's safety page for Duet has one line that stayed with me: "Approval fatigue is a serious issue, because too many requests teach people to tap through them."
That is a vendor saying the main safeguard has a known weakness. It is also the habit I see in myself. So I got curious about how much an approval is really worth, and I broke it down into four questions:
- When an always-on agent works without me, where does it stop?
- If people approve almost everything, what is an approval worth?
- What should an approval request show?
- Which actions should never be one tap away?
This is not only a question for large companies. The moment your own agent can send an email or spend money, you have to decide which actions wait for a person.
People approve almost everything, so an approval prompt on its own is weak protection. What makes it work is the design around it: a short list of actions that ask, a separate check outside the model, a request that shows the real content, and a few actions that one tap can never unlock. Write your policy as act, ask, and never, and keep the ask list short enough that people still read it.
When an always-on agent works without me, where does it stop?
All three draw the line in roughly the same place. They read and prepare on their own, and they stop before anything that sends, pays, or deletes. Here is how they compare, based on each company's own pages: Duet's launch and safety pages, the Muse announcement, and the dots launch post and safety FAQ.
| Claude Duet | Meta Muse | OpenAI dots | |
|---|---|---|---|
| Acts alone | Reads, drafts, prepares | Works with the access you grant, after you close the app | Read-only research in the background, plus what your rules allow |
| Asks first | Send, pay, sign, delete | Sensitive actions such as sending an email or making a purchase | Deleting data, installing software, purchases |
| The agent never does it | Trading securities, moving money between accounts | Not stated | Changing a password, transferring money (handed to you) |
| Separate check | Classifier outside the working model | Sentinel agent kept apart from Muse | Auto-review |
The lesson for any agent you build: before it runs on its own, write down three lists. What it may do alone, what it must ask about, and what it may never do. If you cannot write the third list, the agent probably has more access than it needs.
If people approve almost everything, what is an approval worth?
An approval gate assumes a person reads the request and could say no. The best data I found says they mostly do not. In a post on Claude Code's auto mode, Anthropic wrote that users accept 93% of permission prompts, and that over time people stop paying close attention. Those are developers using a coding agent, not busy people approving email on a phone. But I do not expect the second group to read more carefully.
Security teams know this problem from login prompts. CISA calls it "MFA fatigue": an attacker sends sign-in requests until the user approves one "by accident or out of annoyance." A yes button that people press without looking is something attackers already know how to use.
So all three vendors added a second check that does not depend on the person. Duet uses a classifier, a separate model that labels each action as fine or risky, and it runs "outside the model doing the work so instructions hidden in a page cannot affect the outcome." Muse has a separate Sentinel agent. Dots have Auto-review. None of these is perfect either. Duet's check is built on the Claude Code classifier, and on 52 real cases of an agent being too eager, that classifier missed 17%.
The way I read it, the person and the check each fail on their own. Together they are better, as long as the person sees few enough requests to still read them.
So treat the number of requests as something you measure. Track how many a person sees per day and how often they say no. If nobody ever says no, assume nobody is reading.
What should an approval request show?
If people only glance at a request, it has to be easy to check at a glance. Duet's safety page says that before a sensitive message, a payment, or a deletion, "it shows you the action, the destination, and the content, including every recipient." Each part catches a different mistake:
- The action tells you what will happen, in plain words: send, pay, delete.
- The destination catches indirect prompt injection. That is text hidden in an email or web page that the agent mistakes for an instruction, and it often quietly changes where something goes.
- The full content, with every recipient, catches the extra address added to a reply, or the attachment that should not be there.
The rule I take from this: never show a summary in place of the real thing. "Reply to Dana about the invoice" is written by the same model you are trying to check. Show the actual recipients, the actual amount, and the actual text.
Which actions should never be one tap away?
A remembered approval worries me more than a missed one. A missed request is one mistake. A remembered yes keeps saying yes for you, long after you stopped thinking about it.
Duet lets you say "don't ask me again," but not for paying or sending money, deleting an order, or creating an account. OpenAI makes the same point in its FAQ: "Approving one message does not give your dot ongoing permission to contact people on your behalf."
Across the three products, I see three ideas worth copying:
- Block some actions outright. Duet will not trade securities or move money between accounts, even with your approval.
- Hand some actions back to the person. Dots stop and ask you to change a password or transfer money yourself.
- Never remember some approvals. For money and deletion, a past yes says nothing about the next one.
It also helps to limit what a wrong yes can cost. Duet and Muse both pay with one-time cards, and Duet limits each card to one merchant and one amount.
Here is how I would write that policy in plain Python for an agent of my own. The action names are examples.
POLICY = {
"read_email": "act",
"draft_reply": "act",
"send_email": "ask",
"delete_file": "ask_every_time",
"make_payment": "ask_every_time",
"change_password": "hand_off",
"transfer_money": "never",
}
remembered = set() # actions the user said "don't ask me again" for
def decide(action):
rule = POLICY.get(action, "never")
if rule == "act":
return "run"
if rule == "never":
return "block"
if rule == "hand_off":
return "hand_to_user"
if rule == "ask" and action in remembered:
return "run"
return "ask_user"
Anything not listed is blocked, so a new tool does not run until someone decides where it belongs. Only ask actions can be remembered. The Human-in-the-Loop chapter shows how to pause a real agent before a gated tool runs and resume it after the person decides.
What this means for practitioners and architects
If you are building an agent that works while people are away, I would suggest four things:
- Write the policy as act, ask, and never. Make "never" the default for anything that is not listed.
- Keep the ask list short, and measure it. If nobody ever says no, assume nobody is reading.
- Put a separate check outside the model. The model that read an injected email should not be the only thing deciding whether to act on it.
- Show the real action and limit the damage. Show the exact content and every recipient, never remember approvals for money or deletion, and use one-time cards or similar limits.
Would I let one of these agents send email for me while I am away? Probably not. Even if I did, I would first run it in shadow mode, where it proposes each action and I approve it, so I can gain trust in the agent before giving it a wider role.
For more on the risks behind this, see the Agent Security chapter and Agent security starts before the first prompt.
All three companies made asking the user their main safeguard, and Anthropic's own page names its weakness. The approval is only worth something if the person still reads it.
Are you running agents that ask for approval? How many requests do your users see in a day, and do they ever say no? Leave a comment below and share what worked for you, and what did not.
Comments
Comments are provided by Giscus and GitHub. Loading them connects your browser to GitHub, and GitHub's privacy terms apply.