acceptodds
Under review as a conference paper at ICLR 2027

Selective Confluence: Coverage-Conditioned Recovery for Agent-Memory Handoffs

Abstract

Cross-session agents use compact memories to continue work without replaying their full histories. A later decision may nevertheless require an exact identifier, status, or prior outcome that was unknown when the memory was written. Better retention and retrieval do not by themselves specify which evidence may authorize that decision. We introduce SELECTIVE CONFLUENCE, a handoff contract that keeps semantic memory advisory and recovers a claim-selected canonical record from an external archive. A local membership check controls release before model exposure; failed lookup or verification returns Defer. Under explicit selection and decision assumptions, the authoritative evidence and the decision grounded in it are independent of the memory-update order. In offline reconstruction over 24 recorded-session tasks and five high-load writer states, with frozen exact selection, verified recovery increases correct decisions from 21/120 to 109/120, with no wrong action and positive mean gains on 23/24 tasks. Matched controls separate the information supplied by episode evidence from the integrity enforced by verification. Structured memory and a released memory-system control show that recovery gains depend on missing coverage, while an open-weight full stack exposes record addressing as a separate bottleneck. These results support a verifiable evidence path for exact commitments when compact memory cannot guarantee coverage.

Primary area:
applications to robotics, autonomy, planning
Keywords:
LLM agents, agent memory, cross-session handoffs, evidence recovery, verifiable retrieval, selective abstention

Reviews

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

This paper proposes Selective Confluence, a handoff contract that separates advisory semantic memory from canonical records used to support exact commitments. A selector retrieves a claim-relevant record, and a local Merkle membership check controls whether that record is released to the successor. The paper establishes a conditional evidence-confluence property and evaluates coverage, addressing, integrity, and downstream evidence use through offline reconstruction experiments.

Across 24 tasks and five writer realizations, verified recovery improves the registered score from 21/120 to 109/120 under frozen correct record selection. The paper includes valuable controls showing that recovered information supplies most of the accuracy benefit, while verification enforces a narrower integrity boundary. My main concern is whether this carefully documented decomposition establishes sufficient additional scientific and practical value beyond source revisitation and authenticated storage. The authority policy is also more fully specified than enforced by the evaluated successors, and the registered metric does not consistently capture faithful task outcomes.

Critical strengths
  1. Clear separation of distinct failure mechanisms. The distinction between coverage, addressing, membership integrity, and evidence use is useful (Sections 3–5). The paper correctly explains that authentic records may still be irrelevant or false, and that invariant evidence does not automatically imply invariant model decisions.

  2. Informative matched controls and negative results. Table 5 is particularly helpful: receipt-free episode traces achieve 52/60, clean exact records achieve 53/60, and verified exact records achieve 54/60. The authors correctly avoid attributing this one-cell difference to improved reasoning from verification. The sufficient-capacity structured control and the Mem0 comparison also establish meaningful limits on when recovery adds information.

  3. Transparent experimental and statistical reporting. The confirmation retains all five writer realizations and prospectively extends to the remaining tasks. The analysis reports writer-level gains, task directions, and crossed task–writer resampling rather than treating all 120 cells as independent samples (Appendices C.5 and C.9). Null results and the incomplete second-model natural run are disclosed appropriately.

  4. Correctly scoped formal guarantees. I found no substantive error in the two propositions in Appendix A. The assumptions about canonical archives, authenticated roots, selection, and downstream decision rules are explicit.

Critical weaknesses
  1. The additional contribution beyond existing source recovery is limited

Source revisitation is already an established response to lossy memory; for example, ReadAgent combines gist memories with lookup of original passages. The paper acknowledges this prior work and adds an explicit authority contract and a standard authenticated-record interface.

However, Proposition 2 assumes an order-independent archive and index, the same selected relevant key, unique materialization, and a fixed record-grounded decision rule. Evidence and decision invariance then follow directly from identical inputs. This is useful as a specification, but it does not establish how the difficult selection and decision assumptions are achieved.

The empirical controls reinforce this concern: ordinary receipt-free source recovery supplies nearly all clean utility, while the alteration experiment demonstrates the expected behavior of a correctly implemented membership gate. The paper therefore establishes its component decomposition more strongly than a new capability for agent handoffs. A direct demonstration of the complete authority contract, including its decision rule, would strengthen the contribution. ReadAgent, ICML 2024.

  1. The headline gain conditions on correct selection of an unusually informative record

The 21/120→109/120 comparison uses frozen correct record selection, and the designated support record is the native evaluator receipt containing the recorded outcome (Appendix B; Appendix C.5). This is a legitimate evidence-sufficiency experiment, but it does not estimate the performance of the complete retrieval-and-decision system.

The additional routing experiments are useful, although their results depend strongly on the available addressing information. Sparse target-derived keys achieve 12/12 selection, whereas the hint-free index achieves 1/12. The local Qwen full stack selects the correct record for 3/12 tasks and achieves 15/60 correct outputs; Mem0 and Mem0 plus recovery both achieve 8/12 under the registered score (Sections 5.5 and Appendix D.7).

These results leave the practical benefit over a competent memory-and-retrieval baseline uncertain. The paper should clarify how routing metadata is constructed independently of future queries and show what operational records substitute for evaluator receipts. This is especially important where a receipt supplies a corrected interpretation absent from the actor trace (Appendix D.5).

  1. The evaluated system does not fully enforce its commitment-authority rule

The contract declares semantic memory non-authoritative for commitment-bearing claims. Nevertheless, the wrong-but-valid-record experiment produces 12/60 correct answers supported by semantic memory rather than the released record (Section 5.5; Appendix D.6). Four responses in the broader routing panel also cite record IDs unavailable in their condition.

