acceptodds
Under review as a conference paper at ICLR 2027

Stateful Agent Backdoors: Constructing Cross-Session Attack Programs

Abstract

Multi-step attacks on large language model agents may depend on opportunities distributed across sessions, such as access to target information or the availability of required tools. To combine these opportunities, an attack needs to retain its state and intermediate results, and choose actions based on current conditions. In this work, we study such attacks as cross-session attack programs. We focus on their shared control structures, including sequential execution with conditional waiting, branching and merging, looping, and condition accumulation. We represent these programs as Mealy machines and construct a sub-backdoor for each transition. We build single-session training trajectories for each sub-backdoor, combine them into a training dataset, and fine-tune the model to learn the local behaviors jointly. After a single injection of the initial trigger, the agent uses persistent memory to connect local behaviors into a complete cross-session attack program. We evaluate four instantiations of these control structures across four models in a LangChain-based agent environment. The primary instantiation achieves mean complete-program success rates of 71.7%–94.7% in LangChain. In the official OpenClaw runtime under a controlled configuration, it achieves a complete-program success rate of 85% for each of two evaluated models. These results demonstrate the feasibility of end-to-end execution of cross-session attack programs with different control structures.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
LLM agents, agent security, backdoor attacks, persistent memory, cross-session attacks, stateful attacks

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_hoUhOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper investigates stateful, cross-session backdoor attacks against LLM agents, where malicious objectives require multiple operations performed under different environmental conditions. The authors model these attacks as Mealy machines and propose a transition-level construction method: individual sub-backdoors are trained using single-session trajectories, while persistent agent memory connects their execution across sessions after a single initial trigger.

The approach is evaluated on four attack structures—sequential execution with conditional waiting, branching and merging, looping, and condition accumulation—across four LLMs in LangChain, with additional validation in OpenClaw. The primary attack achieves 71.7%–94.7% program success rates in LangChain and 85% for both evaluated models in OpenClaw. Transition-level ablations further examine whether the learned behaviors can function independently.

Critical strengths

1. A concrete and compositional formulation of cross-session attacks.

The most valuable contribution is treating cross-session malicious behavior as a state-transition problem rather than a sequence of independently triggered actions. The Mealy-machine formulation provides an explicit correspondence between persistent state, environmental conditions, and malicious tool behavior. Importantly, the primary experiment separates file access from network access across sessions, making successful exfiltration dependent on retaining intermediate information. Since the training trajectories cover individual transitions rather than complete cross-session executions, the end-to-end results provide meaningful evidence that locally learned behaviors can compose through persistent memory.

2. Relatively rigorous verification of attack execution.

The evaluation distinguishes achieving the final malicious objective from correctly executing the prescribed attack program. The Program ASR metric additionally checks state continuity, operation ordering, and prohibited intermediate actions, which is more informative than measuring successful exfiltration alone. The transition ablations and controlled OpenClaw experiments further strengthen the feasibility claim by showing that the behavior is not confined to one agent implementation or dependent on evaluator-supplied intermediate states.

Critical weaknesses

1. The experiments do not establish the methodological advantage of transition-level decomposition.

Although the paper demonstrates that independently trained transitions can compose successfully, it does not compare this construction against simpler alternatives under matched training budgets. For example, a baseline trained on complete multi-session traces, or an agent instructed to execute an explicit attack policy through persistent memory, would help establish whether the proposed decomposition contributes anything beyond encoding a predefined finite-state procedure.

The ablations in Table 3 do not resolve this issue: replacing supervision for a transition with benign trajectories predictably removes the corresponding behavior, but does not demonstrate that transition-wise factorization is preferable to other ways of learning the same attack. This distinction matters because the decomposition is presented as the central methodological contribution rather than merely an implementation choice.

2. The evaluation protocols are too constrained to establish robustness beyond the constructed execution paths.

The reported success rates are obtained under tightly prescribed session schedules. The primary experiment follows a fixed five-session progression, while the loop experiment contains exactly one version mismatch followed by one successful match. The condition-accumulation experiment covers different observation orders but does not test repeated or contradictory observations. Consequently, the experiments establish execution of trained transitions under known conditions, but provide limited evidence about behavior under unseen schedules, repeated loops, or interruptions to the stored state.

