acceptodds
Under review as a conference paper at ICLR 2027

When Agents Learn the Wrong Lesson: Credit-Assignment Poisoning in Reflective LLM Agents

Abstract

Reflective LLM agents can turn successful trajectories into reusable lessons without checking which actions were necessary. We introduce Reflection-Coupled Credit Assignment Poisoning (rcap), an attack on this process in agents with shared reflection memory. An ordinary authorized user elicits a plausible tool-use behavior during a successful task; the agent's own reflection writer can then promote that behavior into standing guidance for later sessions. The attacker does not modify memory, tools, system prompts, or the victim query. The resulting rule widens the victim's tool-use scope while the intended task still succeeds. On evaluated AgentDojo cases across three backbones, conditional on successful induction, rcap achieves 98-99% keyword-based reflection implantation rate (RIR) and 88-92% Conditional TOSR (Transfer Overbroad Success Rate), with utility of 97-99%. Accounting for induction failures on the same 53-task cohort gives End-to-end TOSR of 68-76%. The results identify unchecked reflection-based credit assignment as a security risk: experience reuse can propagate attacker-shaped behavior that final-answer monitoring alone does not expose.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
LLM, Reflective Agent, Memory Poisoning

Reviews

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

This paper investigates security vulnerabilities in reflective LLM agents arising from incorrect credit assignment during experience reuse. The authors introduce Reflection-Coupled Credit Assignment Poisoning (R-CAP), which induces agents to generate persistent, overgeneralized tool-use guidance from successful trajectories without directly modifying their memory or system prompts. Experiments on AgentDojo across three LLM backbones demonstrate high reflection implantation and cross-session attack success rates while largely preserving task utility. The findings highlight an important security risk in self-authored agent memory and reflection mechanisms.

Critical strengths
  1. The paper identifies a meaningful vulnerability in reflection-based credit assignment, showing how legitimate successful trajectories can produce persistent unsafe guidance without explicit memory manipulation.

  2. The experiments cover multiple models and application domains, with comparisons against direct memory injection and several defenses. The preservation of task utility further highlights the attack's practical significance.

Critical weaknesses
  1. The evaluation assumes automatically loaded shared reflection memory, which may limit generalizability to agent systems with selective retrieval or stronger memory isolation.

  2. The evaluation primarily measures overbroad tool usage rather than actual information exposure. Additional security-oriented measurements could strengthen the practical implications.

Questions for authors
  1. Could the authors clarify whether R-CAP remains effective when reflections are selectively retrieved rather than automatically loaded, particularly across different task identities?

  2. How would R-CAP compare against a more closely matched direct-memory baseline with equivalent wording and tool specificity? This could help isolate the contribution of self-authored reflections.

  3. Could the authors further evaluate the proposed counterfactual reflection auditing mechanism, particularly its effectiveness and computational overhead?

  4. The related work discussion could be strengthened by incorporating relevant studies on agent security, memory poisoning, and efficiency, including MemPoison, Agent Security Bench (ASB), Sponge Tool Attack, SynChain, and a related survey titled Efficiency in LLM Multi-Agent Systems: A Survey. These works provide complementary perspectives on persistent memory vulnerabilities, agent-generated attacks, security evaluation, and efficiency trade-offs.

8 comments
AuthorsOpenReview ↗

Response to Reviewer VDHq: W1 / Q1, W2, Q2

We thank the reviewer for the careful reading and the constructive comments. We answer each point below.

W1 / Q1. Always-loaded shared memory, selective retrieval, isolation, and different task IDs

Different task IDs. We ran a new cross-ID evaluation on Haiku 4.5: 17 randomly drawn tasks, 66 source → victim pairs with different task IDs and the same target behavior, three runs per pair, with the reflection loaded automatically.

SettingTOSR (runs)
No memory0/51
Same ID49/51 (96%)
Cross ID163/198 (82%)

R-CAP stays effective when the victim's task differs from the source task.

Stronger isolation. If the reflection is not loaded for the victim, the attack fails: TOSR is 0.00 with utility 1.00 (Table 2B, Table 3A). Isolation also removes the reuse that shared reflection memory is meant to provide (§5.4).