Furthermore, the local full-stack experiment deliberately calls the successor after invalid selection instead of implementing the stipulated hard-DEFER branch (Appendix C.7). These limitations are candidly acknowledged and do not contradict the conditional theorem. They do, however, mean that the experiments demonstrate a record-integrity gate plus prompted adherence, rather than enforcement of the complete authority contract.

For the existing task family, the authors should demonstrate a successor/action rule that satisfies the contract and report evidence-reference compliance alongside answer correctness. Testing decisions across differing memories with the same verified record would directly evaluate the claimed decision invariance.

  1. The primary metric incompletely measures faithful outcome reconstruction

The registered exact-term or status/action rule can classify correctly described negative outcomes as DEFER. Conversely, exact-term matching can credit an answer that falsely reports task completion. The Mem0 audit illustrates this distinction: both registered scores are 8/12, while outcome fidelity changes from 7/12 to 10/12 (Appendix D.7).

Consequently, “109/120 correct decisions” should be interpreted strictly under the registered scoring rule. Its relationship to faithful task outcomes and authorized commitments is not fully quantified.

The authors should retain the registered score and add a clearly labeled outcome/status audit over the complete primary panel, including failed episodes. This could use the saved outputs and native outcome records without additional model calls. Reporting correct negative answers, unsupported positive commitments, and deferrals separately would clarify the practical meaning of the result.

Questions for authors

What behavior or measured benefit distinguishes the complete contract from the same source-revisitation system using canonical records and ordinary trusted storage?

How are the sparse routing keys generated, and which metadata would be available before the future claim? What operational evidence would replace native evaluator receipts?

Can the tested successor enforce both hard deferral after failed lookup and the rule that semantic memory cannot independently authorize a commitment? What are the primary panel’s evidence-reference compliance rates?

What are the complete 24-task results under a uniform outcome/status audit, particularly for recorded failures and false completion claims?

4 comments
AuthorsOpenReview ↗

Authors' Response(1/3) for Weakness 1, Question 1 and Question 3

Thank you for your careful review and for recognizing the separation of failure mechanisms, the matched controls in Table 5, our transparent statistics and the correctness of both propositions. You asked for a direct demonstration of the complete contract, operational evidence beyond evaluator receipts and a uniform outcome audit. We built an executable commitment rule and ran each requested test.

Weakness 1. [...] The empirical controls reinforce this concern: ordinary receipt-free source recovery supplies nearly all clean utility [...] A direct demonstration of the complete authority contract, including its decision rule, would strengthen the contribution.

Question 1. What behavior or measured benefit distinguishes the complete contract from the same source-revisitation system using canonical records and ordinary trusted storage?

Our answer: the contract adds an executable commitment rule that makes authority independent of the deployed model. The rule takes a typed query and one bound record. It checks entity and field scope, then outputs only extracted fields with the bound record ID. It has no memory input. Missing, invalid, mismatched or insufficient evidence returns DEFER.

The complete contract end to end. Over 120 genuine historical sessions, the learned selector, membership verification and the rule run together without oracle routing. They commit on all 22 claims that the native records support, with no unsupported commitment and no successor call. When the selector picked another person's session, the rule deferred.

Matched comparison with source revisitation. Prompted readers receive the same canonical record and answer the same typed claims:

ReaderClean record: grounded ANSWERAuthentic but insufficient record: unsupported commitments
Qwen3.8-27B, ordinary prompt132/14410/144
Qwen3.8-27B, strict prompt131/1443/144
GPT-5.6-sol, ordinary or strict prompt44/48 each0/48 each
Executable rule, on the same positions132/144 and 44/480

The contract therefore differs from source revisitation in three measured ways.

  • Sufficiency for any reader. Authentic and relevant evidence can still be insufficient. GPT-5.6-sol defers on these records, and the rule guarantees the same behavior for every reader, without a model call and with no loss of clean accuracy.
  • Memory cannot authorize. With record, query and seed fixed, switching memory changes the committed claim of Qwen3.8-27B readers in 9/48 clean pairs for each prompt. The rule's output never changes across 960 memory interventions.
  • Integrity across transport. The rule runs on any canonical store. When records cross an untrusted channel, verification adds protection. Without it, altered records produce 24/24 wrong actions. The gate rejects every altered package before the model sees it.

Proposition 2 sets a design target: make the authorized input identical across memories. Our experiments now achieve both of its assumptions. The learned selector returns a stable relevant record (22/24 over 120 sessions, 96/96 across candidate orders and wordings), and the executable rule is the fixed record-grounded decision rule.

Question 3. Can the tested successor enforce both hard deferral after failed lookup and the rule that semantic memory cannot independently authorize a commitment? What are the primary panel's evidence-reference compliance rates?

Our answer: yes. Both rules are now enforced in code.

  • Hard deferral. If the selector returns no valid key, the system defers without calling the successor. This happens in all 96 target-withheld cases of the held-out entity study.
  • Entity binding. Across all 576 query–record pairings of the native archive, the 552 mismatched pairings all defer.
  • Citations. The rule fills the citation with the single verified record ID, so every commitment cites evidence that is present.
Compliance on the original primary panel (n = 120)MemoryVerified recovery
Non-empty evidence reference25120
Every cited record body present in context0105
Cited body supports the reported outcome0120

Verified recovery turns citations from labels into checkable evidence. With the executable rule, compliance is complete by construction.

AuthorsOpenReview ↗