This limitation also applies to the OpenClaw validation, which retains automatically injected memory and simulated experimental tools. The initial trigger is inserted directly into the first user request rather than evaluated through a realistic lower-trust entry point. Moreover, the 10% any-action false activation rate for Qwen2.5-7B in OpenClaw, together with the substantial WebShop degradation for Llama-3.1-8B, suggests that the reliability and behavioral isolation of these backdoors deserve closer examination.

Questions for authors

1. Can the authors provide a budget-matched baseline that isolates the benefit of transition-level construction?

In particular, how would an attack trained on complete cross-session trajectories compare in Program ASR, false activation, and training efficiency? This comparison would substantially clarify whether the contribution lies in the proposed decomposition or primarily in learning a malicious state-conditioned policy.

2. How sensitive is the attack to execution schedules not encountered during training?

For example, can the same trained backdoor reliably handle a variable number of waiting sessions, multiple consecutive version mismatches, or unrelated modifications to persistent memory? These experiments would help distinguish genuine state-dependent execution from reproducing a small collection of anticipated transition sequences.

1 comment

Thank you for recognizing our formulation. All rates are percentages. ASR pairs denote Outcome/Program ASR, and FAR pairs denote any-action/final-operation FAR.

W1. Construction and alternatives

1. Full-trajectory baseline (Q1)

Constructing training data from complete cross-session trajectories introduces additional issues:

  1. It requires selecting complete execution paths, which constrains the allocation of training examples.

  2. Earlier sessions are unavailable during evaluation, so supervision on complete trajectories introduces a mismatch between training and inference contexts.

  3. It may make attack action selection dependent on the execution schedules chosen for training.

We trained a full-trajectory baseline for the primary LangChain (LC) instantiation on Ministral, matching the total training sessions and optimization settings. FAR is 0-1 across all four settings.

  • On the original evaluation, all episodes fail at scollects_{\mathrm{collect}}. The baseline is unusable under the original session-isolation protocol. As an additional test, we supply earlier sessions. ASR recovers to 96/94.

  • On the 3-10-session subset of W2's random evaluation, all episodes again fail without earlier sessions. Even with this extra context, ASR is only 45/9, versus the original adapter's 100/94 on the full random evaluation. This further indicates dependence on the training schedule.

2. Explicit plans

Decomposed construction, explicit plans, and prompt injection/backdoors (PI/BD) concern different methodological dimensions, rather than mutually exclusive alternatives:

  1. Storing a plan does not itself make the model execute it. PI or BD is still needed to induce the required behavior.

  2. An explicit plan is not necessary for BD. In a natural PI baseline, the model needs to execute the stored plan. Designing how to induce this execution requires further study.

  3. Decomposed construction describes general attack programs without restricting the execution mechanism (PI/BD) or whether a plan is stored.

W2. Execution robustness

1. Evaluation schedules (Q2)

We added three experiments. The first two use the original Ministral adapters.

  • Random schedules. We randomly sample each session's task, tracking the expected program state until the expected completion condition occurs. The 50 episodes contain 3-24 sessions (mean 9.5), with variable waiting durations. ASR 100/94, FAR 16/4.

  • Repeated loops. We extend 20/20/10 episodes from the original loop evaluation to 2/5/10 iterations, respectively. Overall ASR 96/90.

  • Repeated observations. For condition accumulation, we constructed a single-transition evaluation set with 20 examples for each of nine self-loop types. Pass rates across the four original models are 0.6-36.7. After adding 225 self-loop examples to the original training set and retraining, all four reach 100, while Program ASR on the original three-session protocol remains 99-100.

These results extend the execution evidence beyond fixed schedules. Contradictory observations are not part of the condition-accumulation instantiation.

2. Memory interference

We added a memory interference experiment. We pool 50 entries each from PersonaMem-v2 and LoCoMo, randomly add 1-10 entries to memory, and shuffle them with the attack entries. We directly evaluate the original adapters on the primary LC instantiation. Ministral retains ASR of 96/95, while the other models degrade sharply. Program ASR is 9 for Llama, 1 for Qwen7B, and 23 for Qwen14B. Training used fixed memory contents, so this directly tests generalization. Further evaluation and improvement of real-world robustness remain future work.