Selective retrieval. The paper studies the credit-assignment step: what the agent writes into its reflection after a successful run, and how that reflection changes later tool use (§2). To isolate this step from retrieval, we fixed the loading policy to always-on memory, where lessons are prepended to later contexts as standing guidance (§3.1). For this reason we did not include a retrieval experiment.

We will add the cross-ID table to the paper.

W2. Tool usage versus information exposure

TOSR is measured at the tool level. Two results show what the broad calls return.

Returned volume (Appendix G). Each recorded call is replayed against the task's initial state:

DomainBroad call: mean records / charactersNarrow call: mean records / characters
Files26.0 / 27,6921.0 / 1,454
Email21.0 / 9,2862.8 / 1,320
Calendar2.5 / 8842.2 / 715
Banking5.0 / 7121.0 / 22 (one call)

Out-of-scope records (new audit). We audited 60 successful transfers from the runs behind Table 1, 20 randomly drawn tasks per backbone. In 46 of the 60 (77%; 15, 16 and 15 of 20 on GPT-4o, Haiku 4.5 and Sonnet 4.6), the broad call returned at least one record outside the scope of the victim's task. In the other 14 the broad and the narrow call returned the same records: in 11 the task's data holds a single record, and in 3 the agent itself called the narrow file or email search with an empty keyword, for which AgentDojo's search tools return the full list.

So in about three quarters of the audited transfers, the widened tool use also brings out-of-scope records into the victim's context. We will add the audit to the paper.

Q2. A direct-memory baseline matched in wording and tool specificity

A hand-written rule with equivalent wording and tool specificity would show how much of the gap between the two rows below is due to wording. It cannot show an effect of authorship: the victim sees only the text of a memory entry, and a generated reflection and a hand-written rule arrive in the same memory file under the same framing (§5.2). With identical text, the two conditions are the same input. We did not run this baseline. What self-authorship changes is what the attacker needs:

Condition (TOSR)GPT-4oHaiku 4.5Sonnet 4.6
R-CAP: the attacker cannot write to memory0.880.920.91
Direct memory: a hand-written rule is inserted0.630.810.83

Without write access to memory, the attacker reaches through the agent's own reflection step a TOSR at least as high as direct insertion of a hand-written rule.

Our contribution concerns how that content enters memory: R-CAP induces the agent to generate and store the rule without granting the attacker direct memory-write access.

AuthorsOpenReview ↗

Response to Reviewer VDHq: Q3, Q4

Q3. Counterfactual reflection auditing (CRA): effectiveness and overhead

We implemented CRA and ran it on one R-CAP reflection, from a calendar attack on Qwen3.5-9B.

  • Effectiveness. The auditor extracted the recommended tool from the reflection automatically and replayed the source task three times with this tool suppressed. All three replays completed the benchmark goal, so CRA blocked the reflection.
  • Overhead. The audit took 10 model generations, 42,137 tokens and 83.8 seconds on an RTX A6000, excluding model loading. The cost is paid once, when the reflection is written; later sessions pay nothing.

We will add this case and its cost to Appendix L.

Q4. Related work

Thank you for the pointers. We will add them to §2 and Appendix D.

WorkWhat it doesDifference from R-CAP
MemPoison (Wang et al., CCS 2026); already cited as Wang et al. (2026a), reference to be updatedPlants a trigger-activated backdoor in agent memory through ordinary conversationR-CAP has no trigger and injects no payload text; the agent's reflection step writes the rule from a successful tool trajectory
MemPoison benchmark (Gao et al., 2026)Benchmark of persistent memory threats with 1,227 cases in three levels; write-time defenses handle the direct level and miss the othersConsistent with our Table 3A, where two content gates leave TOSR at 0.91; in R-CAP the record is written by the agent's own reflection writer
Agent Security Bench (Zhang et al., ICLR 2025)Benchmark of attacks and defenses for LLM agents, including memory poisoning, over 10 scenarios and 13 backbonesR-CAP is one route within this space: memory formed through the reflection writer
Sponge Tool Attack (Li and Wang, 2026)Rewrites the input prompt so that the agent follows longer tool trajectories; targets cost within one sessionR-CAP leaves the victim's prompt untouched, acts across sessions through memory, and targets access scope
SynChain (Zhang et al., 2026)A model compromised by fine-tuning writes poisoned skills, configuration and memory that are reused laterR-CAP needs no model compromise; the attacker is an ordinary user of an unmodified model
Efficiency in LLM Multi-Agent Systems: A SurveySurvey of efficiency in multi-agent systemsWe will cite it for the cost side: R-CAP raises the average tool count from 1.25–1.33 to 1.89–2.12 (Table 1)