Authors' Response (2/3) for Weakness 2 and Question 2

Thank you again for asking what replaces the evaluator receipt in practice. Below we show archives built only from operational observations and their results.

Weakness 2. [...] The paper should clarify how routing metadata is constructed independently of future queries and show what operational records substitute for evaluator receipts. This is especially important where a receipt supplies a corrected interpretation absent from the actor trace (Appendix D.5).

Question 2. How are the sparse routing keys generated, and which metadata would be available before the future claim? What operational evidence would replace native evaluator receipts?

Our answer: archives built only from operational observations, indexed by metadata recorded during the session, support autonomous recovery.

Routing keys. Appendix D.6 derived its keys from the task instruction. The new archives use no task text.

Operational records. The archives contain native browser and API observations, without evaluator outputs, actor reasoning or actor answers. They replace the receipt:

  • GitLab: contributor pages and API responses.
  • Shopping Admin: filtered order and review pages.
  • Salesforce: creation confirmations and account-contact views.

Metadata available before the claim. The index stores only the observed URL, page title, filter keys and timestamp. All are recorded when the agent visits the page, before any future claim exists.

Corrected interpretations. The archive stores observations, not actor reasoning, so an actor's misreading cannot enter the evidence. The rule reads the observed page value.

Results. Over 120 genuine historical sessions, the learned selector finds the target session in 22/24 queries, under both the original and a paraphrased wording, and in 10/12 on the tasks of Appendix D.6. The full contract then commits on all 22 claims that the native records support, with no unsupported commitment. The two Salesforce creation requests without an observed creation are deferred.

Full answers with the paper's primary model. With GPT-5.6-sol reading the retrieved records, and a strict criterion that requires every stated fact to be grounded in a retrieved record, learned retrieval matches oracle routing (24/48 versus 22/48). It cuts unsupported commitments from 42/48 with index access alone to 14/48. On typed claims, the executable rule makes no unsupported commitment.

Transfer to unseen entities. With all rules frozen, we added 16 new repository entities. The learned selector finds the target in 96/96 present cases and returns NONE in 96/96 withheld cases. Over all 40 tasks and entities, the rule commits on 37 and defers on 3, with no unsupported commitment.

For deployment, an agent needs only the observation log it already produces. We will add these archives and results to Section 5.5 and Appendix D.6.

AuthorsOpenReview ↗

Authors' Response (3/3) for Question 1 and Question 4

Thank you again for these questions on confluence and positioning. Below we answer both, starting with order effects.

Question 4. What evidence demonstrates order invariance independently of writer variability? In particular, can the authors distinguish the effects of acquisition order on memory coverage, selected records, and final decisions, and clarify how often the proposed guarantees hold when selection is performed by learned components?

Our answer: order changes memory and memory-only decisions, and recovery removes that change. A bounded sequential Qwen3.8-27B writer updates memory one session at a time within the same limits. We crossed forward and reverse order with three seeds and reran each chain unchanged.

  • Writer variability. Identical order and seed reproduce byte-identical memories, with no decision change.
  • Memory coverage. Order changes which primary fields survive, by up to 12 of the 98 fields for the same seed.
  • Selected records. The selector reads only the query and the index, so every order selects the same record.
  • Final decisions. Reversing the order flips the memory-only decision on 19 of the 24 tasks. With recovery, it flips on none. The executable rule returns identical outputs across all memories.
  • Same record, different memories. With record, query and seed fixed, switching between empty memory and a generic completion claim changes the Qwen3.8-27B decision in 0/48 (ordinary) and 1/48 (strict) clean pairs. The rule's output never changes.
  • Learned selection. Proposition 2 requires a stable relevant selection. The learned selector returns the same target across candidate orders and wordings in 96/96 held-out cases, and finds the target in 22/24 queries over 120 genuine sessions.

With recovery, a long-running agent reports a past outcome the same way, however its history was summarized.

Question 1. How does Selective Confluence differ technically from TierMem, MemWeaver, and APEX-MEM [...]? In particular, what new guarantees does the proposed authority contract provide beyond existing provenance-aware retrieval and tiered memory architectures?

Our answer: these systems decide what to retrieve. Our contract decides which representation may authorize a commitment. As the paper states, “The contribution is the interface that connects claim eligibility, evidence authority, and release, using established retrieval and Merkle components.” MemGPT [1] and MemoryOS [2] manage memory tiers. TierMem [3] routes between summaries and raw evidence. MemWeaver [4] links graph, experience and passage memory to sources. APEX-MEM [5] keeps temporal history with structured and hybrid retrieval. The contract adds three guarantees.

  1. Memory cannot authorize an exact commitment. The executable rule takes only the query and one bound record.
  2. Evidence must be sufficient, not only authentic and relevant. On authentic records that lack the needed observation, GPT-5.6-sol defers, while Qwen3.8-27B readers still commit in 10/144 (ordinary) and 3/144 (strict) cases. The rule defers on every such record for any reader, without a model call, and keeps the clean accuracy of the prompted readers.
  3. Failure ends in DEFER before any model call. A missing key, a mismatched entity or a rejected proof never reaches the successor.

Each of these systems can keep its memory manager and add the contract for commitment-bearing claims. We will add this comparison to Section 2.

References

[1] Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G. Patil, Ion Stoica, and Joseph E. Gonzalez. MemGPT: Towards LLMs as operating systems. arXiv:2310.08560, 2023. https://arxiv.org/abs/2310.08560

[2] Jiazheng Kang, Mingming Ji, Zhe Zhao, and Ting Bai. Memory OS of AI Agent. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 25961–25970, 2025. https://doi.org/10.18653/v1/2025.emnlp-main.1318