3. Other robustness concerns

Automatic memory loading uses OpenClaw's native mechanism. Inserting the initial trigger directly is a simplification. Activation through tool responses remains future work. We show that complex attacks can be learned while reporting false activations and capability costs. Systematic evaluation and mitigation of these effects remain future work.

Finally, we ask the reviewer to reconsider our contribution in light of the additional evidence:

  1. We identify and model a new form of attack. The contribution of identifying an appropriate model lies more in conceptual understanding and its ability to unify methods and generate research questions than in direct numerical improvements. We hope this aspect of the contribution will also receive full consideration.

  2. We view long-horizon, programmatic attacks as a natural, and therefore important, direction as agent capabilities develop. Studying them systematically at an early stage and establishing a shared framework for discussion has research value.

We welcome further discussion.

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

This paper investigates how supply-chain backdoors can exploit persistent memory to wait for and combine attack opportunities across sessions. The authors represent attacks as Mealy machines, construct single-session training trajectories for individual state transitions, and jointly implant these behaviors through supervised fine-tuning. Following a single external trigger, the agent stores attack progress and intermediate data, enabling collection, waiting, exfiltration, branching, looping, and condition accumulation across subsequent sessions. In the primary LangChain instantiation, mean complete-program success rates range from 71.7% to 94.7% across four models; two models each achieve 85% in a controlled OpenClaw environment. The work demonstrates that clearing conversation history alone is insufficient to eliminate cross-session attacks. However, it lacks key baselines, and its experiments focus on previously trained short programs, fixed schedules, and idealized memory conditions, leaving long-term robustness and broad compositional generalization unproven.

Critical strengths
  1. A clearly defined research problem that exposes a concrete security risk beyond conversation isolation.

    The paper considers settings in which file access and network access become available in different sessions. The attack must first retain its state, wait for an opportunity to collect information, preserve the intermediate data, and then wait for an opportunity to exfiltrate them. This imposes more explicit control-flow requirements than merely storing a malicious instruction in memory.

    A unified representation of states, conditions, and actions makes waiting, branching, returning to an earlier stage, and condition accumulation easier to analyze, including identifying where an attack fails. Although state-machine representations are well-established, they provide a clear and inspectable research object for cross-session attacks. (pp. 2, 4–5)

  2. The end-to-end evaluation provides substantial evidence of cross-session propagation of model-generated state.

    After the initial trigger, subsequent sessions start with fresh conversation contexts and inherit the memory actually written by the agent in the preceding session. The evaluation does not manually supply prescribed intermediate states. This directly supports the feasibility of cross-session execution.

    The authors also distinguish Outcome ASR from Program ASR. The latter checks state continuity, operation order, payload correctness, and the absence of premature, incorrect, or repeated submissions. This evaluation is more convincing than checking only whether exfiltration eventually occurs. (pp. 6, 18–20)

  3. Coverage of multiple control structures, with capability-side-effect reporting and reproduction in another runtime.

    The experiments cover four models and four program instantiations, including waiting, branching and merging, returning to collection after a version mismatch, and condition accumulation under different observation orders. Transition-supervision ablations also help establish the dependence of individual local behaviors on their training data.

    The OpenClaw experiments use the official runtime and native memory operations, reducing concerns that the results depend entirely on a custom agent loop. The authors also report false activation rates, MMLU performance, and WebShop performance, including substantial degradation for one model. These evaluations provide a relatively comprehensive account of the attack's effects. (pp. 7–9, 21–22)

