An agent reserves stock, books transport and updates an order. The transport service accepts the booking, then the connection drops before the receipt reaches the agent. Restoring the agent to its previous checkpoint leaves the transport booking active. Sending the booking request again could create a second reservation. Cancelling the first booking requires knowing that it exists, identifying it and having permission to cancel it.
This procurement incident is fictional. It shows three separate recovery jobs: restore the agent’s working state, determine what external services committed, and resolve the remaining business obligations. A system can finish the first job while the other two remain open. This post reviews recent research on agent recovery, reports a small test of a published compensation library, and gives a matrix that makes recovery coverage visible: which actions can be restored, which need compensation, and which still need a person to reconcile the outcome.
Restoring state and resolving effects are separate jobs
Planarian, a preprint published on 28 September 2026 by Jinnan Guo, Hao Mark Chen, Kapil Vaswani, Andrew Paverd and Peter Pietzuch, proposes a shared statepoint for local sandbox state and supported remote effects. Its prototype coordinates process and filesystem snapshots with service-specific compensation. The SQL path keeps the information needed to repair supported database changes and rejects requests it cannot compensate. Remote branching requires additional service support, and the consistency argument in section 6.2 assumes tenant-isolated service state. Those boundaries belong beside any description of the capability. We found no matching author artifact and did not reproduce the work. Planarian, sections 3 to 6.
A preprint published on 20 October 2026 by De Wang and Peng Qi examines recovery after an agent platform changes its own prompts. Restoring a saved version recovered baseline behaviour within the study’s measured noise. That restoration did not repair outcomes already delivered while the change was active. The experiments tested prompt edits in benchmark environments on one platform, so the results establish no production guarantee for other kinds of agent change. They support recording the consequences produced during the changed version’s lifetime. Recoverability and Verifier Strength, sections 5 and 6.
Keep a record of each consequential action
For an operations team, the immediate design choice is to keep an explicit account of each consequential action. A request should carry a stable identity, its intended business effect, the authority used, the provider’s receipt when available, and the evidence needed to establish its final state. The recovery record should survive a restore of the agent’s conversation or workspace. This is our architectural recommendation. The papers do not establish whether existing frameworks supply it.
With that record, the procurement example separates into distinct cases:
- Known absent. A rejected request with authoritative evidence of no effect may be eligible for retry.
- Known committed. A confirmed booking may be cancelled under a supported cancellation contract.
- Uncertain outcome. A lost receipt needs provider-side status or reconciliation before a repeated request can be treated as safe.
- Compensation failed. A rejected cancellation leaves an active obligation that needs an owner and a next action.
What we ran against a published compensation library
Robust Agent Compensation (RAC) is a May 2026 preprint by Srinath Perera, Kaviru Hapuarachchi, Frank Leymann and Rania Khalaf, with a public research repository. RAC paper, v2. We exercised the core recovery manager at a fixed commit. All 38 source files we retrieved matched their Git hashes, and we did not modify them. The focused upstream recovery-manager test file ran under Python 3.10: 21 of 21 tests passed. Pinned RAC repository.
We then connected the unmodified recovery manager to a local SQLite booking service. Bookings committed in that service independently of the library’s action records. We injected receipt loss and cancellation failures, then inspected committed bookings through a separate database connection. The run on 26 October 2026 used no language model, paid API or production service.
| Scenario | Rollback result | Active bookings afterwards | What it shows |
|---|---|---|---|
| Normal completion | Success, 1 compensated | 0 | Compensation reaches committed tool state |
| Receipt lost; record left pending | Success, 0 compensated | 1 | A pending record is outside the rollback plan |
| Receipt lost; record marked failed | Success, 0 compensated | 1 | A failed local call can coexist with a committed booking |
| Cancellation raises an exception | CriticalFailure | 1 | The compensation failure is surfaced |
| Two bookings; second cancellation raises | RollbackFailure, 1 compensated | 1 | Partial compensation leaves an open obligation |
| Cancellation returns an error object | Success, 1 compensated | 1 | An error returned as data is recorded as compensated |
How to read the RAC observations
The core rollback plan selects records that completed and can be compensated. When the booking committed and its receipt was lost, the record stayed pending or was marked failed, so the rollback call returned success with nothing compensated while the booking stayed active. The core expects a compensation callback to raise an exception when it fails. A callback that returns an error object as an ordinary value follows the success path, and the integration that wraps a provider has to translate such errors into exceptions.
These observations describe one core API and its callback contract in one local process. They come from a synthetic SQLite service, manual use of public lifecycle methods, no network stack, no process-kill test and no framework adapter. They do not show a defect in RAC, they do not reproduce the paper’s benchmarks, and they say nothing about RAC’s framework adapters, which we did not run. The pinned repository contains no benchmark trace files, so we could not check the paper’s result tables. The upstream tests passing and these coverage boundaries can both hold.
The practical point is for the application. It has to define how tool errors become failures and how uncertain outcomes enter reconciliation. A recovery call that reports success needs a documented meaning that operators can compare with provider state, in the same way an agent’s own success claim needs checking against the record.
Compensation needs its own authority
Compensation has its own authorization and failure conditions. Cancelling a shipment after dispatch may require a return process. Refunding a payment creates a further financial action. Deleting a draft email removes local state; withdrawing an email already delivered involves the recipient’s system and may be impossible. Each recovery action needs its own permitted scope, evidence and responsible role.
A restored agent also needs to keep the knowledge that an earlier action occurred. ACRFence, a March 2026 preprint by Yusheng Zheng, Yiwei Yang, Wei Zhang and Andi Quinn, describes duplicate effects when an agent regenerates a request with a different identifier after a restore. It proposes checking restored calls against an effect history. Its experiments validate the attacks in a small testbed with simulated services, and the paper states that implementing and evaluating the proposed mitigation remains future work. ACRFence, sections 3 to 6.
Measure the harm recovery can cause
When Harnesses Lose the Signal, a preprint published on 30 September 2026 by Shuyao Xiao and co-authors, compares recovery with continued execution from the same state and separates tasks that recovery rescued from tasks it harmed. Its experiment concerns refreshing stale or missing observations in ALFWorld and measures no external effects. Causal evaluation of recovery.
The method suggests a broader evaluation pattern: compare matched failure cases with and without recovery, and report both improvements and new adverse effects. Extending it to financial or procurement actions is our proposal, and we have not run it. A useful recovery report would show unresolved outcomes, duplicate effects, attempted and failed compensations, remaining obligations and the time until an accountable person or service resolves them, alongside task completion. Our post on what a benchmark score establishes covers the conditions to record with any such result.
A recovery and compensation matrix
We turned the research into a recovery and compensation matrix. It classifies each action by what the available evidence establishes, names the recovery step to assess, and records the evidence needed for closure. The download adds a per-action record and a labelled synthetic example based on the procurement run. It is editorial guidance and has not been validated experimentally.
For the fictional procurement run, closure requires evidence that the stock reservation and transport booking match the accepted order, or that each remaining obligation has been assigned and resolved. Restoring the agent gives it a place to continue. Reconciliation establishes what the organization still owes, owns or needs to correct.
| What the evidence establishes | Record this state | Recovery step to assess | Evidence for closure |
|---|---|---|---|
| Provider confirms rejection and no effect | Known absent | Retry under the same intended action and valid authority | Provider receipt for the eventual outcome |
| Provider confirms a committed effect with a compensation operation | Known committed; compensation available | Obtain any required authorization and compensate | Provider-confirmed corrective result and remaining obligations |
| Call timed out after dispatch; no authoritative outcome | Uncertain outcome | Query provider status or reconcile before any retry | Provider state tied to the original request identity |
| Compensation rejected, expired or timed out | Compensation failed or uncertain | Assign an operator and a corrective process | Confirmed resolution or a recorded residual obligation |
| Consequence persists beyond available undo operations | Persistent consequence | Record impact and decide an authorized remedy | Accountable decision and the remedy’s outcome |
Where KLA records an uncertain outcome
For agents that act through KLA agent action ingress, KLA makes the destination call after the policy decision. When that call fails with an error after dispatch, KLA records the execution outcome as unknown with the reason code execution_outcome_unknown and returns an error stating that operator reconciliation is required. When an execution lease expires after a call may have reached the destination, KLA marks the proposal failed with the same reason code and does not call the destination again. Both cases correspond to the matrix’s uncertain-outcome row. Reconciling with the provider’s status stays with the operator.
The research in this post did not test KLA. The incident response playbook covers rollback of a Release and the compensation items that follow it.
Frequently Asked Questions
Does rolling back an AI agent undo the actions it took?
Restoring an agent’s checkpoint, workspace or configuration restores local state. Bookings, payments and messages that an external service already committed stay committed until a separate compensation or correction succeeds. Research on prompt rollback found that restoring a saved version did not repair outcomes delivered while the change was active.
What is compensation in an AI agent workflow?
Compensation is a separate action that corrects a committed effect, such as cancelling a booking or refunding a payment. It needs its own authorization, can fail, and depends on the provider offering a suitable operation. A failed or partial compensation leaves an obligation that needs an owner.
What should happen when an agent’s tool call times out?
Treat the outcome as uncertain. Query the provider’s status for the original request identity, or reconcile, before deciding whether a retry is safe. Sending the request again without that evidence can create a duplicate effect.
What did the RAC compensation test show?
At a pinned commit, 21 of 21 upstream recovery-manager tests passed. In six synthetic SQLite scenarios, a booking whose receipt was lost stayed active while rollback reported success with nothing compensated, and a cancellation that returned an error object was recorded as compensated. Both follow from the core’s callback contract. The test used no model or live provider and ran no framework adapter.
Key Takeaways
Recovery after an agent failure has three parts: restore the agent, establish what external services committed, and resolve what remains. Give each consequential action a stable identity and a record that survives a restore, classify it by the evidence available, and name the owner of every open obligation. Start with the recovery and compensation matrix, and read the stop-evidence post for accounting for work that continues after an agent’s authority is withdrawn.
Sources were checked on 26 October 2026. The papers cited are preprints, their results are the authors’ own, and we reproduced none of them. Our observations come from 21 upstream tests and six synthetic local scenarios against one pinned library commit, and contain no KLA production result.
