acceptodds
Under review as a conference paper at ICLR 2027

Agent Memory Is a Surface for Endogenous Authorization Laundering

28 views

Abstract

Long-running LLM agents rely on persistent memory to preserve not only task context but also the permissions and restrictions governing their actions. When memory misrepresents this evolving authorization state, the agent's own records can make unauthorized actions appear permitted, resulting in misaligned behavior without any external attacks. We term this failure endogenous authorization laundering, where memory creates or retains false authority through semantic misinterpretation or failed updates, and executors act on that authority. We then introduce EAL-Bench to measure how accurately persistent memory preserves evolving authorization state and whether memory errors propagate to unauthorized actions. We evaluate seven LLMs as memory writers and two as executors across procurement, cybersecurity, and finance tasks. Under incremental typed-memory updates, writers create false authority for up to 45.4% of unauthorized requests, and once false authority is present, executors act on it in 99.0% of trials. Memory-level safeguards reduce laundering but can reject legitimate actions, exposing a safety–utility tradeoff. Persistent memory is therefore part of an LLM agent's effective authorization policy, not merely a performance component.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
LLM agents, persistent memory, authorization, agent memory, agent safety, memory integrity, authorization laundering

Reviews

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

This paper introduces endogenous authorization laundering (EAL), a failure mode in which persistent agent memory incorrectly creates or retains authority and a downstream executor subsequently acts on that state. EAL-BENCH evaluates this writer–memory–executor chain across procurement, cybersecurity, and finance, using seven memory-writer models, two calibrated primary executors, typed and free-text memory, and one-shot versus incremental updating. The benchmark uses a hidden deterministic authorization ledger, matched authorized/unauthorized requests, frozen-memory replay, exact-state repair, and several mitigation and robustness studies.

The central within-benchmark result is convincing. Typed incremental memory forms false authority for up to 45.4% of unauthorized probes, and the tested executors act on erroneous memories in 386/390 trials, compared with 1/390 after oracle-exact memory replacement. The paper provides a valuable benchmark and unusually detailed mechanism analysis. My main reservations concern the effective experimental unit, dependence among pooled observations, coupling to a particular patch-based memory implementation, conditional selection of perfectly calibrated executors, and several claims that generalize beyond the evaluated architecture.

Critical strengths
  1. Clear and useful problem formulation. The separation between false-authority formation (F) and downstream execution (G) in Section 3.1 (pp. 3–4) is conceptually useful. The deterministic ledger and exact-action scoring avoid relying on an LLM judge for the primary authorization outcomes.

  2. Strong memory-level causal intervention. The exact-state repair experiment is a major strength. The request, executor, and other inputs are held fixed while the erroneous memory is replaced by oracle-exact state (Section 4.2; Table 11, p. 19). The reduction from 386/390 to 1/390 unauthorized actions convincingly establishes the stored memory artifact as a causal mediator in the evaluated system.

  3. Broad and transparent empirical investigation. The paper evaluates seven writers, multiple memory representations and update strategies, two primary executors, a third-executor check, three domains, and three primary seeds. The appendices provide prompts, schemas, raw counts, software versions, writer–executor matrices, capacity ablations, and lineage information.

Critical weaknesses
  1. The inferential target and effective experimental unit are insufficiently clear

The benchmark contains only 12 procurement, 16 cybersecurity, and 8 finance base cases. Headline rates pool multiple probes derived from the same memory, stochastic runs on the same cases, seven fixed writers, and two executors replaying shared artifacts. Section 3.3 recognizes this dependence, but Table 2 reports no uncertainty, and the clustering units vary across analyses.

Consequently, the large request denominators should not be interpreted as independent evidence about a broader population of authorization histories. The paper should define the estimand for each main claim and report base-case-clustered intervals for Tables 2 and 10, keeping all probes, seeds, conditions, and executor replays derived from a case or memory together. Leave-one-case-out results would show whether any headline effect depends heavily on a small number of authored cases.

  1. The typed incremental result is partly coupled to the chosen update harness