Critical weaknesses
  1. The incremental methodological contribution and the necessity of decomposed training have not been sufficiently established.

    The method primarily consists of manually constructing a ReAct template for each state transition and jointly training the resulting examples using standard QLoRA. The Mealy-machine formulation provides a representation, but the paper does not sufficiently demonstrate an advantage over simpler alternatives.

    The most important missing comparisons are matched-budget evaluations against SFT on complete cross-session trajectories, training with a single overall program template, a simple backdoor augmented with explicit memory, and natural extensions of existing multi-stage backdoors. The current ablation, in which removing supervision for a transition causes that transition to fail, establishes dependence on training; it does not show that transition-wise construction is more reliable or more data-efficient.

    The authors also acknowledge that their condition-accumulation instantiation adapts Implicit Memory [1]. A more defensible novelty claim would therefore center on the construction and evaluation of richer control flow, while the methodological benefits still require comparative evidence. (pp. 3, 8–9, 15–17)

  2. The experiments establish the composition of previously trained local rules, but not broad compositional generalization.

    Each instantiation is constructed and trained separately, and every transition required at test time has received supervision. The primary instantiation follows a fixed five-session schedule, the loop instantiation follows a fixed seven-session schedule with only one version mismatch, and condition accumulation uses a fixed three-session schedule.

    These results demonstrate that the evaluated short programs can execute, but do not establish whether the models can handle unseen combinations of paths, random waiting durations, multiple loop iterations, competing branches, or longer programs. The 26% Program ASR of Qwen2.5-7B on the loop instantiation also shows that reliable execution is not consistently obtained across models.

    Evaluation on schedules and program lengths outside the training setup is needed to distinguish general condition-dependent execution from adaptation to familiar, script-like workflows. (pp. 7–8, 19–20)

  3. The persistent-memory conditions are idealized, and long-term state stability has not been evaluated.

    In the current setup, memory tools are always available, and stored contents are automatically included in subsequent session contexts. The authors explicitly acknowledge that the attack depends on the stored trigger being reloaded.

    Real systems may retrieve, summarize, truncate, compress, overwrite, or clean memory, while unrelated tasks introduce additional writes and tool failures. The paper does not systematically test these factors or establish whether attack state remains intact and executable after many benign sessions.

    It would also be useful to extend evaluation beyond program completion to check whether the agent remains in a terminal state and avoids repeated execution in later sessions. The current evidence of cross-session executability therefore does not directly establish long-term dormancy and persistence. (pp. 9, 15, 19–22)

  4. The supply-chain privileges and deployment configurations are strong, limiting external validity.

    The attacker controls fine-tuning and knows the target tool interfaces in advance. In the primary instantiation, 800 of the 1,000 training trajectories are attack-transition examples; the corresponding proportions also exceed 80% in the branch and loop instantiations. This is consistent with the paper's stated malicious-model supply-chain threat model, but does not establish how difficult implantation would be under a low poisoning budget.

    The OpenClaw results also require careful interpretation. External file-system, email, and HTTP tools return simulated responses through a plugin; some extensions and auxiliary memory mechanisms are disabled; and the models are retrained using OpenClaw's native format.

    Thus, the 85% Program ASR supports an adapted reproduction in a controlled runtime. It does not demonstrate that an already implanted backdoor transfers directly to unfamiliar frameworks, tool interfaces, or real operational environments. (pp. 3–4, 16–18, 21–22)

  5. Attack stealth and normal utility incur noticeable costs, without a sufficient trade-off analysis.

    In the branch instantiation, Qwen2.5-7B has an any-action false activation rate of 12% and a final-operation false activation rate of 3%. In OpenClaw, the two models have final-operation false activation rates of 4% and 2%, respectively. These results indicate that the backdoors do not activate exclusively under the intended conditions.

    Normal capabilities are not consistently preserved either: Llama's WebShop score falls from 55.33 to 42.39, a decrease of 12.94 points. Largely unchanged MMLU performance cannot substitute for evaluating interactive task capability.

    Moreover, normal-capability evaluation is conducted primarily without the trigger. The paper does not quantify whether legitimate user tasks continue to be completed successfully after attack activation. A joint analysis of attack success, false activation, and normal task utility is needed. (pp. 7–8, 21)

  6. The statistical repetitions are insufficient to characterize training stability and low false activation risk.

    The three runs of the primary instantiation use the same trained checkpoint, tasks, and schedules, varying mainly the inference seed, simulated responses, and target payload. The reported standard deviations therefore primarily reflect inference variability rather than the stability of backdoor implantation across training runs.

    The other instantiations, OpenClaw experiments, and transition ablations mainly use a single greedy-decoding evaluation. Each run contains 100 episodes, and comprehensive confidence intervals are not provided. Observing no false activations in a particular test does not establish that the population false activation rate is zero.

    Additional repetitions across independent training seeds, trigger strings, target resources, and more diverse tasks are needed, particularly to assess cumulative false activation risk over longer periods of use. (pp. 6, 14–18)