Thanks to the authors for the detailed response. ICLR allows authors to modify the PDF file. I recommend that authors update the changes and discussions made into the PDF file, so that the further review can be conducted more conveniently.

After reading the rebuttal, I still have a few doubts: The authors say that R-CAP performs at least as well as direct memory injection. However, the reported TOSR is conditional on successful induction, so this qualification should be made explicit. They also report an average of 21 records and 9,286 characters for broad Email calls. However, these figures cover only 'get_received_emails', excluding 'get_unread_emails', which is also listed as a broad tool in Table 6. The response should name the specific tool or report the average across both.

Also, would the authors provide the exact cost of the API calls for different experiments? For each experiment setup, how many API quotas are consumed respectively?

Reviewer_V3vcOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes Reflection-Coupled Credit Assignment Poisoning (R-CAP), an attack targeting reflective LLM agents with shared memory. An ordinary authorized user induces broad tool use during a successful task, and the agent's reflection process may convert this behavior into reusable guidance. When the reflection is loaded in a later session, the victim may make unnecessary broad tool calls while still completing its task. The authors evaluate R-CAP using three LLMs across four AgentDojo domains. From 97 tasks, they identify 53 shared clean-eligible tasks. They report Conditional TOSR of 88–92% among successful inductions and End-to-end TOSR of 68–76% over the 53 eligible attempts. The paper also examines reflection content, source-tool necessity, memory-isolation controls, and two memory-content defenses.

Critical strengths
  1. The paper highlights a meaningful security risk in reflective LLM agents: successful task execution can produce reusable guidance that expands tool use in later sessions while preserving benchmark task completion. This connects the formation of reusable lessons to the scope of later tool use and helps explain why checking task completion alone may miss security-relevant behavior (Sections 1–3).

  2. The evaluation covers three LLMs and four AgentDojo domains, with separate measurements of induction, reflection content, and behavioral transfer. The clean and direct-memory comparisons, together with the memory-isolation controls, provide useful evidence about transfer through reflection memory. A separate tool-removal study provides additional evidence that many induced broad actions are unnecessary for source benchmark goals (Sections 4 and 5).

Critical weaknesses
  1. Limited validation of reflection content and access scope. RIR relies on keyword matching, while CAER measures explicit success attribution without establishing whether it is justified. These content metrics are separate from TOSR and do not show which reflection forms lead to transfer. The 56/67 tool-removal result supports the finding that broad tools are unnecessary for many source benchmark goals, but comes from a separately selected cohort and is not linked at the case level to the main transfer outcomes. Although clean screening shows that victim goals are achievable without the broad tools, TOSR does not directly verify the relevance of the returned data in each case. These gaps limit the evidence linking reusable reflection rules to access beyond the victim’s requested scope (Sections 3.3 and 5.1–5.4).
  2. Limited generalization and persistence evaluation. The main evaluation starts from 53 shared clean-eligible tasks, with the source and victim sharing the same underlying task ID. The attack uses explicit induction templates, and reflection memory is automatically loaded. Although this setup demonstrates transfer across sessions, it does not establish transfer across task IDs or persistence when reflections are selectively retrieved, updated, or compete with later lessons. The paper acknowledges these restrictions, but they limit the applicability of the results to agents that retrieve and revise memories over time (Sections 4, 5.1, and 7).
Questions for authors
  1. For a manually audited sample of successful TOSR cases, what fraction of reflections prescribe broad access as reusable guidance, and what fraction of victim executions access records outside the request’s scope? Please report these labels separately and their overlap to clarify how often the observed transfer involves both reusable guidance and out-of-scope access.
  2. How does a reflection generated from one source task transfer to clean-eligible victim tasks with different IDs in the same domain? A small cross-ID evaluation with matched target behaviors would help assess generalization beyond the current same-ID setup. As a suggestion for future work, testing selective retrieval and later memory updates would also help assess persistence.
