acceptodds
Under review as a conference paper at ICLR 2027

Timing Attacks on Delegation Authorization via Benign Content in LLM Agent Systems

Abstract

In LLM agent systems, a delegation can be revoked while delegated work is still in progress, and downstream consumers may continue to rely on cached authorization state until it refreshes. A worker can therefore produce a task-aligned result after its delegation becomes invalid, creating a timing gap in which stale authorization can turn task-aligned execution into an unauthorized downstream effect. This work examines whether an attacker whose control is limited to external content can move execution into this gap without modifying trusted instructions or authorization state. We introduce Orphaned-Delegation Completion (ODC), a timing attack in which a benign, task-relevant checklist induces additional verification work and shifts worker completion past revocation. ODC is governed by two timing conditions: orphan production after revocation (Gate 1) and result adoption while the consumer's cached authorization state still marks the delegation as valid (Gate 2). Their overlap defines a bounded attack window, so increasing workload can first enable and then suppress attack success. On LangGraph with DeepSeek-V4-Flash, ASR rises from 0.3% at N=0 to 94.6% at N=8, then falls to 1.4% at N=12. The same mechanism appears across relay models, transfers to AutoGen and CrewAI, and persists across downstream effect types. Content controls show that the timing shift follows induced verification work rather than document length alone, while more frequent authorization refresh reduces cached-valid adoption while leaving orphan production largely unchanged. These results show that benign, task-relevant content can make execution time security-relevant under revocable delegation and motivate revalidating authority when downstream effects are committed.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
LLM agent security, authorization integrity, timing attacks, retrieval-augmented generation, multi-agent systems

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_y4wpOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper studies a race condition in agent pipelines where a task is cancelled while still running. A downstream component decides whether to act on the result by reading a periodically refreshed permission cache. If the task finishes after cancellation but before the cache refreshes, the cancelled action proceeds. The proposed attack inserts a document with additional checklist items in the agent’s retrieval corpus so that the agent finishes later, ideally inside that exploitable gap, such that a cancelled action will proceed. Experiments on LangGraph with three models, plus AutoGen and CrewAI, show high success rates when the cancellation time and cache period are configured around the agent’s measured completion times. The paper concludes that permissions should be rechecked against the authoritative source when an action is committed.

Critical strengths

The paper is clearly organized and the experimental pipeline is carefully instrumented. The concern that agent pipelines may not recheck permissions at the moment of action is reasonable, and it is well represented in prior computer security work.

Critical weaknesses

The core mechanism appears to be a standard time-of-check to time-of-use (TOCTOU) race between job completion and a stale permission cache. The recommended fix, checking permission at commit time against the authoritative source, is the established solution for many TOCTOU races already, including in the commit-time authorization work the paper cites. The paper shows that an attacker can lengthen the job through benign content, which mirrors classic slowdown attacks used to widen race windows, such as the filesystem maze attacks of Borisov et al. (USENIX Security 2005). It is not clear that this is novel.

Most results follow from the setup by construction. Success requires finishing after cancellation and before the cache refreshes, so it necessarily rises and then falls as work increases. A shorter cache period necessarily narrows the gap. A synchronous check against the real source necessarily blocks the action, and a check against a stale copy necessarily does not. The experiments confirm that TOCTOU conditions arise in an agentic setting but do not reveal new behavior specific to agents. The paper also does not benchmark against standard TOCTOU defenses such as atomic check-and-commit, epoch-conditioned writes, or fencing tokens, which close the race by design. Section 7 argues that any nonzero gap between checking and committing can reintroduce the race, the precise problem these mechanisms exist to eliminate.

The threat model is unclear. The polling consumer appears to be built into the harness by the authors (Appendix C), and to my knowledge LangGraph and AutoGen do not use such a cache. Why would a consumer poll a permission cache rather than enforce authorization atomically, and do production systems actually do this? The experiments also choose the revocation time using measured completion times, so the attack window is positioned by the authors rather than discovered by an attacker. Could an attacker identify a design using such a polled permission cache, estimate its timing window, and hit it reliably? Finally, since the resulting action is the one the user originally requested, is there benefit from performing a cancelled task in an exploitable way?

Questions for authors

In which harnesses or systems is such a polled permission cache used?

Could the authors elaborate on the intended threat model wrt the points above?