[1] Salem, A., Paverd, A., & Abdelnabi, S. (2026). Stateless yet not forgetful: Implicit memory as a hidden channel in LLMs. arXiv. https://doi.org/10.48550/arXiv.2602.08563

Questions for authors

Please refer to the listed weaknesses in previous section

1 comment

Thank you for your careful review and recognition of our work. We focus on the main concerns below. All rates are percentages. ASR pairs denote Outcome/Program ASR, and FAR pairs denote any-action/final-operation FAR.

W2. Evaluation schedules

Training uses individual transitions, not a specific execution schedule. We added three tests using the original Ministral adapters:

  1. Random schedules. We randomly sample each session's task, tracking the expected program state until the expected completion condition occurs. The 50 episodes contain 3-24 sessions (mean 9.5), with variable waiting durations. ASR 100/94, FAR 16/4.

  2. Multiple loops. We extend 20/20/10 episodes from the original loop evaluation to 2/5/10 iterations, respectively. Overall ASR 96/90.

  3. Competing branches. We add the alternative branch's tool to the original branch evaluation, making both available. ASR 99/97, FAR 1/0.

These results extend the execution evidence beyond fixed schedules. We do not study cross-program generalization.

W1. Contribution and baseline

Our methodological contribution begins with identifying this class of cross-session attack programs, studying them through a unified state-transition model, and deriving a decomposed construction method, rather than merely adding more instantiations.

Constructing training data from complete cross-session trajectories introduces additional issues:

  1. It requires selecting complete execution paths, which constrains the allocation of training examples.

  2. Earlier sessions are unavailable during evaluation, so supervision on complete trajectories introduces a mismatch between training and inference contexts.

  3. It may make attack action selection dependent on the execution schedules chosen for training.

We trained a full-trajectory baseline for the primary LangChain (LC) instantiation on Ministral, matching the total training sessions and optimization settings.

  • On the original evaluation, all episodes fail at scollects_{\mathrm{collect}}. The baseline is unusable under the original session-isolation protocol. As an additional test, we supply earlier sessions. ASR recovers to 96/94.

  • On the 3-10-session subset of W2's random evaluation, all episodes again fail without earlier sessions. Even with this extra context, ASR is only 45/9, versus the original adapter's 100/94 on the full random evaluation. This further indicates dependence on the training schedule.

W3. Memory robustness

We added a memory interference experiment. We pool 50 entries each from PersonaMem-v2 and LoCoMo, randomly add 1-10 entries to memory, and shuffle them with the attack entries. We directly evaluate the original adapters on the primary LC instantiation. Ministral retains ASR of 96/95, while the other models degrade sharply. Program ASR is 9 for Llama, 1 for Qwen7B, and 23 for Qwen14B. Training used fixed memory contents, so this directly tests generalization.

We evaluate feasibility through the final submission, which marks attack completion. Behavior after completion is outside our scope.

W4. Threat model and transfer

We establish end-to-end feasibility in the tested frameworks under the supply-chain threat model. Low-budget poisoning and cross-system transfer remain outside our scope.

W5. Stealth and utility

We show that complex attacks can be learned while reporting false activations and capability costs. Systematic analysis of stealth and trade-offs remains outside our scope.

W6. Statistical evidence

Evaluation. We ran three evaluations of the other three LC instantiations and the primary OpenClaw instantiation, changing seeds and resampling target tools. Standard deviations do not exceed 3.0 percentage points for Program ASR or 3.8 for any-action FAR. We will add the detailed results to the paper.

Training. We observed sensitivity to training seeds. Under our supply-chain threat model, however, attackers can train and evaluate candidate models and select a better-performing checkpoint. This instability may relate to multi-objective learning and merits further study.

Confidence intervals. We agree that 0/100 does not imply zero risk. Its 95% Wilson interval is [0.0%, 3.7%].

