Undo is what lets you delegate

Ask someone why they won’t let an agent touch their CRM, send the email, or run the refund, and they’ll say they don’t trust it yet. Push on that and you’ll find they don’t actually mean the agent is dumb. They mean they’re afraid of the version of the mistake they can’t take back. The fear isn’t “it might be wrong.” It’s “it might be wrong, and then I’m explaining to a customer why we double-charged them.”

Those are different fears, and only one of them is about intelligence. The other is about reversibility. And reversibility, not accuracy, is usually the thing standing between an agent and real work.

A cheap mistake is a delegatable one

Watch how you delegate to people. You don’t hand someone a big task because you’ve verified they’re flawless. You hand it over because the cost of them getting it wrong is bounded and recoverable. A draft can be edited. A proposal can be revised before it goes out. You delegate freely into reversible territory and you clamp down hard the moment the action becomes one-way: the wire transfer, the public announcement, the deletion. The deciding variable was never how good the person is. It’s how expensive their worst case is.

Agents are the same, and we keep getting the order backwards. We try to earn trust by making the agent smarter, hoping accuracy climbs high enough that we stop worrying. But you can’t accuracy your way out of a one-way door. A 99% accurate agent that permanently deletes data is still terrifying, because the 1% is unrecoverable and you’ll meet it eventually. Meanwhile a merely-decent agent operating in a world where every action can be undone is something you’ll hand real work to today, because the worst thing that happens is you click undo.

So the feature that unlocks delegation isn’t a better model. It’s reversibility, and it shows up in three concrete shapes.

Dry-run first. Before the agent does the thing, it shows you exactly what it would do: these 14 records get updated, this email goes to these 200 people, this charge gets refunded. You approve the diff, not the intention. A dry-run turns a leap of faith into a reviewable plan, and most of the fear evaporates right there, because now you can see the mistake before it happens instead of after.

Undo after. When the action is taken, it’s taken in a way that can be walked back. The update is logged with its previous value. The send is queued with a cancel window. The change is a transaction, not a fact. Undo doesn’t make the agent correct. It makes being incorrect cheap, which is the only thing your nervous system actually cares about.

Reversible by default, irreversible by exception. The agent treats one-way actions as a different category. It can update a draft on its own all day. It cannot send the thing to the customer, move the money, or delete the record without crossing a gate you control. The line isn’t drawn by how confident the agent feels. It’s drawn by whether the action can be taken back, because that’s the line that decides whether a mistake is a shrug or an incident.

Put those together and the trust question changes shape. You stop asking “is this agent good enough to never make a mistake,” which is a question no honest engineer can answer yes to, and start asking “when it makes one, how fast and cheap is the recovery.” That second question has real answers, and the answers are things you can build.

This is why we treat dry-run, audit trails, and a working undo as core, not as polish you bolt on once the agent is “ready.” They’re the features that make the agent rideable in the first place. An agent you can correct in one click is one you’ll actually use. An agent whose mistakes require a meeting and an apology will sit in a sandbox forever, no matter how smart it gets. The fastest path to handing over real work isn’t a smarter agent. It’s a cheaper undo.