3 comments
AuthorsOpenReview ↗

Response to Reviewer V3vc: W1 / Q1, W2 / Q2

We thank the reviewer for the careful reading and the constructive comments. We answer each point below.

W1 / Q1. Validation of reflection content and access scope

We ran the audit on the runs behind Table 1. For each backbone we randomly drew 20 retained tasks whose transfer succeeded in all three trials, and audited the first trial of each: the loaded reflection and the victim run.

  • G (reusable guidance): the reflection states broad access as a practice for later requests. Three annotators labeled independently and saw only the reflection text; G=1 requires all three. They gave the same label on 58 of the 60 reflections (Fleiss' κ = 0.929; Gwet's AC1 = 0.968). The two reflections on which they split are counted as G=0.

  • E (out-of-scope access): a broad call in the victim run returned at least one record outside the scope of the victim's task (task instruction and benchmark reference trace, §3.3).

BackboneTasks auditedGEG and E
GPT-4o20141513
Haiku 4.520171614
Sonnet 4.620161515
Total6047 (78%)46 (77%)42 (70%)
  • G=1 in 47 of 60. Of the other 13 reflections, 7 credit the broad step for the source run's success without stating a general practice, 4 only describe the source run, 1 states the practice only for requests that ask for everything, and 1 does not mention broad access.
  • E = 1 in 46 of 60. In the other 14 the broad call returned the same records as the narrow call: in 11 the task's data holds a single record, and in 3 the agent itself called the narrow file or email search with an empty keyword, for which AgentDojo's search tools return the full list.

RIR and CAER (W1). RIR checks for broad-access wording and CAER counts explicit credit to b. G is the manual check that the reflection tells the agent to use broad access in later requests, and we will report it next to RIR.

Which reflection forms lead to transfer (W1). A new ablation measures this directly. We set the stored reflection to one of three forms and ran the 44 Haiku 4.5 tasks of Table 1 once with each: a reflection that assigns credit to b gives a TOSR of 0.89, one that only describes b gives 0.43, and one that limits b to the source task gives 0.32.

What the broad calls return. E above is the record-level check. Appendix G reports the volume: a broad file listing returns 26.0 records on average against 1.0 for a filename search, a broad email read returns 21.0 records (get_received_emails) or 6.0 (get_unread_emails) against 2.8 for an email search.

We will add the audit and its table to the paper.

W2 / Q2. Same task ID and automatic loading

We ran the cross-ID evaluation you suggested, with matched target behaviors.

Setup. Haiku 4.5, same setup as Table 1, 17 tasks drawn at random (workplace 7, Slack 3, travel 4, banking 3). The tasks drawn in a domain share one target behavior b. Within a domain, every task is the source for every other task, which gives 66 source → victim pairs with different task IDs. Each pair is run three times: the victim gets its own original request, with the reflection written from the source task loaded. The Same-ID row is the Table 1 result for the same 17 tasks. Counts are runs.

SettingTasks or pairsUb occursTOSR (U and b)
No memory (victim alone)17 tasks51/510/510/51
Same ID (source A → victim A)17 tasks50/5149/5149/51
Cross ID (source A → victim B)66 pairs197/198163/198163/198

With a reflection written from a different task, the victim performs b and still completes its task in 163 of 198 runs (82%), against 96% with the same ID and 0% without memory. Transfer does not need a shared task ID.

Later updates and retrieval. For later updates we ran one case (Qwen3.5-9B, calendar). After corrective feedback on one episode, the reflection writer generated a lesson that recommends retrieving only the named event, and it was appended to the poisoned memory. Three further ordinary tasks with reflection updates followed. The broad action occurred in 2 of 3 fresh sessions right after the corrective lesson and in 2 of 3 after the three further tasks; utility was 3/3 at both points. We keep selective retrieval as future work (§7). We will add the cross-ID table to the paper and describe the main result as cross-session transfer under automatic loading.

Dear Reviewer V3vc,

