acceptodds
Under review as a conference paper at ICLR 2027

Confirmation Is Not Attestation: How Agent Memory Mints Fresh Authority

Abstract

Persistent memory lets agents reuse saved values without asking users to repeat them. This convenience creates an authorization ambiguity: approving “use my saved address” confirms an operation over a record, but does not necessarily attest the hidden value resolved from that record. We study this referential-confirmation gap in matched retail and airline tasks with official state mutations. Across 21 entities, a conventional issuer commits externally supplied values in 21/21 cases even though the confirmation is valid and the resulting capabilities are fresh, scoped, and single-use. Two changes eliminate the effect while preserving 21/21 clean completion: showing and binding the exact candidate value, or requiring authenticated source evidence during issuance. We replace the deterministic confirmation oracle with open-ended review by three models. Among 63 hidden-reference decisions, 54 explicitly delegate, two request clarification, and seven affirm without delegation; six of those seven express an expected-value restriction. Conventional issuance nevertheless commits all seven paired external alternatives, whereas source-sensitive issuance rejects all seven. Complete-value review accepts all 63 correct values and no alternatives. The boundary persists across an independent LangGraph implementation, visible warnings, conversational planning, and five memory transformations. A valid confirmation response therefore becomes an authorization fact only when the system records which concrete object the response and its supporting evidence bind.

Primary area:
foundation or frontier models, including LLMs
Keywords:
agent memory, LLM agents, authorization, memory poisoning, tool-use security, provenance, human-in-the-loop confirmation

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

This paper studies how approval of a saved memory record becomes permission to execute a tool action. It makes distinguishing between "approving a record", "approving its concrete value", "imposing a condition on that value", and "explicitly delegating value selection". In controlled retail and airline workflows, the evaluated runtime can discard an approval condition and issue permission for a different value. The paper then compares this behavior with exact-value confirmation, source-sensitive checks, and a compiler that preserves approval conditions. Additional experiments further examine model decisions, source metadata, and repeated memory transformations.

Critical strengths

S1. The paper identifies a useful distinction between approval and execution enforcement. At a runtime the model can correctly enforce an issued permission, while that permission has already lost a restriction expressed during approval. The matched comparisons isolate this step by keeping the candidate and subsequent capability checks fixed. The idea of separating explicit delegation from conditional approval is also valuable, since executing a different value is not necessarily unauthorized when the user deliberately delegates its selection.

S2. The experimental control settings help explain where the failure occurs. The authors distinguish candidate submission, permission issuance, tool execution, and net state change. They also test matching values and explicit delegation, showing that preserving approval conditions need not reject every request. The figures communicate these comparisons clearly, and the paper openly reports the limited model transfer and the idealized assumptions behind its controls.

Critical weaknesses

W1. The additional contribution beyond existing authorization and memory-security work appears limited. Prior work already studies argument-level authority binding[1], concrete-value authorization[2], and false permissions carried through persistent memory[3]. The authors acknowledge these connections and focus on the earlier step where confirmation becomes executable permission. This distinction is useful, but the evaluated failure largely follows from mapping different approval meanings to the same Boolean decision. Preserving a stated value restriction then prevents the corresponding mismatch. I am not sufficiently convinced that this provides a substantial new security principle or empirical finding beyond a focused demonstration of an incorrectly specified authorization interface.

W2. The evaluation establishes the mechanism more clearly than its practical relevance. The experiments cover 21 entities and two mutation families, with many additional episodes replaying the same tasks or model responses. The non-delegating approval behavior appears in one tested confirmer model and is concentrated in airline tasks. The exact-value control uses an ideal oracle, while the condition-preserving compiler consumes structured approval scope and authenticated context rather than interpreting unrestricted user replies. Moreover, as the evaluated confirmation and issuance rules are application-defined, using official benchmark tools or LangGraph does not establish that existing applications implement the same problematic conversion. I feel these choices support a controlled demonstration, but leave the prevalence of the failure and the practicality of the proposed remedy insufficiently established.

[1] Fan et al. (2026). “The Granularity Mismatch in Agent Security: Argument-Level Provenance Solves Enforcement and Isolates the LLM Reasoning Bottleneck.”

[2] Louck (2026). “Securing LLM-Agent Long-Term Memory Against Poisoning: Non-Malleable, Origin-Bound Authority with Machine-Checked Guarantees.” Section III binds user authorization to the concrete action and value.

[3] Cerruti, Okamoto, and Erol (2026). “Agent Memory Is a Surface for Endogenous Authorization Laundering.”

Questions for authors

Q1. What is the main additional security insight beyond PACT’s argument-level authority checks and TMA-NM’s concrete-action authorization? In particular, does the paper identify a limitation of those mechanisms, or a confirmation-interface mistake that their authorization requirements would already exclude?

Q2. Is the evaluated Boolean conversion based on an existing application or commonly used approval interface? A concrete example would materially strengthen the practical motivation. I understand that the LangGraph experiment implements application-defined confirmation views rather than identifying a vulnerability in LangGraph itself.

Q3. How much of the proposed condition-preserving approach is implemented beyond the structured comparator? Does any experiment test whether approval scope and value restrictions can be recovered reliably from free-form replies? If not, I would appreciate a clearer separation between demonstrating that these conditions can be enforced and providing a practical way to obtain them.

2 comments
AuthorsOpenReview ↗

Response on contribution and scope

Thank you for the specific questions.

Additional insight. PACT and TMA-NM study how already-formed authority should be bound to a concrete action, argument, or value. We study the earlier step that produces that authority from a confirmation reply. Our result is that scope, freshness, and lifecycle checks can all work correctly after issuance while the conversion step has already discarded a value restriction. The mechanisms are complementary: existing enforcement would block the failure if given the correct scope; our paper identifies how that scope can be incorrectly produced.