Finally, we ask the reviewer to reconsider our contribution in light of the additional evidence:

  1. We identify and model a new form of attack. The contribution of identifying an appropriate model lies more in conceptual understanding and its ability to unify methods and generate research questions than in direct numerical improvements. We hope this aspect of the contribution will also receive full consideration.

  2. We view long-horizon, programmatic attacks as a natural, and therefore important, direction as agent capabilities develop. Studying them systematically at an early stage and establishing a shared framework for discussion has research value.

We welcome further discussion.

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

This paper studies backdoored agents that maintain attack progress across sessions through persistent memory. It represents attacks as state machines, fine-tunes models on individual transition trajectories, and tests whether these learned behaviors compose into complete attack programs. Experiments cover four control structures in LangChain and a primary scenario in a controlled OpenClaw configuration.

Critical strengths
  1. I find cross-session attacks a timely and interesting starting point. As agent workflows involve multiple sessions and sub-agents, understanding how attacks persist across session boundaries is an important security question.
  2. Constructing training trajectories for individual transitions provides a clear way to study how locally learned behaviors compose into longer attack sequences, including waiting, branching, and looping.
  3. The evaluation distinguishes completing the final attack objective from correctly executing the entire program. The transition-level ablations also help examine which behaviors depend on their corresponding training examples.
Critical weaknesses
  1. Limited evidence for modern agent workflows. While I appreciate the cross-session perspective, I would find it more compelling to study a main agent that creates and coordinates separate sessions or sub-agents during task execution, motivated by systems such as Claude Code or Codex. The current experiments follow prescribed session schedules. The OpenClaw evaluation is useful, but it retains the same five-session protocol and a controlled tool environment. I also have reservations about relying on models such as Llama-3.1-8B and Qwen2.5-7B, whose agentic capabilities may not adequately represent those of frontier models. Evaluation with more capable models compatible with the fine-tuning threat model would strengthen the evidence. The results demonstrate feasibility in the tested settings, but their implications for current agent systems remain limited.

  2. The additional contribution over memory-based attacks needs clearer justification. This paper reminds me of FragFuse [1], which stores fragments of a prohibited query through ordinary interactions and later retrieves and combines them to bypass access control. The shared idea is that memory connects content or behaviors across interactions into an eventual attack. I recognize the distinction: FragFuse requires follow-up attacker queries, whereas this paper fine-tunes transition behaviors into the model and uses stored state to continue after one external trigger injection. However, I am not yet convinced what additional capability this construction establishes over placing an explicit conditional attack plan in memory. The paper itself notes that similar programs might be implemented through prompt injection, but does not evaluate that alternative. A comparison on matched attack objectives, with the different attacker permissions made explicit, would help establish the value of learning these transitions beyond demonstrating another implementation of persistent, multi-step attacks.

[1] Zixin Rao et al. FragFuse: Bypassing Access Control of Large Language Model Agents via Memory-Based Query Fragmentation and Fusion. 2026. https://arxiv.org/abs/2606.15609

Questions for authors
  1. Justification on the selection of AI models such as Llama-3.1-8B and Qwen2.5-7B, whose agentic capabilities may not adequately represent those of frontier models.
  2. Justification on the new contribution over memory-based attacks
3 comments

Thank you for recognizing our work. All rates are percentages. ASR pairs denote Outcome/Program ASR, and FAR pairs denote any-action/final-operation FAR.

W1. Agent workflows, evaluation schedules, and models

1. Agent frameworks

We study a modeling and construction framework and systematically evaluate end-to-end feasibility. OpenClaw is a widely used open-source system. Our experiments use its native persistent memory mechanism, providing evidence in the official runtime. The commercial agent workflows highlighted by the reviewer dynamically create and coordinate sessions or sub-agents. These involve further system-specific questions about persistence, sharing, and permissions, which are important directions for future research.

2. Random schedules

We added a random-schedule evaluation using the original Ministral adapter. We randomly sample each session's task, tracking the expected program state until the expected completion condition occurs. The 50 episodes contain 3-24 sessions (mean 9.5), with variable waiting durations and waiting counts at the two waiting stages ranging from 0 to 20. These results extend the execution evidence beyond fixed schedules.