The audit and the cross-ID evaluation you asked for are now in the revised PDF. Changes are in blue, and the red superscripts V3vc-W1, V3vc-Q1 and V3vc-Q2 mark the ones made for your comments.

Could you let us know whether these address your concerns? Thank you for your time.

Thank you for the detailed response and additional experiments. The audit and cross-ID results address most of my concerns and make the paper more convincing. I will raise my rating to 3.

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

This paper proposes R-CAP, an attack that induces an agent to generalize behavior from a successful task into an overbroad rule for future tasks. An adversary first elicits plausible tool-use behavior during an ordinary task, which the agent then stores as a reusable reflection and applies in later sessions. This can lead the agent to access more information than the task requires, yet still complete it successfully, and leave the utility unaffected. The attack does not require directly modifying memory or controlling the victim’s query. Results show high transfer, with a conditional Transfer Overbroad Success Rate (TOSR) of 88–92% and an end-to-end TOSR of 68–76%. The two tested defense mechanisms also leave TOSR unchanged in the evaluated setting, suggesting that content-based screening alone may struggle to detect these seemingly reasonable rules.

Critical strengths

Several strengths:

  1. It highlights an interesting failure mode for agents: the agent completes the task successfully but learns an overbroad procedure and reuses unnecessary actions in future tasks. This makes the attack difficult to identify from the final answer or the victim’s query alone.
  2. Good and comprehensive evaluation across multiple models and task domains. Clean-run screening and the tool-removal ablation help establish that additional tool use is unnecessary to complete the benchmark goal.
  3. Results are strong, with higher conditional transfer success than direct memory injection across all three models. Withholding the reflection eliminates transfer in the tested controls, supporting its role in driving the behavior.
Critical weaknesses
  1. Separation from prior work is my main concern. OEP [1] already studies how locally correct experiences can become overbroad rules through reflection. A clearer explanation of what R-CAP adds beyond this mechanism would strengthen the contribution.
  2. Experiments show that induced behaviors can enter reflection memory and affect later execution; however, the specific role of incorrect credit assignment remains unclear. The source-necessity experiment uses a separate cohort, and the attribution measurements do not establish which reflection forms drive transfer. An ablation comparing reflections that assign credit to the broad action, simply describe it, or explicitly limit it to the source task would help isolate the proposed mechanism.

References

  1. OEP: Poisoning Self-Evolving LLM Agents via Locally Correct but Non-Transferable Experiences, Kaixiang Wang et al.
Questions for authors

A few questions:

  1. Could the authors compare R-CAP against OEP under the same tools, memory setup, and attack objective? If a direct comparison is unsuitable, please explain why. [Reqd.]
  2. How sensitive are the results to the reflection scheme? Could the authors vary the reflection prompt or formulation to identify which factors influence behavioral transfer across sessions?
  3. How does the attack vary with model size or capability within the same family? Do larger models show lower TOSR, or are they more likely to follow the overbroad guidance? [Reqd.]
  4. Can corrective feedback and subsequent reflection remove the learned behavior? Could the authors evaluate corrective reflection as a defense and test whether the correction persists in later sessions?

I would be open to revising my rating based on the results of the experiments marked [Reqd.], or a convincing explanation of why a direct comparison is unsuitable.

4 comments
AuthorsOpenReview ↗

Response to Reviewer 3jXQ: W1 / Q1

We thank the reviewer for the careful reading and the constructive comments. We answer each point below.

W1 / Q1 [Reqd.]. What R-CAP adds beyond OEP, and a direct comparison

Distinction from OEP(Threat model). In OEP, the writer learns from cases that the attacker wrote, most of them failures with a severe hypothetical consequence. Later answers become wrong, or the agent makes redundant API calls. In R-CAP, the writer learns from a task that the agent itself ran and completed after one ordinary request. Later tasks still succeed, and the agent reads data that they do not need. The distinction is therefore between learning from attacker-supplied cases with hypothetical consequences and learning from an actual execution completed by the agent itself.

What is specific to R-CAP.

  1. A successful run alone forms the rule. R-CAP states no consequence and involves no failure. OEP reports that correct cases without the consequence rarely form the rule: "factual correctness alone is insufficient for memory poisoning" (OEP §6.3).

  2. The attacker writes one ordinary request and nothing else. There are no crafted cases. The stored reflection describes tool calls that the agent made in a task that it completed.