Typed memory uses a relatively brittle PatchDoc protocol: nested arrays require dependent patches, writers receive only one validation-informed retry, and two failed attempts cause the previous profile to remain active (pp. 14–18). This recovery rule directly converts write failures into stale authorization.

The issue is especially important in cybersecurity: 503/529 attributed open-loop failures are rejected updates rather than semantic reinterpretations (Table 26, p. 31). In the single-seed capacity ablation, doubling capacity reduces baseline unauthorized actions from 12.5% to 1.6% (Table 34, p. 35).

This remains a real system failure, but it supports a narrower claim about the evaluated LangMem/PatchDoc/fail-stale configuration, not typed or incremental memory in general. The paper should report rejected-update rates beside behavioral results and either:

add a simpler incremental baseline that regenerates the complete typed state;

evaluate fail-closed or stale-state signaling after a rejected write; or

consistently narrow the claim to the tested patch-based implementation.

  1. The propagation and repair conclusions require more conditional wording

The executors are selected only if they make no errors under faithful benchmark memories, receive memory as their only case-specific authorization evidence, and are instructed to execute when that memory covers the request. Under this protocol, high (P(G\mid F)) is informative for causal localization but also partly induced by executor selection and interface design.

Moreover, oracle repair replaces the entire memory. It establishes a memory-level cause, but it does not prove that the particular false-authority record measured by (F) is the sole mediator; unrelated omissions, ordering, or wording may also change.

The paper should report how many executors were screened, provide results without conditioning on perfect calibration if available, and describe the 99% result as applying to “selected calibrated executors in the EAL-BENCH memory-only protocol.” A request-local minimal-repair arm would more specifically connect (F) to execution. Without an independent policy gateway or source lookup, the statement that executor-side safeguards “cannot” help is too broad.

Questions for authors
  1. What are the confidence intervals for Tables 2 and 10 when resampling at the base-case level? Do the conclusions survive leave-one-case-out analysis?

  2. What are the formation and unauthorized-action rates after separating semantic/lifecycle errors from rejected PatchDoc writes? Do the main results hold with full-state regeneration or a fail-closed recovery policy?

  3. How many executor candidates were evaluated before selecting the two calibrated executors? What propagation rate is obtained without conditioning on perfect faithful-memory behavior?

  4. Can the authors add a request-local repair condition that modifies only the fields determining (A_M(M_T,a_q)), rather than replacing the complete memory?

1 comment

Thank you again for your positive assessment of our work and for your constructive suggestions! We wanted to follow up briefly to let you know that we have now updated the paper accordingly:

  • Section 3.3 now clarifies that the base case is our experimental unit, we added bootstrap intervals for false-authority formation in table 10, and shown how these estimate changes when we leave out one case at a time in Appendix E;
  • Appendix B.5 now compares PatchDoc with atomic full-state rewriting, reporting rejected updates alongside action outcomes so to distinguish failed updates that leave stale permissions from accepted updates that record incorrect permissions;
  • Appendix E now examines blocking execution after failed updates and checking proposed actions agains the hidden ledger (done offline, using the saved executor decisions);
  • we've clarified that the propagation result applies to the two calibrated executors relying on memory for authorization, and that the repair experiment tests the causal role of the memory as a whole;
  • we've also removed the statement on executor-side safeguards being uncapable to help, as you suggested.

The updated artifact archive includes the new experiment under the w2/ directory, and the additional analyses under review_checks/, with the saved records and code available for inspection in case you are interested :)

We appreciate your support and careful engagement, which helped us make the experimental interpretation and manuscript clearer. Thank you again!

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

This paper introduces endogenous authorization laundering, a failure mode in which an LLM agent's persistent memory incorrectly represents evolving permissions, causing downstream agents to perform unauthorized actions even without adversarial attacks. The authors propose EAL-Bench, which separates the formation of incorrect authorization states in memory from their propagation into agent actions. Experiments across seven memory writers, two executors, and three domains (procurement, cybersecurity, and finance) show that incremental memory updates substantially increase authorization errors, with false authority forming in up to 45.4% of unauthorized requests and propagating to execution in 99.0% of corresponding trials. The paper further investigates error mechanisms and mitigation strategies, highlighting the effectiveness of memory rebuilding and the safety-utility tradeoffs of other defenses.