[3] Qiming Zhu, Shunian Chen, Rui Yu, Zhehao Wu, and Benyou Wang. From Lossy to Verified: A Provenance-Aware Tiered Memory for Agents. arXiv:2602.17913, 2026. https://arxiv.org/abs/2602.17913

[4] Juexiang Ye, Xue Li, Yang Xinyu, Chengkai Huang, Lanshun Nie, Lina Yao, and Dechen Zhan. MemWeaver: Weaving Hybrid Memories for Traceable Long-Horizon Agentic Reasoning. In Findings of the Association for Computational Linguistics: ACL 2026, pp. 12928–12956, 2026. https://doi.org/10.18653/v1/2026.findings-acl.630

[5] Pratyay Banerjee, Masud Moshtaghi, Shivashankar Subramanian, Amita Misra, and Ankit Chadha. APEX-MEM: Agentic Semi-Structured Memory with Temporal Reasoning for Long-Term Conversational AI. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 16470–16489, 2026. https://doi.org/10.18653/v1/2026.acl-long.749

Dear Reviewer,

As the deadline for the discussion period approaches, we kindly request your feedback on our response. Your insights would be greatly appreciated.

Thank you for your time and consideration!

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

This paper proposes selective confluence, which retrieves verified records to ensure consistency for cross-session agents to resolve the coverage issue of compact agent memory.

Critical strengths
  1. The paper writing is ok, with good figures.
  2. Results on GPT-5.5 and Qwen3-8B seem good.
Critical weaknesses
  1. The core idea of selective confluence is largely similar to traditional operating system principles of consistency and correctness that ensure reliable state management, predictable behavior, and data integrity. While this paper applies it to agent memory, the novelty is very incremental, in my humble opinion, as the idea pretty much overlaps with old-school OS principles in an abstract way.

  2. Many definitions in the paper are unclear to me. For instance, why C=1,900 and B=2,048? What do low- and high-load memory scenarios mean in the evaluations?

  3. The overall writing of this paper leans more toward a technical report instead of a scientific paper. Most importantly, this paper lacks a proper structure to guide readers in understanding the why and how behind the core idea. In the evaluation, there are also no proper ablation studies or performance analysis to help readers understand the effectiveness of each key design,

  4. The baseline methods for the proposed method are unclear to me. There are no citations of the selected baseline methods, which makes it hard to judge the novelty of this work.

Questions for authors

Please see the weaknesses.

3 comments
AuthorsOpenReview ↗

Authors' Response (1/2) for Weakness 1 and Weakness 2

Thank you for your comments and for your positive words on our figures and on the GPT-5.5 and Qwen3-8B results. Your concerns are novelty relative to OS principles, unclear definitions, the paper's structure and the baselines. Below we answer each, add ablations and list every baseline with its citation.

Weakness 1. The core idea of selective confluence is largely similar to traditional operating system principles of consistency and correctness that ensure reliable state management, predictable behavior, and data integrity. [...]

Our answer: OS principles keep stored bytes intact. Our question is whether recovered evidence may authorize a commitment. Agent memory adds a step that classic state management does not have. A model rewrites a long history into a short summary before the future question is known. Proposition 1 shows that once the possible histories outnumber the handoff states, a bounded self-contained handoff cannot answer every distinguishable future question. Some exact evidence must stay outside the summary, and the system must decide which representation may justify a commitment.

Intact bytes do not settle this. As the paper states, “Authenticity and relevance are distinct, so selection and integrity are scored separately.” Our new results isolate a third condition, sufficiency. A verified commit-history page of PHP_XLSXWriter is authentic and relevant, yet it shows no contributor totals. A Qwen3.8-27B reader still reported 28 or 25 commits. Our executable commitment rule deferred, and on the contributor page it answered correctly (58 commits for mk-j). Across such insufficient records, Qwen3.8-27B readers make unsupported commitments in 10/144 and 3/144 cases, GPT-5.6-sol defers (declines to commit), and the rule defers every time without a model call. Integrity checks cannot catch this failure, because every byte is genuine. In practice, a successor that trusts such a page would report work as done when the evidence does not show it.

The contract uses standard components where they suffice, such as Merkle membership for integrity. Its contribution is the interface that assigns authority: memory supports planning, a selected record supports exact commitments, and missing or insufficient evidence ends in DEFER, whichever model is deployed.

Weakness 2. Many definitions in the paper are unclear to me. For instance, why C=1,900 and B=2,048? What do low- and high-load memory scenarios mean in the evaluations?

Our answer. C = 1,900 is the writer's character limit and B = 2,048 is the UTF-8 byte limit of the stored memory. They use different units, so we check both. The values place the experiments in the regime the paper studies: a low-load memory keeps every queried binding, while a high-load memory cannot. In the capacity panel, the high-load writer must compress 224 candidate bindings into 1,900 characters.

Load is the number of source records one writer compresses into the same budget. In the recorded-session panels, a low-load writer sees one eight-episode bundle and a high-load writer sees all 24 episodes. In the capacity panels, low-load writers see four cards and the high-load writer sees all 28.

The effect holds across settings (Appendix D.3). At 1,900 characters, loads 4, 8, 16 and 28 score 12/12, 12/12, 12/12 and 2/12. At load 28, budgets of 950, 1,900 and 3,800 characters score 1/12, 2/12 and 3/12. A second model reproduces the load contrast. We will state these definitions at the start of Section 4.

AuthorsOpenReview ↗