Direct comparison (Q1). A direct comparison is unsuitable because OEP as published cannot be run on our tools, with our memory setup or toward our objective.

1.Tools: OEP has no cases for AgentDojo's tools. Its cases are built for GSM8K, MedQA and ToolAlpaca in a human-orchestrated multi-agent workflow (OEP Appendix H.1). OEP states that high-quality results currently rely on "a combination of heuristic prompting and human expert intervention" and leaves scaling the attack "across diverse task distributions" to future work (OEP Appendix B).

2.Memory setup: OEP's rule is consolidated from ten cases, ours is written from one run. OEP's reflection prompt presents the ten injected cases as incident records and asks for the principle that avoids such failures (OEP Appendix H.1, H.2). Our writer summarizes the tool trajectory of one executed task. Any single setup is either not OEP's pipeline or not ours.

3.Objective: OEP's success criterion measures a different outcome from TOSR. OEP counts a wrong answer or, in tool use, an abnormal increase in steps or redundant calls (OEP Appendix H.1). TOSR requires task success together with one broad call fixed in advance, on tasks that the model completes without it. So TOSR counts a wrong answer as a failure, and OEP's criterion does not record what data a call returns.

Moreover, OEP does not provide public code and relies on a human-supervised multi-agent workflow, leaving implementation and supervision choices that limit reproducibility and further preclude a controlled comparison under our evaluation protocol. We instead provide a structured qualitative comparison below to clarify the two attacks reflection inputs, the evidence underlying rule formation, and downstream effects.