Critical strengths
  1. Important problem with a clear formulation. The paper highlights a relevant risk in persistent agent memory, distinguishing the formation of incorrect authorization states from their propagation to downstream actions.

  2. Systematic empirical evaluation. The benchmark evaluates multiple models, domains, memory representations, and update strategies. The analysis of different failure mechanisms and mitigation strategies provides useful insights into authorization drift and the safety-utility tradeoff.

Critical weaknesses
  1. Potentially underspecified authorization rules. It is unclear whether source-authority rules are sufficiently explicit in the writer-visible context. Some failures may reflect ambiguous instructions or implementation-specific update failures rather than inherent memory-maintenance limitations.

  2. Limited scale and generalizability. The benchmark contains only 36 synthetic histories and 132 request pairs. Moreover, executors rely exclusively on generated memory without access to original histories or independent authorization checks. Once the memory is corrupted, the high downstream propagation rate is largely expected.

Questions for authors

See weaknesses, and:

  • The evaluation also lacks comparisons with practical authorization-enforcement mechanisms that verify permissions independently of LLM-generated memory.
4 comments

Thank you again for pointing out the distinction between "errors in maintaining authorization state" and "the protection that an independent enforcement mechanism could provide". We agree that scope of the memory-only protocol should have been clear by making explicit the writer-visible rules, and therefore we update the paper accordingly.

On the authorization rules, we augmented Appendix E to show representative inputs from the saved writer requests, in particular:

  • procurement identifies the chief financial officer as the principal who can issue the required exception;
  • cybersecurity explicitly states that only signed operations from the security duty officer can create or change grants, while handoffs, recommendations and operational preferences cannot;
  • finance similarly requires a signed mandate-register entry from the portfolio mandate officer and excludes desk plans, budgets and operational worksheets from changing authority.

On this note, we want to make explicit again that these rules are not supplied only to the hidden scoring ledger, but are of course visible to the writers.

We agree that one-shot performance alone does not prove the "absence of ambiguity", so we've decided to replace that argument with the visible rules themselves. We have added Appendix B.5, where we show that atomic full-state rewriting removes Kimi and Flash's final stale-state failures, but GLM and Nemotron still produce accepted states containing false authority. Thanks to this division, we now distinguish those permission errors from capacity rejection, malformed updates and stale-state fallback.

Additionally, we've audited the seven-writer typed-incremental formation analysis and added whole-case bootstrap intervals to Table 10:

DomainFalse-authority rate95% case-bootstrap interval
Procurement25.9%12.3-39.4%
Cybersecurity10.5%8.2-12.8%
Finance45.4%27.1-62.8%

These are the updated seven-writer estimates used in the revised paper, we hope the intervals make the uncertainty around the formation results easier to asses :)

We also agree that an independent authorization check can interrupt propagation, so we added an offline comparison in Appendix E using the 2048 saved executor decisions. Two findings stand out:

  • blocking execution after a failed final update prevents Kimi and Flash’s stale-state actions, but does not recover lost permissions or catch incorrect permissions in accepted updates;
  • checking proposed actions against the canonical ledger instead blocks all unauthorized actions while preserving the recorded legitimate ones.
    This assumes access to complete trusted authorization state, making it an idealized enforcement mechanism. We have therefore removed the statement that executor-side safeguards cannot help and clarified that our propagation result concerns executors relying on memory as their case-specific authorization evidence.

The updated artifact archive contains the new checks under review_checks/, with code, case contributions, source hashes and gate outcomes linked to the original trials. We appreciate your suggestions, which helped us distinguish more clearly what the benchmark establishes from what depends on the surrounding authorization architecture, and would be grateful for your reassessment of the revision.

Thanks for the detailed clarification and new results. They address most of my questions.