Authors‘ Response (2/2) for Weakness 3

Thank you again for your comments on structure and baselines. Below we show how each design answers one question with its own ablation, and we list every baseline with its citation.

Weakness 3. [...] this paper lacks a proper structure to guide readers in understanding the why and how behind the core idea. In the evaluation, there are also no proper ablation studies or performance analysis to help readers understand the effectiveness of each key design.

Our answer: each component answers one question, and each has an ablation.

QuestionAblationResult
Is the needed information missing from memory?Memory vs. verified record, 24 tasks, 5 writers21/120 vs. 109/120, every writer gains
Where does the gain come from?Memory, + index, + verified record81, 109, 115 of 120
Can retrieval find the record without oracle routing?Learned selector over 120 genuine sessions, no task hints22/24, all 22 supportable claims committed
Does verification enforce integrity?Alter a record after commitmentUnverified: 24/24 wrong. Gate: 24/24 rejected before the model
Does the rule enforce sufficiency?Prompted readers vs. executable rule on authentic but insufficient recordsQwen3.8-27B: 10/144 and 3/144 unsupported commitments. Rule: 0 for every reader
Does recovery remove the order effect?Forward vs. reverse sequential writing, 3 seedsMemory-only decisions flip on 19/24 tasks, recovery on 0/24
Does sufficient structure remove the order effect?Structured writers, opposite orders, ample capacity6/6 pairs identical, 96/96 bindings kept

Removing the record removes the information gain. Removing verification admits altered bytes. Removing the rule admits unsupported commitments. The paper states the same logic: “a better summary cannot authenticate altered bytes, and a valid proof cannot make an irrelevant record useful.”

Performance. Recovery matches full replay (24/24 each) while exposing only 35.2% of the full-replay context to the successor (2,075 versus 5,901 bytes). The executable rule runs locally in under a millisecond and needs no model call.

We will open Section 4 with this table and a short overview of why each component exists.

Weakness 4. The baseline methods for the proposed method are unclear to me. There are no citations of the selected baseline methods, which makes it hard to judge the novelty of this work.

Our answer: every baseline and its source.

BaselineWhat it representsReference
Semantic memory, low and high loadCompact handoff without recoverySection 3 of the paper
Metadata BM25Lexical retrievalRobertson and Zaragoza [1]
Dense retrieval, Qwen3-Embedding-0.6BEmbedding retrievalZhang et al. [2]
Hybrid retrieval, reciprocal rank fusionLexical plus dense retrievalCormack et al. [3]
Mem0 2.0.19Released memory systemChhikara et al. [4]

Free-form readers can still make unsupported commitments even with relevant evidence. This is why commitment-bearing claims go through the executable rule. With Mem0 [4], adding the verified record turns both false completions on failed tasks into deferrals. We will add this table and its references to Section 4.

References

[1] Stephen Robertson and Hugo Zaragoza. The probabilistic relevance framework: BM25 and beyond. Foundations and Trends in Information Retrieval, 3(4):333–389, 2009. https://doi.org/10.1561/1500000019

[2] Yanzhao Zhang, Mingxin Li, Dingkun Long, Xin Zhang, Huan Lin, Baosong Yang, Pengjun Xie, An Yang, Dayiheng Liu, Junyang Lin, Fei Huang, and Jingren Zhou. Qwen3 Embedding: Advancing text embedding and reranking through foundation models. arXiv:2506.05176, 2025. https://arxiv.org/abs/2506.05176

[3] Gordon V. Cormack, Charles L. A. Clarke, and Stefan Büttcher. Reciprocal rank fusion outperforms Condorcet and individual rank learning methods. In Proceedings of the 32nd International ACM SIGIR Conference on Research and Development in Information Retrieval (SIGIR), pp. 758–759, 2009. https://cormack.uwaterloo.ca/cormacksigir09-rrf.pdf

[4] Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav. Mem0: Building production-ready AI agents with scalable long-term memory. arXiv:2504.19413, 2025. https://arxiv.org/abs/2504.19413

Dear Reviewer,

As the deadline for the discussion period approaches, we kindly request your feedback on our response. Your insights would be greatly appreciated.

Thank you for your time and consideration!

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

This paper presents Selective Confluence, a memory-handoff framework that separates compact semantic memory from an authoritative archive. It selectively recovers and verifies historical evidence for exact commitments, with a conditional guarantee of order-independent evidence. The offline experiments demonstrate substantial benefits under correct record selection, while also revealing limitations in retrieval and downstream evidence use.

Critical strengths
  • Clear problem formulation. The paper distinguishes memory coverage, record retrieval, integrity verification, and evidence use, providing a useful perspective on cross-session agent memory.

  • Well-designed controls. The experiments help disentangle the benefits of evidence recovery from those of integrity verification.

  • Consistent empirical improvements. Results across multiple writer realizations support the effectiveness of recovery under constrained memory.

  • Careful boundary analysis. Structured-memory, Mem0, and open-weight experiments provide valuable insights into the conditions under which recovery helps or fails.