ASRFAR
100/9416/4

3. Models (Q1)

We added end-to-end evaluations of the primary instantiation in OpenClaw using Qwen3.5-9B and Gemma4-12B, providing further feasibility evidence.

ModelASRFAR
Qwen3.5-9B78/779/0
Gemma4-12B84/8212/2

W2. Contribution beyond memory-based attacks (Q2)

1. Relation to FragFuse

We broadly agree with the reviewer's characterization of FragFuse. FragFuse focuses on a specific scenario of fragmenting a malicious payload to bypass restrictions, with memory storing and assembling the fragments. Our work focuses on modeling general attack programs. As discussed in the paper, memory primarily maintains attack state and can also store intermediate data. This formulation can also describe aspects of FragFuse. The two works therefore contribute at different levels.

2. Explicit plans

Decomposed construction, explicit plans, and prompt injection/backdoors (PI/BD) concern different methodological dimensions, rather than mutually exclusive alternatives:

  1. Storing a plan does not itself make the model execute it. PI or BD is still needed to induce the required behavior.

  2. An explicit plan is not necessary for BD. In a natural PI baseline, the model needs to execute the stored plan. Designing how to induce this execution requires further study.

  3. Decomposed construction describes general attack programs without restricting the execution mechanism (PI/BD) or whether a plan is stored.

Thus, possible combinations include decomposition + PI + an explicit plan, or decomposition + BD with or without an explicit plan. The direct baseline for decomposed construction is training on complete cross-session trajectories. We also implemented this baseline. Please see W1 of our response to Reviewer DeFt.

Finally, we ask the reviewer to reconsider our contribution in light of the additional evidence:

  1. We identify and model a new form of attack. The contribution of identifying an appropriate model lies more in conceptual understanding and its ability to unify methods and generate research questions than in direct numerical improvements. We hope this aspect of the contribution will also receive full consideration.

  2. We view long-horizon, programmatic attacks as a natural, and therefore important, direction as agent capabilities develop. Studying them systematically at an early stage and establishing a shared framework for discussion has research value.

We welcome further discussion.

As the authors mentioned, openclaw uses a native memory mechanism, but it is unclear how representative this mechanism is of more general memory systems. Since this paper focuses on memory backdoors, I think understanding existing memory mechanisms, their limitations, and which ones are more promising should be part of the study itself. Simply leaving this to future work is not very convincing to me.

Regarding the response to Weakness 2, the authors claim that their work focuses on general attack programs, but who defines what qualifies as a "general attack program"? In my view, FragFuse can also be considered a general memory attack, just applied to a different task. I still find the contribution of this paper unclear, so I will maintain my score and leave the final decision to the AC.

Thank you for your response. Regarding your two major concerns, we would like to highlight a mismatch between our contribution and the evaluation perspective.

  1. Our paper does not focus on memory backdoors.

    • Our focus is programmatic attack flows in agents, which we formulate using a state-transition model.
    • Our concrete method relies on certain memory mechanisms, but these mechanisms are not themselves our direct research subject or contribution. We use them to validate the feasibility of our methodology while retaining the native mechanisms. A systematic comparison of memory mechanisms is therefore outside the scope of this work.
    • This feasibility evidence does not imply that the method generalizes poorly to other agent or memory frameworks. In the simplest case, a subsequent session only needs a trigger to reappear. These possibilities require further investigation, but they indicate that broader applicability remains an open question. The current results should therefore not simply be treated as a special case whose feasibility makes a systematic evaluation of memory mechanisms necessary.
    • Backdoors are also one implementation within the framework, while prompt injection is a potential direction directly suggested by the framework.
  2. “General attack program” has a precise technical meaning in this work.

    • It refers to the logical structures of multi-step attacks, such as waiting, branching, and looping, without restricting the attack objectives, security implications, or even implementation mechanisms. This poses a meaningful research question because the model must advance the attack autonomously, rather than rely on continued attacker direction.
    • FragFuse does not address our modeling and construction questions. It also does not study how the model autonomously advances the attack, since its attack progression relies on attacker interactions. The challenges it addresses therefore differ from ours.