As for the scale of the dataset, I would encourage the authors to provide a more detailed analysis of the taxonomy and coverage of different cases such as authorization lifecycle patterns and failure mechanisms. For the executor results, it would be helpful to clarify the interpretation of 99.0%. It serves more like a validation of the effects of corrupted memory instead of a clear evaluation.

Thank you for your thorough review! We appreciate your acknowledgment that the new results address most of your questions.

On taxonomy and coverage:

  • Appendix B.7 reports 108 controlled procurement histories crossing three lifecycle patterns (amendment, explicit replacement, and implicit replacement) with different restatement counts and grant-to-change gaps across four themes.
  • Appendix B.9 distinguishes five failure categories: restatement errors dominate procurement and finance, while rejected updates dominate cybersecurity.
  • Appendix B.5 contains the new atomic-rewriting experiment which further separates stale permissions retained after failed updates from incorrect permissions in accepted updates.

On 99.0%, we agree with your interpretation:

  • Section 4.2 and Appendix E now explicitly describe this as conditional propagation: the two calibrated executors take unauthorized actions in 386/390 trials with naturally erroneous memories under the memory-only protocol.
  • Replacing only memory with oracle-exact state reduces this to 1/390, establishing the memory artifact’s causal contribution.
  • The benchmark separately evaluates false-authority formation and e2e unauthorized actions; the 99.0% result validates the downstream consequences of corrupted memory.

Given the additional experiments and the above clarifications to your remaining questions, would you consider increasing your score?

Thanks for the explanation. I have increased my score.

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

This paper studies how persistent memory in long-running LLM agents can, during incremental updates, retain revoked permissions or absorb non-authoritative information, leading to unauthorized actions without any external attack, a failure the authors term endogenous authorization laundering. To measure it, the authors introduce EAL-Bench, which spans procurement, cybersecurity, and finance, uses a hidden deterministic ledger as authorization ground truth, and evaluates matched request pairs that differ in a single field. The experiments compare free-text and typed memory under one-shot and incremental updating, and separate the formation of false authority in memory from its propagation to executed actions. Under incremental typed memory, false authority forms for up to 45.4% of unauthorized requests, and once present, executors act on it in 99.0% of trials. The authors further evaluate several mitigations, find a safety–utility tradeoff among them, and argue that memory maintenance should be treated as part of an agent’s authorization boundary.

Critical strengths

The benchmark uses a hidden deterministic ledger and single-field matched pairs, so authorization errors can be scored without an LLM judge. The exact-state repair experiment further shows that the unauthorized actions originate in memory.

Each failure is traced to the specific memory update that introduced it, and mixed results, such as the writer instruction increasing unauthorized actions in cybersecurity, are reported openly.

Critical weaknesses

W1. The writing is overly defensive and sometimes obscures the main narrative

The main text frequently reports a result and immediately adds multiple qualifications, alternative explanations, or preemptive caveats. While these caveats are often individually reasonable, their density makes the prose feel formulaic and overly defensive. I would encourage the authors to state the main findings more directly and retain only qualifications that materially affect their interpretation.

W2. The typed incremental-memory results are confounded with the specific update mechanism

Typed memory differs from free-text memory not only in representation but also in its update procedure, which relies on PatchDoc, JSON Pointer operations, schema validation, and multi-step patches, with failed updates reverting to the previous memory. This matters especially in cybersecurity, where 503 of 529 failures are attributed to rejected updates, and increasing memory capacity reduces the unauthorized-action rate from 12.5% to 1.6%. A typed-memory baseline using atomic full-state JSON rewriting would help separate representation effects from implementation-specific failures.

W3. The benchmark’s failure modes are highly concentrated

Although EAL-Bench spans three domains, most failures come from only two mechanisms: non-authoritative restatements being incorporated as current authority, and failed updates leaving stale authority active. For example, 815/819 procurement failures and 442/464 finance failures are “restatement applied,” while 503/529 cybersecurity failures are rejected updates. Broader authorization structures, such as delegation changes, conflicting principals, inheritance, or rule precedence, would strengthen the benchmark’s failure-mode diversity.