Critical weaknesses
  • Outcome fidelity and evaluation metrics. The registered correctness metric may not fully capture faithful reconstruction of task outcomes. For example, some Salesforce failures are correctly recognized but mapped to DEFER, while the Mem0 analysis identifies false completion despite matching expected terms. The authors acknowledge these limitations, but additional clarification would strengthen the interpretation of the results. Reporting outcome fidelity, abstention, and unsupported actions alongside registered correctness would help distinguish successful evidence recovery from correct downstream decisions.

  • Dependence on exact routing and evaluator receipts. The main improvement (21/120 to 109/120) assumes exact selection of evaluator receipts containing recorded outcomes. While this isolates the value of recovered evidence, it provides limited evidence of autonomous retrieval performance. The local full-stack selector correctly identifies only 3/12 targets, suggesting that record addressing remains an important challenge. A more closely matched learned-retrieval comparison would strengthen the practical claims. Additionally, a structured-memory baseline under the same byte budget would help separate the effects of representation and capacity.

  • Limited empirical validation of confluence. The conditional confluence proposition is well defined, but relies on stable relevant selection and a fixed record-grounded decision rule. These conditions are not necessarily satisfied by learned components. Moreover, the primary writer realizations vary acquisition order and generation together, making order-specific effects difficult to isolate. A more explicit analysis of opposite-order memory coverage, selected records, and downstream decisions would better connect the theoretical property to empirical behavior.

  • Positioning relative to existing memory architectures. Prior work, including MemGPT (Packer et al., 2023) and MemoryOS (Kang et al., 2025), has explored hierarchical memory architectures. More recent systems such as TierMem (Zhu et al., 2026), MemWeaver (Ye et al., 2026), and APEX-MEM (Banerjee et al., 2026) further combine abstracted memory with retained source evidence or history for query-time retrieval. A clearer discussion of these works would help distinguish the proposed authority contract and conditional confluence guarantees from existing approaches.

Questions for authors
  1. Novelty and related work. How does Selective Confluence differ technically from TierMem, MemWeaver, and APEX-MEM, which also combine compact or structured memory with retained historical evidence? In particular, what new guarantees does the proposed authority contract provide beyond existing provenance-aware retrieval and tiered memory architectures?

  2. End-to-end recovery effectiveness. The main results assume exact routing to evaluator receipts. How should the reported gains be interpreted when retrieval errors are included? Do the existing experiments support conclusions about end-to-end recovery effectiveness beyond the utility of correctly selected evidence?

  3. Outcome fidelity. How does the registered correctness metric handle supported negative outcomes, abstentions, and false completion? Could the authors clarify these cases with examples, particularly for Salesforce and Mem0, to establish how well the metric reflects faithful task reconstruction?

  4. Empirical confluence. What evidence demonstrates order invariance independently of writer variability? In particular, can the authors distinguish the effects of acquisition order on memory coverage, selected records, and final decisions, and clarify how often the proposed guarantees hold when selection is performed by learned components?

6 comments
AuthorsOpenReview ↗

Authors' Response (1/3) for Weakness 1 and Question 3

Thank you for your valuable review and for recognizing our clear problem formulation, the well-designed controls and the consistent gains across writer realizations. Your questions concern outcome fidelity, end-to-end retrieval, empirical confluence and novelty. We answer each with new results on the same 24 recorded-session tasks.

Weakness 1. Outcome fidelity and evaluation metrics. The registered correctness metric may not fully capture faithful reconstruction of task outcomes. [...] Reporting outcome fidelity, abstention, and unsupported actions alongside registered correctness would help distinguish successful evidence recovery from correct downstream decisions.

Question 3. How does the registered correctness metric handle supported negative outcomes, abstentions, and false completion? Could the authors clarify these cases with examples, particularly for Salesforce and Mem0, to establish how well the metric reflects faithful task reconstruction?

Our answer: the gain holds under a strict outcome audit. We keep the registered score and audit all 240 primary outputs against the native browser and API observations alone.

Endpoint (n = 120 per arm)MemoryVerified recovery
Registered score21109
Supported outcome, positive or negative1680
Supported outcome with an ANSWER decision573
Same, with every auxiliary assertion supported472
Supported ANSWER, declared contributor-identity rule1099
Incomplete outcome906

Recovery improves 17 of the 24 tasks and lowers none. Most other recovered outputs are contributor counts whose request does not say whether aliases of one person should be merged. Under a single-displayed-identity rule, they match the native records, and recovery improves 22 tasks with none lower.

How each case is treated.

  • Supported negative outcomes. A correct report of a recorded failure counts as supported content, and as an ANSWER only when the successor commits to it. Recovery commits to 8 such outcomes, memory to none.
  • Abstention. An empty DEFER never counts as reconstruction. Recovery reduces DEFER from 99 to 11.
  • False completion. No output in either arm claims a completion that the recorded outcome contradicts. Recovery reports 13 recorded failures or partial completions accurately, versus 4 for memory.

Salesforce. With the verified record, the successor describes each recorded Salesforce failure correctly. The registered rule records these supported negative answers as DEFER, which explains the Salesforce registered score (12/30 to 19/30). The strict audit credits them.

Mem0. With the verified record added, Mem0's two false completions on natively failed Salesforce targets become deferrals (2/2 to 0/2). A term-matching score cannot see this difference. The outcome audit can. Recovered evidence thus keeps a failed operation from being handed over as a success.

We will report all endpoints with the per-task table in the appendix and state the scoring rule beside each headline number.

AuthorsOpenReview ↗

Authors' Response(2/3) for Weakness 2 and Question 2

Thank you again for pressing on end-to-end effectiveness. Below we remove exact routing and evaluator receipts, and we add the same-budget structured baseline.

Weakness 2. Dependence on exact routing and evaluator receipts. [...] A more closely matched learned-retrieval comparison would strengthen the practical claims. Additionally, a structured-memory baseline under the same byte budget would help separate the effects of representation and capacity.

Question 2. The main results assume exact routing to evaluator receipts. How should the reported gains be interpreted when retrieval errors are included? Do the existing experiments support conclusions about end-to-end recovery effectiveness beyond the utility of correctly selected evidence?

