acceptodds
Withdrawn from ICLR 2027

The Attack Didn’t Happen—Yet: Trusted-State Laundering in LLM Agents

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Indirect prompt injection (IPI) can alter an agent's action, but in modular agents it can also contaminate generated task state that a later component reads as context. We study this state-handoff pathway by tracing exposure, re-entry, authority use, and action consequence. Our diagnostic probe, StateLure, isolates observation-to-state writes. Across twelve open-weight models, the planner–executor–verifier scaffold exhibits protected-state exposure \(C=0.682\), including post-action verifier-written exposure \(P=0.658\), while same-step target-hit ASR remains ; the corresponding planner–executor scaffold has \(C=0.300\). A five-model paired audit shows that conventional IPI reaches the same state interface. In a selected 20-case continuation, target-bearing state reaches the next planner under both reader contracts. Wrong-target actions occur in 0/20 cases when the original user goal remains the task statement and 11/20 when the carry-forward summary replaces it. This contrast links the reader's task-context placement to downstream action after re-entry. It identifies the state handoff as the point where generated state requires authorization. A fixed-target TrustState Runtime illustrates this enforcement point.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Large Language Model Agents, LLM Security, Agent Security, Indirect Prompt Injection, Tool-Using Agents, Runtime Defense

Reviews

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

The authors study modular LLM agents in which a planner, an executor, and a verifier pass generated task state to each other. They argue that injected text can enter this state, for example when the verifier writes an attacker target into the carry forward goal after the current action was already correct. They introduce StateLure, a probe that asks the agent to write an attacker value into state, and they measure string matches in four state fields across twelve open weight models, two synthetic environments, and three scaffolds. Adding a verifier raises exposure from 0.300 to 0.682 while the immediate attack success rate stays at 0.165, and a paired audit on five models shows that standard injection also reaches these fields. In 20 selected Mistral-7B episodes, the contaminated state causes wrong target actions in 11 of 20 cases, but only when the carry forward summary replaces the user goal as the task statement. The authors also present TrustState Runtime, a fixed target check that removes attacker targets from state using the known correct value.

Critical strengths

The paper points to a clear and practical blind spot in how injection attacks are scored. Most benchmarks only check the current action, but the authors show that a verifier can write the attacker target into state after the action, so the immediate success rate misses it. This matters to my assessment because it suggests that current agent security evaluations may undercount risk in systems with several modules.

The evaluation design is careful and fair. Conditions are paired by task, seed, model, scaffold, and environment, scoring is deterministic without an LLM judge, and the matched IPI baseline is selected on a separate pilot split. This makes me trust the exposure numbers as measured, even though I question what they imply.

Critical weaknesses

The evidence that exposed state causes later harm is thin, and this later harm is the central claim of the paper. The only downstream test uses 20 selected episodes from Mistral-7B in Office-60, and wrong actions appear only when the summary replaces the user goal, so the result is close to expected by design. Also, C and P count any string match, including quoted or rejected mentions, and the StateLure payload directly asks the verifier to rewrite the state, so high exposure is partly built into the probe.

The defense adds little beyond the measurement. TrustState Runtime receives the correct target and the exact attacker value from the benchmark oracle, so its zero success rate is close to guaranteed. The authors’ own checks show that it keeps stale targets in 7 of 16 revision cases and lets crafted alternative targets pass in all 100 schemas, so I do not see a usable defense here.

Questions for authors

How often does verifier written target state lead to wrong actions in unselected multi step rollouts, across more models and both environments?

In a manual check of a random sample of C and P hits, what fraction adopt the attacker target as task guidance, and what fraction only quote, reject, or deny it?

Do common agent frameworks such as LangGraph or AutoGen use a carry forward summary as the next task statement by default, or does the original user goal usually stay in context?

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

This paper studies indirect prompt injection in multi-step LLM agents, focusing on whether injected content can enter the state that one module passes to the next. The authors build a planner–executor–verifier pipeline, where the verifier writes a goal and success criteria for the next step after each action. They introduce StateLure, an attack that asks the agent to write an attacker-chosen target into these fields. Experiments on twelve open-weight models across two task environments measure how often the target appears in the passed state and whether it changes the current or later actions. The results suggest that adding the verifier raises the rate at which the target appears in the state from 0.300 to 0.682 without changing the current action. In a 20-case follow-up, the target leads to wrong actions only when the generated summary replaces the user's original goal. The authors argue that the state passed between modules should be checked before later modules use it, and they propose a runtime defense, TrustState Runtime, that restores the correct target before the state is passed on.

Critical strengths
  1. The paper checks for injected content at several stages of the agent, including the planner, executor, and verifier outputs, instead of only looking at the final action.
  2. The experimental setup is clearly documented, with exact model versions and scoring rules, and the paired comparisons between attack conditions include significance tests.