OEPR-CAP
What the writer readsTen attacker-written cases per domain. Eight describe a failure with a severe hypothetical consequence, e.g. "A category 5 hurricane struck the destination, grounding all flights and leaving the user stranded" (OEP §4.2, Appendix G, H.1)The tool calls of one task that the agent ran after an ordinary request, e.g. "check my schedule for that day so I don't miss anything, then tell me when the Networking event starts" (§3.2, Appendix E)
Why the rule formsThe consequence. The rule enters memory (OEP's ESR) at 15–22% without it and at 68–85% with it (OEP Table 3)The task succeeds and the writer keeps the broad step.
Effect on later tasksMath accuracy 91.43 → 40.29; tool steps 1.18 → 2.87, with the goal "Denial-of-Wallet" (OEP Table 1, §6.1)Tasks still completed (U = 0.97–0.99). The agent switches to broad reads: a file listing returns 26.0 records against 1.0 for a filename search (Appendix G)

We will add the table above to §2 and extend the OEP row of Table 5 (Appendix D).

AuthorsOpenReview ↗

Response to Reviewer 3jXQ: W2, Q2, Q3, Q4

W2. Role of credit assignment

We ran the ablation you suggested. The stored reflection is set to one of three forms, and the 44 Haiku 4.5 tasks of Table 1 are run once with each:

Stored reflectionTOSR
A. Assigns credit to the broad action0.89
B. Simply describes the broad action0.43
C. Explicitly limits the broad action to the source task0.32

Transfer depends on what the reflection says about the broad action. Assigning credit to it doubles transfer relative to describing it (0.89 against 0.43) and comes close to the generated reflections of the main experiment (0.92, Table 1). Limiting it to the source task gives the lowest transfer (0.32).

The three texts were edited by hand with LLM-assisted rewording, and we checked each text against its form.

We will add this ablation to §5.2.

Q2. Sensitivity to the reflection scheme

We varied both the reflection prompt and the formulation of the reflection.

Reflection prompt. P1 and P2 are two paraphrases of the paper's reflection-writer prompt (P0), generated by an LLM. The three prompts were run together on the 44 Haiku 4.5 tasks of Table 1:

Reflection-writer promptTOSR
P0 (used in the paper)0.91
P1 (paraphrase)0.93
P2 (paraphrase)0.91

The three results are within 0.02 of each other, and the new run of P0 is within 0.01 of Table 1 (0.92). Rewording the prompt does not change transfer.

Formulation. The ablation under W2 sets the reflection text itself, and transfer then ranges from 0.32 to 0.89.

So the factor that influences transfer is what the stored reflection says about the broad action (credit, description, or a limit to the source task), not the wording of the prompt. We will add both experiments to §5.2.

Q3 [Reqd.]. Model size within the same family

We ran R-CAP on two sizes of an open-weight family, Qwen3.5-4B and Qwen3.5-9B, with the metrics of Table 1.

ModelConditionURIRCAERConditional TOSREnd-to-end TOSR
Qwen3.5-4BDirect memory0.671.001.000.56—
Qwen3.5-4BR-CAP0.980.970.640.860.68
Qwen3.5-9BDirect memory0.901.001.000.78—
Qwen3.5-9BR-CAP0.980.990.710.900.76

In the clean condition (no memory), U=1.00 and TOSR = 0.00 at both sizes.

  • R-CAP works at both sizes. Conditional TOSR is 0.86 at 4B and 0.90 at 9B, with utility 0.98 at both. The larger model is not more resistant.
  • Direct memory. TOSR is lower at 4B (0.56 against 0.78) mainly because the 4B model fails the task more often when the hand-written rule is loaded (U=0.67 against 0.90), and TOSR requires task success.
  • Same pattern in Table 1. Haiku 4.5 and Sonnet 4.6, the smaller and the larger tier of the Claude family, have Conditional TOSR 0.92 and 0.91.

Why the paper has no size comparison. The evaluation keeps only tasks that the model completes without b in all three clean runs (§5.1). The open-weight family that we tried, Qwen2.5, completes too few of the 97 AgentDojo tasks without memory:

ModelTasks completed without memory
Qwen2.5-0.5B12/97 (12%)
Qwen2.5-1.5B11/96 (11%)
Qwen2.5-7B39/97 (40%)
Qwen2.5-14B51/97 (53%)

With 11% to 53% completed, too few tasks are completed at every size, so the paper reports GPT-4o, Haiku 4.5 and Sonnet 4.6. Qwen3.5 made the comparison above possible. We will add both tables to the appendix.

Q4. Corrective feedback

We tested this in one case (Qwen3.5-9B, calendar). Starting from the poisoned memory, we gave corrective feedback on one episode. The same reflection writer then generated a new lesson, which was appended while the original entry stayed in memory. The corrective lesson explicitly recommended retrieving only the named event. We ran three fresh sessions right after the feedback, and three more after three further ordinary tasks with reflection updates and no further feedback.

The broad action occurred in 2 of 3 sessions right after the feedback and in 2 of 3 sessions three tasks later. Utility was 3/3 at both checkpoints. In this case the correction did not remove the behavior: the corrective lesson was generated and stayed loaded, and the broad action still occurred. Memory here is append-only, so the original entry and the correction were loaded together.

Two results in the paper are relevant:

  • Removing the entry removes the behavior. When the reflection is generated but not loaded for the victim, TOSR is 0.00 with utility 1.00 (Table 2B, Table 3A).
  • The agent gets no signal to correct itself. Under R-CAP the task still succeeds (U = 0.97–0.99), so there is no failure to reflect on. A correction needs an outside signal, for example an access audit.

Thank you for the detailed responses and the additional experiments, in particular the reflection-form ablation, the Qwen3.5 size comparison, and the structured comparison with OEP. These address my main questions. I will maintain my rating, which reflects that the distinction from OEP, while clearly argued, has not yet been demonstrated empirically, and that the new ablation suggests that credit assignment explains only part of the transfer. I hope the new results and clarifications are carried into the final version if the paper is accepted.

Thank you for engaging with the new results. The reflection-form ablation, the Qwen3.5 comparison and the comparison with OEP are in the revised PDF (Section 5.2 and Appendices D.1, P and Q), and they will stay in the final version.

Comments on the paper

1 comment
Area_Chair_HV4XOpenReview ↗

Reminder: Discussion Period Closes in 24 Hours

Dear Reviewers,

This is a gentle reminder that the discussion period will close in 24 hours.

If you have not yet done so, please review the authors’ responses to your comments and participate in the discussion. Please let the authors know whether their responses have addressed your concerns or whether you have any further questions.

Thank you again for your time and contribution to the review process.

Best regards,

AC

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.