Our answer: recovery stays effective with autonomous retrieval over ordinary operational records. As the paper states, “Oracle routing tests evidence sufficiency, not retrieval accuracy.” We now test retrieval directly.

No evaluator receipts. The new archives contain only native browser and API observations, without evaluator outputs or actor answers. The index holds only observed URLs, page titles, filter keys and timestamps, with no task hints.

Autonomous retrieval. Over 120 genuine historical sessions, the learned selector finds the target session in 22/24 queries, under both the original and a paraphrased wording, and in 10/12 on the tasks of Appendix D.6. With verification and the executable rule, the system commits on all 22 claims that the native records support, with no unsupported commitment.

Full answers. On the original sessions, Qwen3.8-27B readers reach 36, 33 and 35 of 48 faithful complete answers with BM25, hybrid and learned retrieval. This matches oracle routing (34/48) and clearly exceeds index access alone (22/48). With the paper's primary model, GPT-5.6-sol, and a stricter criterion that requires every stated fact to be grounded in a retrieved record, learned retrieval also matches oracle routing (24/48 versus 22/48). It cuts unsupported commitments from 42/48 with index access alone to 14/48. On typed claims, the executable rule makes no unsupported commitment.

Unseen entities. With all rules frozen, we added 16 new repository entities. The learned selector finds the target in 96/96 present cases and returns NONE in 96/96 withheld cases, after which the system defers without calling the successor.

Same-budget structured baseline. Under the same 1,900-character and 2,048-byte limits, text and JSON memories built from the same facts keep all primary fields in only 16/144 and 10/144 memory–task cells. With ample capacity, structure keeps all 96/96 bindings (Section 5.2). The loss therefore tracks capacity rather than representation. With recovery, both representations perform alike (168/288 and 165/288 grounded complete answers).

For a deployed agent, the evidence path works with ordinary session logs and standard retrievers. We will add these results to Section 5.5.

AuthorsOpenReview ↗

Authors' Response(3/3) for Question 4

Thank you again for these questions on confluence and positioning. Below we separate order from writer randomness, show that the guarantee holds with a learned selector, and state what the contract adds beyond existing architectures.

Question 4. What evidence demonstrates order invariance independently of writer variability? In particular, can the authors distinguish the effects of acquisition order on memory coverage, selected records, and final decisions, and clarify how often the proposed guarantees hold when selection is performed by learned components?

Our answer: order changes memory and memory-only decisions, and recovery removes that change. A bounded sequential Qwen3.8-27B writer updates memory one session at a time within the same limits. We crossed forward and reverse order with three seeds and reran every chain with identical order and seed.

  • Writer variability. Identical order and seed reproduce byte-identical memories, with no decision change.
  • Memory coverage. Order changes which primary fields survive, by up to 12 of the 98 fields for the same seed.
  • Selected records. The selector reads only the query and the index, so every order selects the same record.
  • Final decisions. Reversing the order flips the memory-only decision on 19 of the 24 tasks. With recovery, it flips on none. The executable rule returns identical outputs across all memories.
  • Same record, different memories. With record, query and seed fixed, switching between empty memory and a generic completion claim changes the Qwen3.8-27B decision in 0/48 (ordinary) and 1/48 (strict) clean pairs. The rule's output never changes.
  • Learned selection. Proposition 2 requires a stable relevant selection. The learned selector returns the same target across candidate orders and wordings in 96/96 held-out cases, and finds the target in 22/24 queries over 120 genuine sessions.

With recovery, a long-running agent reports a past outcome the same way, however its history was summarized.

Question 1. How does Selective Confluence differ technically from TierMem, MemWeaver, and APEX-MEM, which also combine compact or structured memory with retained historical evidence? In particular, what new guarantees does the proposed authority contract provide beyond existing provenance-aware retrieval and tiered memory architectures?

Our answer: these systems decide what to retrieve. Our contract decides which representation may authorize a commitment. As the paper states, “The contribution is the interface that connects claim eligibility, evidence authority, and release, using established retrieval and Merkle components.” MemGPT and MemoryOS manage memory tiers. TierMem routes between summaries and raw evidence. MemWeaver links graph, experience and passage memory to sources. APEX-MEM keeps temporal history with structured and hybrid retrieval. The contract adds three guarantees.

  1. Memory cannot authorize an exact commitment. The executable rule takes only the query and one bound record.
  2. Evidence must be sufficient, not only authentic and relevant. On authentic records that lack the needed observation, GPT-5.6-sol defers, while Qwen3.8-27B readers still commit in 10/144 (ordinary) and 3/144 (strict) cases. The rule defers on every such record for any reader, without a model call, and keeps the clean accuracy of the prompted readers.
  3. Failure ends in DEFER before any model call. A missing key, a mismatched entity or a rejected proof never reaches the successor.

These guarantees complement the systems above. Each can keep its memory manager and apply the contract to commitment-bearing claims. We will add this comparison to Section 2.

References: MemGPT (Packer et al., 2023). MemoryOS (Kang et al., 2025). TierMem (Zhu et al., 2026). MemWeaver (Ye et al., 2026). APEX-MEM (Banerjee et al., 2026).

Comments on the paper

2 comments
AuthorsOpenReview ↗

Global Response (1/2)

Dear reviewers, thank you for your thoughtful and constructive feedback!

Our Strengths Summarized by Reviewers