W4. The current submission lacks accessible open-source artifacts

EAL-Bench is presented as an open-source benchmark, but I could not find an accessible anonymous repository or artifact link in the current submission, and the appendix refers to what the future public repository “will include.” For a benchmark paper, access to the benchmark data, code, prompts, generated memories, and evaluation scripts is important for independently checking the construction and reproducing the reported results.

Questions for authors

See Weaknesses.

In the exact-state repair experiment, how many independent erroneous memories, writer–case trajectories, and unique authorization failures are represented by the 390 trials? The relationship between request-level replays and independent memory-level samples is currently unclear.

In the closed-loop experiment, writing the agent’s own logs back into memory reduces legitimate action rate by 14.3 percentage points relative to the control, while unauthorized action rate increases by only 2.7 points. Can the authors further analyze why the dominant effect is the loss of legitimate authority, and identify which memory updates are responsible for this behavior?

Could the authors provide an anonymous EAL-Bench repository during the review period, including the benchmark data, code, full prompts, evaluation scripts, generated memories, and run manifests? For a benchmark paper, being able to inspect these artifacts would substantially increase my confidence in the reproducibility and reliability of the evaluation, and this would increase my score.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Rebuttal improvements and Scientific contribution

Thank you to all three reviewers for the thoughtful discussion, which has led to substantial improvements in the experiments and the paper. As the discussion concludes, we would like to bring together the remaining concerns and clarify the contribution we hope will inform the final assessment.

  • 5yQq (original rating: 1; current rating: 2, but assessed as 2.5) highlighted our deterministic scoring approach and ability to granularly identify when and where errors are introduced, but raised concerns around domain diversity and the relevance of synthetic workflows to real deployments. We clarified several concerns, leading to a score increase, and introduced an additional experiment testing the suggested "atomic full-state rewriting".
  • 23oC (original rating: 2; current rating: 3) recognized that our work tackled an "important problem with a clear formulation". We addressed the concerns regarding underspecification, scale, and generalization with supporting experimental evidence, resulting in a score increase.
  • BWCW (original rating: 3; current rating: 3) likewise praised our "clear and useful problem formulation", "broad and transparent empirical evaluation", and "strong memory-level causal intervention". We addressed BWCW’s helpful feedback in our rebuttal, and integrated these clarifications into the revised manuscript.

While we agree with our reviewers that greater benchmark scale could help to further generalize the findings, the scientific contribution goes beyond the benchmark itself. The paper identifies and experimentally studies a phenomenon we call Endogenous Authorization Laundering: an agent's own memory maintenance can create or retain false authority, leading to unauthorized actions without adversarial input. EAL-Bench provides a controlled and rigorous way to investigate this phenomenon, by separating errors introduced into memory from their downstream consequences and allowing interventions that establish the memory state's causal contribution. This led to several interesting findings, particularly:

  • Incremental updating can undermine authorization even when memory is structured -- across all three domains and both tested memory formats, incremental updating produces substantially more unauthorized actions than one-shot construction.
  • Memory-level mitigations reveal a safety–utility Pareto frontier -- among the tested typed-memory configurations, safeguards reduce unauthorized actions at varying costs to legitimate work. Source filtering, for example, lowers unauthorized actions from 23.5% to 7.3%, while reducing legitimate actions from 93.1% to 53.2%.
  • Successful storage does not guarantee correct permissions -- atomic full-state rewriting removes final stale-state failures for some writers, while others still produce accepted memories containing false authority, separating failed persistence from errors in the permission content itself.
  • A safeguard can help one failure mechanism while worsening another -- explicit authority-checking instructions substantially reduce unauthorized actions in procurement and finance, yet nearly double them in cybersecurity by increasing failed updates.

By identifying and causally characterizing Endogenous Authorization Laundering within the evaluated setting, this work provides a reproducible experimental foundation for understanding an overlooked source of unauthorized agent behavior and evaluating defenses that preserve legitimate work.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.