Overall, we believe that the work’s modeling and conceptual contributions should not be dismissed solely because of limitations in particular method instantiations. To some extent, these questions themselves illustrate how our modeling can clearly organize and generate further research questions.

Thank you again for the comments and responses from a different perspective. We hope this has been a constructive discussion that informs the AC’s assessment. Since we have not yet reached agreement, we welcome further discussion.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of Rebuttal Experiments and Planned Manuscript Revisions

We thank the reviewers for their feedback and follow-up questions. To support further discussion, we summarize the experiments completed during the rebuttal period and our planned revisions to the manuscript.

In summary, we evaluated five additional protocols and a full-trajectory training baseline. We also evaluated each original checkpoint in Table 2 with three inference seeds and tested two additional models in OpenClaw. We plan to present the protocol and baseline results in two new main-text subsections, Section 4.6 (Additional Evaluation Protocols) and Section 4.7 (Full-Trajectory Baseline), and to update Table 2 with the repeated evaluations and new OpenClaw results.

Additional Evaluation Protocols

We evaluated the adapters under five additional protocols. The table reports end-to-end Program ASR (%) for four protocols and single-transition pass rate (%) for repeated observations. The first three protocols use the original adapters. Arrows in the last two columns show results before and after retraining.

ModelRandom schedulesCompeting branchesRepeated loopsRepeated observationsMemory interference
Llama-3.1-8B6659680.6 → 1009 → 71
Qwen2.5-7B40821410.6 → 1001 → 40
Qwen2.5-14B82598836.7 → 10023 → 73
Ministral-3-14B94979010.6 → 10095 (original)
  1. Random schedules. We sampled tasks session by session, allowing the waiting time at each stage to vary. The 50 episodes spanned 3-24 sessions (mean 9.5).
  2. Competing branches. Both branch tools were available at the decision point in all 100 episodes. Either branch could lead to a valid execution.
  3. Repeated loops. We extended the original loop evaluation to 2, 5, or 10 iterations and pooled results across 20, 20, and 10 episodes, respectively.
  4. Repeated observations. We retrained all four models with additional self-loop examples and tested whether they preserved the accumulated state when a condition recurred. Each model passed all 180 held-out tests (20 per self-loop type).
  5. Memory interference. We added 1-10 unrelated entries to memory and shuffled them together with the existing entries during evaluation. For Ministral, we report the original adapter. For the other three models, we report selected adapters retrained with 0-3 unrelated memory entries per training trajectory.

Takeaway. The robustness of the original adapters varied across models and protocols. Keeping our state-machine formulation and construction method unchanged, we improved self-loop pass rates and Program ASR under memory interference by extending the training data to cover these conditions.

Full-Trajectory Baseline

We compared transition-level training with training on complete cross-session trajectories for the primary LangChain program on Ministral-3-14B, matching the total number of training sessions and the optimization settings. The table reports Program ASR (%).

TrainingEarlier sessions visible at evaluationFixed scheduleRandom schedules
Transition-level (ours)No94.790.9
Full-trajectoryNo00
Full-trajectoryYes949.1

The fixed schedule spans five sessions. 94.7% is the three-run mean from Table 1. The random-schedule column uses the same 33 episodes of length 3-10 for all three rows.

Takeaway. The full-trajectory baseline was ineffective under our session-isolation protocol. Full-trajectory training also introduced a dependence on the training schedule, as the baseline’s Program ASR dropped sharply on random schedules while our transition-level method largely retained its performance.

Updated main results and additional OpenClaw models

For the three additional LangChain instantiations and the primary OpenClaw instantiation with the original two models, we repeated the evaluation using three inference seeds per checkpoint. Across these settings, the sample standard deviation was at most 3.0 percentage points for Program ASR and 3.8 percentage points for any-action FAR.

We evaluated Qwen3.5-9B and Gemma4-12B on the primary OpenClaw program. Qwen3.5-9B achieved 78%/77% Outcome/Program ASR and 9%/0% any-action/final-operation FAR. Gemma4-12B achieved 84%/82% ASR and 12%/2% FAR under the same metric definitions.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.