Practical scope. The Boolean conversion is a controlled application rule, not one taken from a deployed framework. The experiments show that the error can propagate to official tool calls and recorded state changes, but do not establish that the rule is common in deployed systems.

Implementation scope. The condition-preserving comparator consumes structured approval scope and authenticated context. It executes 12/12 matching values, rejects 12/12 alternatives, and preserves 54/54 explicit delegations. We do not test automatic recovery of authorization conditions from unrestricted free-form replies and do not claim to solve it.

Thanks for the reply. The rebuttal clarifies the distinction between producing authorization and enforcing it, but does not resolve my main concerns about the additional contribution and practical relevance. The Boolean conversion remains application-defined, and recovering approval conditions from free-form replies is still not evaluated. The current version does support a useful controlled demonstration of an authorization-interface failure, however, its prevalence and the practicality remain insufficiently established and limited. Therefore, I decide to retain my weak rejection score.

Reviewer_oprxOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies agents that ask the user to approve a saved memory record without showing its value.

Critical strengths
  1. Sec. 2 does a good job at defining what a confirmation authorizes when the value sits behind a memory reference; showing where a yes/no flag drops a value condition. Table 5 shows that with record-only confirmation, source-sensitive issuance accepts 21/21 authenticated wrong values and 0/21 external correct ones, so provenance cannot replace user approval.

  2. The failure is traced to official tool calls and recorded state, and controls rule out other possible causes: wrong record identifiers, versions, entities, fields and value digests are each rejected 21/21 (C.1), as are all 8 reused invalid capabilities (C.10); clean completion stays 21/21 (Table 1). So the fault is in issuance itself.

Critical weaknesses
  1. The main tables restate the issuer definitions. Once candidates are extracted and replies frozen, every cell of Tables 1, 2, 5 and 8 follows from the rules (e.g., the conventional issuer never compares the value with what was approved, Eq. 3). The McNemar p compares deterministic rules and adds no evidence. The issuer is application-defined (Sec. 3.1); no deployed framework is shown to work this way.

  2. The new element is narrow and not well-supported. The dominant behavior, delegation (54/63), executes the external substitute even under source-sensitive and condition-preserving issuance (54/54, Table 2) and is counted as authorized.

Questions for authors
  1. (Clarification) Does any deployed agent framework or approval API issue permission from approval of a record whose value is hidden? An example would help substantiate significance.

  2. (Clarification) Eq. 4 has no delegation term, yet source-sensitive issuance executes all 54 delegated external substitutes (Table 2). How does delegation enter Eq. 4, and why are these authorized when the screen named the authenticated record, which the replay binds to the external summary (B.6)?

  3. (Clarification) The condition-preserving compiler checks against a value the runtime already holds (Sec. 2.2; B.6). Why would such a runtime resolve the value from memory at all? Should we test a compiler that reads the condition from the reply alone?

1 comment
AuthorsOpenReview ↗

Clarifications on delegation and compilation

Thank you for pointing out these definition issues.

Deployed example. We do not claim that an existing framework uses this rule. τ²-Bench and LangGraph verify that the rule can reach an official tool call and a state change; they do not establish deployment prevalence. The issuer is a controlled application-level design.

Delegation. Equation 4 describes source-sensitive issuance without explicit delegation. Explicit delegation is a separate sufficient authorization path. The 54/54 delegated cases in Table 2 use that path, not Equation 4. We agree that the text should state this branch more directly.

Condition-preserving compiler. Authenticated context supplies the expected value v*, while memory supplies the actual candidate v that will become the tool argument. The runtime must compare them before issuing authority. Reading the condition from the reply alone can recover the restriction, but cannot determine whether the value resolved from memory satisfies it. The current experiment uses structured approval scope and authenticated context; it does not solve reliable extraction from unrestricted free-form replies.

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

The paper studies the flaw of the system where an agent reuses a saved memory value (e.g., an address, a flight itinerary) and user approves it without seeing the value. If a wrong value got into memory, it can lead to some unexpected results (e.g., approving a different reservation). They simulate this using 21 tasks: 10 retail address updates and 11 airline itinerary updates. Two fixes block them all while keeping legitimate tasks working: showing the user the actual value, or checking where the value came from.

Critical strengths
  • Important and interesting topic
  • Formalizing and empirical experiments
Critical weaknesses
  • One of my main concerns is that the authors don't use a real setup/applications. Without experiments on real applications, it is unclear whether the issue are due to the authors’ simplified logic or is really pervasive.
  • The paper would be more interesting if it studied model behavior more deeply, e.g., whether models approve a wrong decision or detect that the memory is contaminated.
  • The paper’s structure could be improved with clearer framing up front.
Questions for authors

Please see weaknesses above.

1 comment
AuthorsOpenReview ↗

Response on scope and model behavior

Thank you for the comments.

Practical setting. We agree that the experiments do not show that this problem is widespread in deployed systems. We use official τ²-Bench tools and a LangGraph workflow to verify the complete execution path, but the confirmation-to-permission rule is a controlled application design. The result is narrower: if a system converts “approve this record” directly into authority over the record’s hidden value, a value restriction expressed by the confirmer can be lost during that conversion.

Model behavior. The existing experiments also show a clear model boundary. GPT-5.6 Luna produces 24 non-delegating approvals across three confirmation phrasings, whereas Gemini-3.7 Flash and Grok-4.6 explicitly delegate in every corresponding test. Showing trusted source metadata to the actor changes external-candidate submission from 21/21 to 0/21. Thus the behavior depends on the model and on what the interface exposes; it is not universal.

We will make this scope and the paper’s framing more explicit.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.