We sincerely appreciate the reviewers for highlighting the following strengths of our work:

  • Clear problem formulation. The paper separates memory coverage, record addressing, integrity verification and evidence use, which gives a useful perspective on cross-session agent memory. It correctly explains that authentic records may still be irrelevant or false, and that invariant evidence does not automatically imply invariant decisions (Reviewer mAfd, Reviewer 8HeD).
  • Well-designed and informative controls. The matched controls disentangle the benefit of evidence recovery from that of integrity verification (Reviewer mAfd, Reviewer 8HeD).
  • Consistent empirical improvements. Results across multiple writer realizations support the effectiveness of recovery under constrained memory, and the results on GPT-5.5 and Qwen3-8B are good (Reviewer mAfd, Reviewer Nmfw).
  • Careful boundary analysis. The structured-memory, Mem0 and open-weight experiments give valuable insight into the conditions under which recovery adds information (Reviewer mAfd, Reviewer 8HeD).
  • Transparent experimental and statistical reporting. The confirmation retains all five writer realizations and prospectively extends to the remaining tasks. It reports writer-level gains, task directions and crossed task-writer resampling rather than treating all 120 cells as independent samples (Reviewer 8HeD).
  • Correctly scoped formal guarantees. The conditional confluence proposition is well defined, the two propositions contain no substantive error, and their assumptions are explicit (Reviewer 8HeD, Reviewer mAfd).
  • Clear presentation. The paper is clear and easy to follow, with good figures (Reviewer mAfd, Reviewer Nmfw).
AuthorsOpenReview ↗

Global Response (2/2)

Our Main Revisions and Supplementary Experiments

In response to the reviewers' feedback, we conduct the following new experiments and revise the manuscript accordingly:

  • Strict Outcome Audit of Every Primary Output (Reviewer mAfd, Reviewer 8HeD)
    • We keep the registered score and audit all 240 primary outputs, including failed episodes, against the native observations alone (Section 5.1, Appendix E.1, Tables 9 to 11). Supported answers rise from 5/120 to 73/120, and incomplete outcomes fall from 90/120 to 6/120. Recovery improves 17 tasks and lowers none. The audit credits the Salesforce failures that the registered rule maps to DEFER. No output claims a completion that the recorded outcome contradicts. The scoring rule now appears beside each headline number.
  • Autonomous Retrieval without Evaluator Receipts (Reviewer mAfd, Reviewer 8HeD)
    • New archives hold 120 genuine historical sessions of native browser and API observations, with no actor reasoning. The index stores only the URL, page title, filter keys and timestamp, all recorded before any future claim exists (Section 5.5, Appendix D.6). The learned selector finds the target session in 22/24 queries, and the complete contract commits on all 22 supportable claims with no unsupported commitment. On full answers, learned retrieval matches oracle routing (35/48 versus 34/48 for Qwen3.8-27B readers, 24/48 versus 22/48 for GPT-5.6-sol). On 16 unseen entities, the selector is correct in 96/96 present cases and returns NONE in 96/96 withheld cases.
  • Executable Commitment Rule (Reviewer 8HeD, Reviewer mAfd)
    • Section 3.1 and Table 1 add a rule that takes a typed claim and one released record, has no memory input, and returns DEFER on missing, invalid, mismatched or insufficient evidence. On authentic but insufficient records, Qwen3.8-27B readers commit in 10/144 and 3/144 cases, while the rule defers every time without a model call and keeps the readers' clean accuracy (Section 5.3, Appendix E.2). All 552 mismatched query-record pairings defer, hard deferral after failed lookup runs in code, and every commitment cites its verified record.
  • Order and Decision Invariance (Reviewer mAfd, Reviewer 8HeD)
    • With a sequential writer, identical order and seed reproduce byte-identical memories. Reversing the order flips the memory-only decision on 19 of the 24 tasks, and with the same recovered record on none (Section 5.2, Appendix E.3). Switching memory under a fixed record changes the reader's decision in 0/48 and 1/48 clean pairs, and the rule's output never changes across 960 memory interventions. The learned selector and the executable rule supply both assumptions of Proposition 2.
  • Positioning and New Guarantees (Reviewer mAfd, Reviewer Nmfw, Reviewer 8HeD)
    • Section 2 now discusses MemGPT, MemoryOS, TierMem, MemWeaver and APEX-MEM. These systems decide what to retrieve. Our contract decides which representation may authorize a commitment. It adds three guarantees: memory cannot authorize an exact commitment, evidence must be sufficient and not only authentic and relevant, and failure ends in DEFER before any model call. Data integrity alone cannot give the second guarantee, because an insufficient record is fully authentic (Section 5.3).
  • Definitions, Ablations and Baselines (Reviewer Nmfw, Reviewer mAfd)
    • Section 4 now opens by defining C = 1,900 as the character limit, B = 2,048 as the byte limit of the stored memory, and load as the number of source records one writer compresses into the same budget.
    • Table 2 states the question each component answers and its ablation. Removing the record removes the information gain. Removing verification admits altered bytes. Removing the executable rule admits unsupported commitments. Recovery matches full replay (24/24 each) while exposing only 35.2% of its context.
    • Table 3 lists every baseline with its citation. Under the same budget, text and JSON memories keep all primary fields in only 16/144 and 10/144 memory-task cells, so the loss tracks capacity rather than representation (Appendix E.4).

Together, these revisions answer every question and resolve every concern raised by the reviewers. The strict audit, autonomous retrieval and the executable rule show that the complete contract recovers, verifies and authorizes exact evidence end to end. The new definitions, ablations and baseline table make the structure and evaluation clear.

We thank all reviewers again for helping us strengthen the end-to-end evidence, the positioning and the presentation of the paper.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.