# Undo is a design decision: classify every agent action before it runs

> Commvault now sells recovery for what AI agents change. A backup restores data, not a sent message. Here is how to design undo into each agent action.

- Type: Technical
- Published: 2026-11-16
- Author: Sentynel
- URL: https://sentynel.ai/sygnals/undo-is-a-design-decision/
- Language: en

On 10 November 2026 Commvault announced AgentRecover capabilities "designed to help organizations audit agent activity, restore agents, and recover the data and systems they affected," starting with Microsoft Foundry and Amazon Bedrock AgentCore. Recovery tooling for agents is a sign that agents now write to real systems. **But recovery works on what you store. A message a customer already read, a payment already settled or a file already shared with a supplier cannot be restored from anywhere, so whether an action can be undone has to be decided before the agent is allowed to take it.**

## Recovery restores state. Operations run on commitments.

Commvault's own announcement describes the problem well: "an unintended or unwanted action can create vast changes across multiple connected systems." Its CTO and AI officer, Pranay Ahlawat, adds that "a single agent decision can trigger changes across data, applications, and infrastructure on multiple platforms."

Some of those changes are rows in a database. Those can be put back. Others are promises made to someone outside the company: a delivery date confirmed to a customer, a discount offered on WhatsApp, a purchase order sent to a supplier. Putting the CRM field back to yesterday's value does not withdraw the promise. The customer still has the message on their phone.

So recovery tooling and operations design answer two different questions. Recovery asks "how do we get our systems back?" Design asks "which actions should an agent be allowed to take in the first place, and what do we do when one was wrong?" The second question has to be answered per action, by the people who own the work.

## Three classes of action

Every write an agent can make falls into one of three classes. The class, not the agent's accuracy, decides how much freedom it gets.

1. **Reversible.** The change stays inside your systems and the previous value can be put back with nothing else happening. Moving a case to another stage, tagging a record, saving a draft, updating an internal note.
2. **Compensable.** The change cannot be erased, but a new action can cancel its effect. A charge is compensated by a refund, a wrong confirmation by a correction message, an order by a cancellation. Compensation is never free: it has a cost, a delay, and usually a person who has to approve it.
3. **Final.** Nothing cancels it. Personal data sent to the wrong recipient, a statement made to a regulator, a payment that has left for a third party, goods already dispatched. These can only be prevented.

**What undo means, by class**

Restore (Reversible: put back the previous value from the journal) → Prevent (Final: only a gate before the action protects you)

_Compensable actions sit in between: a new action, with its own owner, cancels the effect of the first._

## Write the action register

Before an agent goes live, list every action it can take, one row each. Six columns are enough:

| Column | Question |
| --- | --- |
| Action | One verb and one object: "send order confirmation", "update delivery date" |
| System | Where the change lands: CRM, ERP, WhatsApp, email, bank |
| Class | Reversible, compensable or final |
| Undo path | The exact step that reverses or compensates it, or "none" |
| Owner | The person who may run that undo path |
| Window | How long the undo stays possible: until the customer reads it, until the batch closes, until the truck leaves |

The register usually surprises people. Actions they thought of as harmless turn out to be final ("send the quote" is final once the customer has it), and actions they feared turn out to be easy to reverse. **The register, not a general sense of risk, is what tells you where an agent can act alone.**

## Five rules that make undo possible

- **Final actions get a gate.** A person approves, or a hard limit in code blocks anything outside a fixed range: amount, recipient list, data fields. Never rely on an instruction in the prompt for this.
- **Every write records its before-value and its case.** The journal stores what the field was, what it became, which agent version wrote it and which case it belongs to. Without the case ID, undoing one bad decision means rolling back everything that happened since, including the work your team did by hand.
- **Compensations are written procedures.** The refund, the correction message, the cancellation: each one is a step with an owner and a template, written before launch. In an incident nobody should be inventing the apology.
- **Turn final into reversible where you can.** Outbound messages can wait in a short hold queue before they are sent. Payments can be staged for a batch that a person releases. A delay of a few minutes moves an action from "final" to "reversible" at almost no cost to the customer.
- **Rehearse the undo.** Take one day of agent activity in a test environment and reverse it case by case from the journal. If you cannot, the journal is missing something, and you have found that out before production did.

**Before an agent writes**

1. Classify the action — Reversible, compensable or final
2. Record before-value — Field, case ID, agent version
3. Gate if final — Approval or a hard limit in code
4. Execute — Through scoped tools only
5. Write the journal — What changed, for which case

## Where recovery tooling fits

None of this replaces recovery tooling. An agent can still corrupt a table, overwrite a configuration or act through an identity it should not have, and you will want the full picture of what it touched and a way to bring those systems back. Commvault positions AgentRecover alongside its "identity recovery and change auditing to help understand what agents did, the data they changed, and the identities they acted through."

The point is the order. Recovery covers the reversible class at scale and helps you find what happened. The action register and the gates cover the other two classes, which no backup reaches. Companies that buy the first without designing the second will restore their databases and still owe their customers an explanation.

## Why the case record matters

Undo by case only works when every piece of work has a record with a stage. In Sentynel's Rodo case, WhatsApp, social and web enquiries were brought into a service operation with a measurable resolution path, and the record reports 82% of live-created enquiries resolved. That number exists because each enquiry is a pipeline record, not a loose conversation. The same structure is what lets you answer "what did the agent do on this case, and how do we reverse it?" (Source: Rodo operational report, 24 September 2026; the resolution cohort covers 31 August–24 September; figures describe pipeline records, not all conversations.)

## A first step for this week

Pick the agent that writes most to your systems and list its actions in the register. Mark each one reversible, compensable or final. Then ask one question of every final action: who approves it today, and where is that approval recorded? If the answer is "the agent decides", that is the first gate to build, before any recovery tool is bought.

## Sources

- https://www.commvault.com/news/ai-agent-recovery-plan
