Engineering · Agent Oversight

Agents Need an Undo Button, Not More Approval Prompts

Approval prompts wear out fast. A better way to keep AI agents safe starts with one question for every tool: how would we take this back?

Author
Quaspar Research
Published
November 16, 2026
Last reviewed
Last reviewed November 16, 2026
Reading time
8 min read
Article contents

The approval prompt problem1

The default way to make an AI agent safe is to make it ask. Before it sends the email, issues the refund or runs the migration, a person clicks Approve. It is easy to build and easy to explain, and security guidance recommends it for high-impact actions.

It also wears out quickly. On the first day, reviewers read every proposal. A few weeks later the agent is right most of the time, the queue is long, and Approve has become a reflex. Anyone who has clicked through a cookie banner or typed a password into a sudo prompt without reading it knows the pattern. An approval that is always granted is not oversight. It is latency.

The usual fix is to decide which actions need approval by how risky they feel. That helps, but risky is vague, and it puts the line in the wrong place. What makes a mistake expensive is mostly whether you can take it back.

Reversibility is the property that matters2,3,4

Take two actions an agent could get wrong: changing a support ticket's priority, and emailing a customer. If the priority is wrong, someone sets it back and nobody outside the team ever notices. If the email is wrong, it is now in someone else's inbox, and no button on your side removes it.

Databases worked through a version of this decades ago. A transaction can be rolled back until it commits. For long-running work that can't hold locks, the 1987 Sagas paper by Hector Garcia-Molina and Kenneth Salem paired each step with a compensating step that undoes its effect: a booking with a cancellation, a charge with a refund. Architecture guides for distributed systems still teach the same pattern today.

Agents are long-running, they take many steps, and they touch systems they don't own. In other words, they are sagas with a language model choosing the next step. So borrow the design: before a tool is available to an agent, write down how its effects get undone.

Four kinds of agent actions5

Reversible

The action has an exact inverse in a system you control: changing a field, moving a file, adding a label. Save the previous value and the undo is one call. Let the agent act, and show the undo right next to the result.

Compensable

The action can't be erased, but a follow-up can cancel its effect: a refund for a charge, a cancellation for a booking, a correction for a wrong price. Compensation is never perfect, because the customer may already have seen the charge. Cap how much of it the agent can do before a person looks.

Delayable

The action can't be undone once it lands, but you can hold it first. Gmail's Undo Send works this way: the message waits up to 30 seconds before it actually leaves. An agent's outgoing email, webhook or post can wait in a hold window long enough for a person or a second check to cancel it.

Irreversible

No inverse, no compensation, no useful delay: deleting data that has no backup, sending money to an outside account, posting in a person's name. These are the actions that deserve a person's full attention, every time.

Undo expires

Reversibility is not a fixed property of a tool. It decays over time.

A record the agent just updated is easy to restore. An hour later, another job may have read it, copied it into a report or sent a notification about it. Restoring the field no longer restores the world. A draft email is fully reversible until it is sent, delayable during the hold window, and irreversible after that. A refund is compensable until the books close.

So the honest answer to "can this be undone?" is "until when, and by whom?" Each tool should carry that answer: how long its undo stays valid, and what else can read its effect before then. An undo that only works for five minutes needs someone, or something, watching during those five minutes.

Write this down for every tool an agent can call

Do this before the tool is connected, not after the first incident.

  • Which kind of action it is: reversible, compensable, delayable or irreversible
  • The exact undo or compensating action, as tested code rather than a sentence in a prompt
  • How long the undo stays valid, and what can read the effect before then
  • What the agent must save before acting so the undo works: the old value, an ID, a receipt
  • Who may trigger the undo, and whether the agent may trigger it itself
  • What happens if the undo itself fails
  • How much compensable or irreversible work the agent may do in a day before a person steps in

Where people's attention goes

The goal is not fewer people involved. It is people spending their attention where it changes the outcome.

Approve everythingApprove by reversibility
Every action waits in one long queueOnly irreversible actions wait; the rest run with an undo ready
Reviewers judge what is about to happenReviewers also see what already happened and can reverse it
Safety depends on careful reading every single timeSafety depends on tested undo paths and a short queue worth reading
The agent is slow on easy workThe agent is fast on easy work and careful on the rest
A mistake that was approved is permanentMany mistakes are caught and reversed after the fact

Keep the undo outside the agent6

It is tempting to give the agent an undo tool and tell it to clean up after itself. That is fine as a convenience, but it can't be the safety mechanism. An agent that made a mistake because it misread the situation is the wrong party to decide whether the situation needs fixing. And an agent that has read a malicious instruction hidden in an email or a web page can be told not to undo anything.

The record of what the agent did, the saved previous values and the undo actions belong to the system the agent runs on. A person should be able to open a list of the agent's recent actions and reverse any of them without asking the agent.

What this doesn't solve

Reversibility isn't everything. Some actions leak information the moment they happen: if an agent puts a private document into a reply, deleting the reply later doesn't un-share it. Some compensations matter legally or socially, and a refund doesn't erase a customer's bad experience. And a tool labeled reversible when it isn't is worse than a tool with no label at all.

Treat each label as a design decision that someone owns and reviews. Test every undo path the way you test the action itself. An undo that has never been run is a hope, not a control.

Why we're writing about this

We build Quaspar, a shared cloud where teams test, deploy and run their apps and AI agents. Today in Workspace, outgoing messages, submissions and changes to connected systems wait for a person to review, and every decision is recorded. This essay is how we think about the trade-off between asking and undoing. It is not a description of a finished feature.

Quaspar is in private preview. If your team runs agents that touch real systems, you can request Studio access.

Next step

Quaspar is in private preview. Request Studio access to test and run your own agents with human review in one shared workspace.

Request Studio access

Sources

Authoritative references

Rules, standards, and guidance can change. The links below were reviewed on November 16, 2026.

  1. 1OWASP GenAI Security Project. LLM06:2025 Excessive Agency
  2. 2Cornell University course reading copy. Sagas (Garcia-Molina and Salem, ACM SIGMOD 1987)
  3. 3Microsoft Azure Architecture Center. Saga design pattern
  4. 4Microsoft Azure Architecture Center. Compensating Transaction pattern
  5. 5Gmail Help. Send or unsend Gmail messages
  6. 6OWASP GenAI Security Project. LLM01: Prompt Injection