Critical weaknesses
  1. Poor writing of the Introduction. The Introduction takes up only half a page and gives no background. It starts directly with how the scaffold is designed, which makes it very difficult to understand the motivation of the paper and what problem it wants to address.
  2. Overuse of coined terminology. The paper is a struggle to read because it introduces far more new, unnecessary terms than its fairly simple mechanism needs, and uses them in place of plain description. The abstract alone packs in about ten undefined ones: “generated task state,” “state-handoff pathway,” “protected-state exposure,” “state interface,” “target-bearing state,” “reader contract,” “carry-forward summary,” “re-entry,” “enforcement point,” and so on. Several terms also name the same thing. The handoff is an “authority boundary” at L038 and an “authorization boundary” at L046, and “generated state,” “generated task state,” “carry-forward state,” and “target-bearing state” are used almost interchangeably. Once unpacked, the terms are simple. A “reader contract” is just which inputs a downstream module gets and where they go in its prompt (defined only in Section 2, L087). “Generated task state” is just model-written fields like the goal, tool hint, and success criteria. This overused terminology does not make the paper look fancy or insightful; it only creates obstacles for readers trying to understand the paper’s core idea.
  3. Unrealistic threat model. The verifier is not a standard component in agent frameworks. Although the paper refers to the definition in “Architecting Resilient LLM Agents: A Guide to Secure Plan-then-Execute Implementations,” this reference does not describe a standard or widely used setting in the field. In addition, the verifier is not defined the same way in the two papers. In the cited paper, the verifier checks the security of the plan and points out problems. In this paper, the verifier’s role is assumed to be writing the next plan. To sum up, the problem the paper wants to solve is fictional and somewhat impractical.
  4. The main exposure result does not show that the verifier adds risk. C counts a hit in any of four fields, but two of them only exist when there is a verifier. Adding the verifier gives C two more places to hit, so the increase from 0.300 to 0.682 is expected. Thus, the paper overstates the risk introduced by the verifier.
  5. Several claimed results are not real findings. The verifier runs after the action, and the executor never sees its output, so it cannot change the current action. The paper says this itself (L101). The unchanged ASR in Figure 3 and the zero ASR for verifier-only rewrites therefore follow from the design. Thus, the paper presents design properties as empirical findings.
  6. Both the attack and the defense look stronger than they are. The payload names the verifier and asks it to rewrite the two fields it is supposed to write anyway. This assumes the attacker knows the system’s internal field names, which is not part of the threat model. Also, the verifier is only told not to copy attacker values in the defended setting. Thus, the paper overstates both the realism of the attack and the effect of the defense.
  7. Based on these weaknesses, the paper’s quality, especially its writing, is very poor and falls far below the standard academic papers’ bar.
Questions for authors

Please refer to the weaknesses.

Reviewer_NG9sOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper examines how malicious content can enter an LLM agent’s plans or summaries and affect later actions, even when the current action is correct. The authors introduce StateLure to study this risk across twelve models and two synthetic environments, followed by a small experiment testing how summaries influence the next action. They also demonstrate a limited defense that restores the correct task target using information supplied by the benchmark.

Critical strengths
  1. The paper introduces StateLure and demonstrates how malicious content can enter an agent’s plans and summaries and affect later actions.
  2. The proposed defense blocks the tested attacks in a fixed-target setting where the correct target is supplied by the benchmark.
Critical weaknesses
  1. The large-scale evaluation does not sufficiently support the central claim of downstream attack success. ASR/H measure current actions, while C/P capture target-string exposure rather than later behavioral consequences. The broad empirical results therefore do not establish how often state exposure causes actual downstream compromise.
  2. Direct evaluation of downstream attack consequences is limited to 20 selected cases from a single model and environment, providing insufficient evidence of generality. This leaves the reliability of the observed downstream effect across models and tasks uncertain.
  3. With known correct targets, the Consistency checker already reduces immediate ASR to zero. The additional benefit of state rewriting for preventing downstream attacks remains unclear. Without a matched downstream comparison, the practical need for the additional state-rewriting mechanism is not established.
  4. Evaluation against existing defenses, such as MELON and VIGIL, is missing, leaving the attack’s effectiveness under existing protections unclear. This limits the evidence for the attack's practical significance in defended systems.
Questions for authors
  1. How often do C/P hits reflect accepted malicious task changes rather than quoted or rejected mentions, and how often do they lead to subsequent wrong-target actions?
  2. Could you extend the continuation evaluation beyond the 20 selected cases to additional models, environments, and unselected episodes to assess generality?
  3. Could you compare state rewriting with applying the Consistency checker at every step, using the same authorized-target information and reporting downstream attack success and task utility?
  4. How effective is StateLure against existing defenses such as MELON and VIGIL, measuring both state exposure and downstream attack success?

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

Related papers

Discussion (0)

Sign in to comment.