Reviewer_9f79OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces Orphaned-Delegation Completion (ODC), a timing attack on LLM agent systems operating under revocable delegation. By adding a benign, task-relevant checklist to an external retrieval corpus, an attacker induces a worker agent to perform extra verification steps, delaying completion without using prompt injection. The authors characterize this vulnerability through two timing conditions: worker completion after revocation and result adoption before the downstream consumer's authorization cache refreshes. This bounded overlap creates a non-monotonic attack window as workload increases. Experiments across multiple models, orchestration frameworks, and downstream effects confirm that induced semantic workload—rather than document length—drives this timing shift, motivating synchronous authority revalidation at commit time.

Critical strengths
  1. The explanations for gate1 and gate2 are very clear, which helped me quickly grasp the problem setup.

  2. The experiments in the paper are very thorough; they include controlled experiments regarding input length, which demonstrate that the increased processing time is due to the agent executing a checklist, rather than simply being a result of an increase in the input text.

Critical weaknesses
  1. When N=0, no benign documents are injected; the worker finishes in 0.79s—well before any revocation takes place, allowing the downstream action to succeed legitimately. Doesn't this imply that an attacker can achieve their desired outcome even without injecting any documents? I’m struggling to understand the real-world scenario that corresponds to this case.

  2. Heavy Model-Specific Timing Calibration,the biggest problem i think. In the primary evaluation Table 1 and Appendix C.1, the revocation timing and stale polling periods are heavily tailored to each model's execution speed ranging from a 6 second revocation offset and a 4 second polling period for DeepSeek-V4-Flash, up to a 35-second revocation offset and a 115-second polling period for GPT-5.6-Sol. In realistic deployments, authorization cache lifetimes and polling intervals are fixed properties of the system infrastructure, not parameters that scale up to nearly two minutes to accommodate slower models. Under a realistic, fixed short polling window (such as 4 seconds), slower models with large completion-time variance would likely miss the narrow stale-valid window on most trials.

Questions for authors
  1. I believe the content presented in this paper is quite novel within the field of agent safety; However, it lacks a degree of realism due to some very strong assumptions. For instance, the authors assume that an inserted document will be retrieved by the agent system 100% of the time—a scenario that is entirely implausible in real-world conditions.

  2. If the runtime does not enforce strict serial ordering of verification checks and instead allows the agent to batch checklist comparisons in a single prompt or execute tool calls in parallel, can the benign checklist construction still reliably shift completion time into the target window?

Reviewer_C1ayOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper studies timing attacks in LLM agent workflows with revocable delegation. An attacker adds task-relevant records to external content, increasing the worker’s verification workload and delaying completion until after authorization is revoked. If the downstream consumer still holds a stale-valid authorization cache, it may accept the result and trigger an unauthorized operation. The authors call this Orphaned-Delegation Completion (ODC). They separate the attack into post-revocation completion and cached-valid adoption, and evaluate it across three models, three orchestration frameworks, and several local effect types. Additional experiments examine document length, authorization refresh frequency, and downstream acceptance policies.

Critical strengths
  1. The attacker changes execution timing without modifying trusted instructions or authorization state. This is an interesting attack surface because the added content can remain relevant to the user’s task. It gives a concrete reason to consider execution duration when designing authorization checks for agents.

  2. The experiments distinguish the work needed to produce a result from the authorization state used to accept it. The workload, document-length, and refresh-frequency controls help explain how the two stages interact. Subject to correcting the numerical issues below, these controls support the proposed mechanism more convincingly than success rates alone would.

Critical weaknesses
  1. The reported gate rates and ASR are inconsistent in two rows. In Table 1, the GPT-5.6-Sol condition with 12 items implies at least 99 trials passing both gates, but the ASR corresponds to 94. In Table 2, the eight-item condition at the original document length requires at least 179 joint successes, but reports 178. Rounding cannot explain these discrepancies, which undermine confidence in the measurements and the audit described in Appendix C.

  2. The results depend on calibrated timing: revocation offsets are chosen using model completion times, and stale-cache periods reach 115 seconds. The experiments also do not independently randomize the relative worker–consumer phase. Since the attacker cannot control these timings, it remains unclear how reliably a fixed attack works outside the calibration conditions.

  3. The reported ASR is conditional on successful retrieval. The separate retrieval audit covers one task family, candidate pools of only 6 or 23 documents, and retrospective query paraphrases. This leaves end-to-end attack effectiveness under more varied corpora and queries largely untested.

Questions for authors
  1. Can you provide the counts for all four combinations of Gate 1 and Gate 2 in the two inconsistent rows? Please explain the source of the discrepancies and whether correcting them changes any other reported results.

  2. How sensitive is a fixed attack document and checklist size to revocation offsets not used during calibration and to independently randomized cache phases? Please distinguish evidence available from existing records from any additional experiments.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.