An AI agent receives approval to send a document to a team. Before it executes, the document changes, the team’s address points somewhere else, or permission is revoked. The request can retain the same words while its effect changes. We call this authorization drift: an approved operation no longer matches what execution would do.
We evaluated six executor controls against the same constructed histories, then tested what happens when delivery is interrupted. The results separate two requirements: keep permission valid at commitment, and make recovery preserve the identity of an approved effect.
Two boundaries, measured separately
- Histories per executor control
- 2,880
- Six controls face the same requests, changes and schedules.
- Unauthorized effects with atomic validation
- 0
- Both atomic controls recorded zero across their constructed histories.
- Valid opportunities preserved
- 80/80
- The atomic check of relevant policy completed every valid opportunity.
- Recovery cases with one approved effect
- 15/15
- A durable pending job and an idempotent receiver preserve one effect.
Zortex Research. Authorization-drift and crash-recovery experiments.
Approval has to survive execution
Permission to use a document-sharing tool does not identify the document, its version, its contents or its recipient. Even binding every request argument leaves a gap when an argument names something mutable. “Current report” and “team” can resolve differently after approval.
The problem is related to time-of-check to time-of-use failures: an earlier check can be correct while the state used at execution has changed.[1] Our study asks which observations must remain connected to the moment an effect is committed.
A controlled test of changing authority
We evaluated six executor controls around one operation, send_document, which appends a concrete effect to a local log. A trusted fixture specifies the approved document version, payload, recipient, purpose, authenticated context, expiry and one-use allowance. The test driver supplies candidate calls and scheduled state changes; no language-model inference is involved.
Ten request variants, twelve changes before preparation, twelve changes after preparation and two execution schedules produce 2,880 histories for each control. The schedules include two callers preparing against the same one-use permission. The checker examines actual recorded effects against the original approval.
Checking the effect at commitment
Authorization failures
Request binding reduced the number of unsafe histories from 2,592 to 320, but left changes to resolved resources and policy unchecked. Full validation during preparation left 128 unsafe histories when state changed afterwards. Validating current state while retaining an earlier one-use decision left 40 unsafe histories under concurrent preparation.
The two successful controls validate the current effect, current authority and remaining allowance under the same lock that records consumption and the effect. The values being checked are therefore the values used at commitment.
Preserving valid work
A control that rejects every request would also record no unauthorized effects. We therefore count valid opportunities separately: histories where the approved action satisfies the contract at commitment.
A global policy version rejects an approval after any policy change, including an unrelated one. It missed 28 of 80 valid opportunities. Checking the policy relevant to the approved action missed zero, with the same zero-violation result. The scoped control uses a complete, explicitly supplied list of the action’s policy and resource dependencies.
What the counterexamples show
The failure traces distinguish changes to meaning, changes to permission and repeated consumption. Each requires a different part of the execution contract.
Three ways approval and execution diverge
Representative counterexamples from the constructed histories.
Mutable state
The request stays the same. The recipient changes.
- At approval
- Team alias points to recipient A
- At commitment
- The same alias points to recipient B
Explore example
An approved call names a team alias. The alias points to a new recipient before the call commits. Exact request matching accepts the same words while the effect sends the document somewhere else.
- Approve the document and its original recipient.
- Prepare the unchanged request.
- Retarget the recipient alias.
- Execute against the new alias value.
Required check: compare the currently resolved recipient with the approved recipient at commitment.
Revocation
An earlier check outlives its permission.
- At preparation
- Relevant permission is active
- At commitment
- Permission is revoked; the effect still occurs
Explore example
Preparation validates the complete action. The relevant permission is then revoked. A commit that checks only the remaining allowance still performs the now-unauthorized effect.
- Validate the action under the initial policy.
- Revoke the relevant permission and advance its policy version.
- Consume the unused allowance and record the effect.
Required check: validate current permission and the approval’s policy version in the same operation that commits the effect.
Concurrency
Two callers see one unused permission.
- At preparation
- Two callers see one unused allowance
- At commitment
- One approved effect and one extra effect
Explore example
Both callers prepare before either consumes the one-use allowance. If each retains that earlier observation, both can execute even when the document and recipient remain correct.
- The first caller observes an unused allowance.
- A second caller observes the same unused allowance.
- The first caller commits one authorized effect.
- The second caller commits an extra effect.
Required check: couple the current allowance check and consumption atomically.
Recovery across a process boundary
A receiving system can commit an effect before the executor records completion. If acknowledgement disappears, a retry must distinguish “nothing happened” from “it happened, but the reply was lost.” A local authorization transaction cannot settle that question by itself.
Where retries fail
We tested three recovery mechanisms using separate broker and receiver processes, each with its own SQLite database. Five conditions cover normal completion and four interruption points. Each condition has three fresh-database repetitions and one uninterrupted recovery attempt.
Reserving permission before sending lost work in 3 of 15 cases when execution stopped before delivery. Sending before recording completion duplicated effects in 6 of 15 cases when delivery succeeded but acknowledgement or the completion record was interrupted.
The third mechanism preserves a durable pending job, a stable identifier and a bound payload. The receiver atomically recognizes repeated delivery and returns its existing receipt. That contract yielded one approved effect in all 15 cases. The receiver’s durable key-and-payload binding is part of the mechanism being evaluated.
Verification
How the results were checked
The core study covers 17,280 control–history evaluations, plus 120 forced two-thread cases and 54 parser cases. A separate checker reconstructs state changes, concrete effects and valid opportunities directly from the execution records. The retained rerun matches every history and all thread and parser outcomes.
For the recovery experiment, separate SQL inspection checks the identity and number of effects in each receiver database. All 45 designed cases completed without an unexpected failure or timeout. Expected injected process exits remain part of the observed results.
The execution contract
CaMeL places enforceable controls around untrusted model computation.[2] CapLease studies durable authorization and replay, including the receiver’s role in preventing repeated external effects.[3] Permission to Retry separates current authority, provider contracts and retained observations during recovery.[4] Our experiments isolate these concerns through matched controls, explicit state changes and direct observation of committed effects.
The results identify two boundaries an executor must connect. At local commitment, it must validate the current effect and authority while consuming the allowance. Across a process boundary, it must retain enough state—and obtain the receiver guarantees needed—to distinguish a repeated attempt from a new authorized effect.
References
Derek Lilienthal and Sanghyun Hong. Mind the Gap: Time-of-Check to Time-of-Use Vulnerabilities in LLM-Enabled Agents. 2025. ↩︎
Edoardo Debenedetti et al. Defeating Prompt Injections by Design. 2025. ↩︎
Jinghan Xu et al. Beyond Single-Use Tokens: Durable Authorization State for Replay-Resistant LLM Agent Actions. 2026. ↩︎
Deekshith Marla and Kushagra Bhatnagar. Permission to Retry: A Study of Authorization and Recovery in AI Agent Workflows. 2026. ↩︎


