Paper deep dive

APDMem: Agent-Controlled Progressive Disclosure for Query-Adaptive Long-Term Memory

Chin-Lun Fu, Anagha Kulkarni, Hong Ni, Behrouz Madahian

Year: 2026Venue: arXiv preprintArea: cs.CLType: PreprintEmbeddings: 69

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%

Last extracted: 10/5/2026, 6:13:56 AM

Summary

The paper introduces APDMem, an agent-controlled progressive disclosure memory architecture for personalized LLM assistants. APDMem addresses the challenge of recovering sparse evidence from long conversation histories by organizing memory into four hierarchical layers (thematic summaries, key facts, turn-level notes, raw messages). A controller dynamically drills into these layers based on query complexity, optimizing the trade-off between retrieval cost and evidence fidelity. Experiments on LongMemEval demonstrate that APDMem achieves high accuracy while accessing only 8% of the total conversation data.

Entities (14)

APDMem · system · 100%GPT-4.1 · model · 95%GPT-4.1-mini · model · 95%L0 · memorylayer · 95%L1 · memorylayer · 95%L2 · memorylayer · 95%L3 · memorylayer · 95%LongMemEval · dataset · 95%LightMem · baselinesystem · 90%Mem0 · baselinesystem · 90%Multi-Resolution Memory Substrate · component · 90%Organized Notes Synthesizer · component · 90%Progressive Disclosure Controller · component · 90%SimpleMem · baselinesystem · 90%

Relation Signals (11)

APDMem → accesses → 8% of conversations

confidence 95% · APDMem achieves strong performance for long-context memory reasoning while accessing only 8% of the total conversations.

APDMem → achievesaccuracy → 87.8%

confidence 95% · APDMem reaches 87.8% with GPT-4.1

Multi-Resolution Memory Substrate → containslayer → L1

confidence 95% · L1 contains personalized key facts

Multi-Resolution Memory Substrate → containslayer → L0

confidence 95% · APDMem represents each session as a four-layer memory tuple... L0 contains thematic summaries

Multi-Resolution Memory Substrate → containslayer → L3

confidence 95% · L3 contains raw messages

Multi-Resolution Memory Substrate → containslayer → L2

confidence 95% · L2 contains turn-level evidence notes

APDMem → evaluatedon → LongMemEval

confidence 95% · Experiments on LongMemEval show that APDMem achieves strong performance

APDMem → uses → Multi-Resolution Memory Substrate

confidence 95% · APDMem consists of three components: (1) a Multi-Resolution Memory Substrate that stores each conversation across four layers of increasing abstraction

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Personalized LLM assistants must recover sparse evidence from long conversation histories across queries of varying complexity. We introduce APDMem (Agent-controlled Progressive Disclosure Memory), a hierarchical long-term memory architecture that applies progressive disclosure to memory retrieval. Rather than relying on a flat memory store or fixed retrieval granularity, APDMem represents conversation history as four progressively detailed layers: thematic summaries, personalized key facts, turn-level evidence notes, and raw messages. At inference time, a controller applies progressive disclosure to the memory hierarchy: it first reads high-level summaries and drills into finer evidence only when needed. This creates an adaptive cost-fidelity trade-off: simple queries can terminate early, while complex temporal, multi-hop, or exact-evidence queries trigger deeper inspection. A note synthesizer converts retrieved evidence into a query-focused structure that consolidates facts, orders events, and flags contradictions before final answer generation. Experiments on LongMemEval show that APDMem achieves strong performance for long-context memory reasoning while accessing only 8% of the total conversations.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

66,174 characters extracted from source content.

Expand or collapse full text

APDMem: Agent-Controlled Progressive Disclosure for Query-Adaptive Long-Term Memory Chin-Lun Fu Anagha Kulkarni Hong Ni Behrouz Madahian Affiliation: Machine Learning Center of Excellence, JPMorgan Chase & Co. Affiliation: chin-lun.fu@jpmchase.com, anagha.p.kulkarni@jpmorgan.com Affiliation: hong.ni@jpmchase.com, behrouz.madahian@jpmchase.com Abstract Personalized LLM assistants must recover sparse evidence from long conversation histories across queries of varying complexity. We introduce APDMem (Agent-controlled Progressive Disclosure Memory), a hierarchical long-term memory architecture that applies progressive disclosure to memory retrieval. Rather than relying on a flat memory store or fixed retrieval granularity, APDMem represents conversation history as four progressively detailed layers: thematic summaries, personalized key facts, turn-level evidence notes, and raw messages. At inference time, a controller applies progressive disclosure to the memory hierarchy: it first reads high-level summaries and drills into finer evidence only when needed. This creates an adaptive cost–fidelity trade-off: simple queries can terminate early, while complex temporal, multi-hop, or exact-evidence queries trigger deeper inspection. A note synthesizer converts retrieved evidence into a query-focused structure that consolidates facts, orders events, and flags contradictions before final answer generation. Experiments on LongMemEval show that APDMem achieves strong performance for long-context memory reasoning while accessing only 8% of the total conversations. 1 Introduction Large Language Model (LLM) agents have shown strong performance on complex, multi-step tasks. However, personalized agents must operate across long-term, multi-session interactions, where relevant information may be scattered across many past conversations Xu et al. (2026); Liu et al. (2025); Yu et al. (2026). Such agents must remember user preferences, factual details, temporal sequences, and recurring themes over time Chhikara et al. (2025); Xu et al. (2025); Fang et al. (2026); Liu et al. (2026); Rasmussen et al. (2025). Without effective memory, agents suffer from contextual amnesia: they may fail to recall prior facts, lose track of evolving goals, or overlook cross-session connections. Prior works on memory systems improve long-term recall by transforming conversation history into specialized representations: MemoryBank uses a structured memory store for personalized dialogue Zhong et al. (2024); MemGPT manages information via virtual context and external memory Packer et al. (2024); A-MEM builds interconnected, evolving memory networks Xu et al. (2025); and Zep constructs temporal, entity-centric memory graphs Rasmussen et al. (2025). Other systems reduce cost through compression or consolidation: LightMem uses staged memory processing Fang et al. (2026), while SimpleMem retrieves over compact semantic memories Liu et al. (2026). While these designs reduce retrieval cost, they also introduce additional memory machinery and require committing conversational context to external memory stores, graph nodes, or other abstractions. We introduce APDMem (Agent-controlled Progressive Disclosure Memory), a hierarchical memory system for efficient context recall in personalized agents. APDMem treats long-term memory access as a query-adaptive disclosure problem rather than a one-shot retrieval problem. Inspired by progressive disclosure Nielsen (1993), it exposes coarse information first and reveals finer evidence as needed. APDMem stores conversations as lightweight Markdown layers—thematic summaries (L0L_0), personalized key facts (L1L_1), turn-level evidence notes (L2L_2), raw messages (L3L_3)—rather than converting them into a specialized database, graph, or compressed-only representation. Unlike existing systems that fix the retrieved representation in advance, APDMem only materializes thematic summaries at ingestion time while preserving raw messages underneath. At inference time, the Progressive Disclosure Controller expands on demand into finer details like personalized key facts, turn-level evidence notes, or raw messages. After sufficient evidence is collected, the controller drafts an answer. For final answer generation, Organized Notes Synthesizer structures the evidence retrieved by the controller along with the draft answer into organized notes. These notes consolidate relevant evidence, align it with the query and provide the answer generator with structured grounding context instead of raw retrieved snippets, reducing noise and improving answer accuracy. APDMem frames long-term memory retrieval as a query-adaptive disclosure problem: it must determine which conversations matter and how much detail to expose. Concretely, APDMem introduces two coupled dimensions: (1) hierarchical memory organization (coarse summaries linked to finer-grained evidence) and (2) progressive disclosure as an explicit architectural principle governing how that hierarchy is accessed. That is, the agent is designed to open only the minimum memory level required, exposing coarse views first and revealing finer evidence only when needed, with the disclosure depth controlled through tool-mediated interactions. Our primary contributions are: • Coarse-to-fine memory formulation. We introduce a Multi-Resolution Memory Substrate that preserves raw messages beneath progressively abstract memory layers. • Agent-controlled query-adaptive memory disclosure. We introduce a Progressive Disclosure Controller that decomposes queries, handles temporal constraints, and drills into deeper memory layers when needed. • Organized Notes for grounded generation. We introduce an Organized Notes Synthesizer that grounds retrieved evidence and the controller’s draft answer into structured notes. • LongMemEval validation. We show that APDMem achieves strong performance on LongMemEval Wu et al. (2025) while accessing only 8% of the conversations. 2 Related Work 2.1 Memory Representations for LLM Agents Personalized agents require persistent memory to maintain continuity across interactions Zhang et al. (2026); Xu et al. (2026). Prior works frame this as a long-term memory problem: agents must retain user-specific facts and temporal context across sessions to avoid contextual amnesia Chhikara et al. (2025); Fang et al. (2026); Liu et al. (2026). Memory systems differ mainly in how they represent past interactions. Profile- or fact-based methods store distilled user information Zhong et al. (2024); Chhikara et al. (2025); episodic systems retrieve prior interaction traces Packer et al. (2024); Xu et al. (2025); graph-based systems such as Zep organize temporal entity-relation memories Rasmussen et al. (2025); and compression-based systems such as LightMem and SimpleMem reduce cost through staged consolidation or compact semantic memories Fang et al. (2026); Liu et al. (2026). These approaches often require graph conversion, compression, or specialized memory objects, creating trade-offs between efficiency, fidelity, and complexity. APDMem instead stores conversations as transparent Markdown layers preserving the original conversation while providing compact abstractions for retrieval. Figure 1: APDMem overview. The Multi-Resolution Memory Substrate stores conversations as layered views from thematic summaries (L0L_0) to raw messages (L3L_3). The Progressive Disclosure Controller uses tool calls to retrieve and drill down only as needed. The Organized Notes Synthesizer then consolidates collected evidence into structured notes for grounded answer generation. The upper-right panel summarizes tools available to the controller. 2.2 Progressive Disclosure Memory systems organize information at different granularities—such as summaries, passages, chunks, or episodic traces—to improve retrieval over large contexts Sarthi et al. (2024); Gao et al. (2023); Izacard and Grave (2021); Khattab and Zaharia (2020); Lewis et al. (2020); Asai et al. (2024); Trivedi et al. (2023). APDMem builds on this idea through progressive disclosure Nielsen (1993), exposing coarse memory views first and revealing finer evidence only when needed. To our knowledge, APDMem is the first system to make progressive disclosure an explicit architectural principle for agent memory, with an agent controlling disclosure depth through tool-mediated interactions. 2.3 Evidence-Grounded Generation Complex queries involving temporal constraints, ambiguous references, user-specific details, multi-hop reasoning, or enumeration often require iterative retrieval and verification Yao et al. (2023); Schick et al. (2023); Press et al. (2023); Trivedi et al. (2023). Prior work has shown the value of organizing or reasoning over retrieved evidence before answer generation Yu et al. (2024); Gao et al. (2023); Asai et al. (2024). Inspired by Chain-of-Note Yu et al. (2024), APDMem converts retrieved evidence into organized notes that consolidate relevant facts, temporal order, contradictions, enumeration evidence, and answer hints into a structured grounding context for the answer generator. 3 APDMem As shown in Figure 1, APDMem consists of three components: (1) a Multi-Resolution Memory Substrate that stores each conversation across four layers of increasing abstraction (§3.1); (2) a Progressive Disclosure Controller that searches, drills into, and reflects over the memory hierarchy through tool-mediated interactions (§3.2); and (3) an Organized Notes Synthesizer that structures retrieved evidence for final answer generation (§3.3). 3.1 Multi-Resolution Memory Substrate Given a conversation history, we partition it into N sessions =S1,…,SNS=S_1,…,S_N, where each session SiS_i is a contiguous conversation episode consisting of turns, and each turn is a user–assistant exchange. APDMem represents each session as a four-layer memory tuple, Si=(L0,L1,L2,L3)S_i=(L_0,L_1,L_2,L_3). L0L_0 contains thematic summaries with resolved pronouns, normalized dates, keywords, and tags, and serves as the primary indexing layer. L1L_1 contains personalized key facts: session facts about user information, recommendations, plans, preferences, and constraints. L2L_2 contains turn-level evidence notes: turn-level factual bullets that preserve temporal order for fine-grained evidence reasoning. L3L_3 contains raw messages: the verbatim user--assistant messages retained for exact evidence recovery.11 1 Construction details, prompts, and real output examples for each layer are provided in Appendix I. Lazy materialization. Only L0L_0 and L3L_3 are materialized at ingestion time, whereas L1L_1 and L2L_2 are generated on demand when first requested by the progressive disclosure controller and then cached for reuse, reducing write-time cost. 3.2 Progressive Disclosure Controller The Progressive Disclosure Controller implements memory access as a bounded, query-adaptive control process. Given a query q, the controller’s objective is to gather sufficient evidence for answering q while avoiding unnecessary disclosure of finer memory. It maintains an evidence set tV_t at step t. Each element in V is a retrieved view of a session SiS_i at abstraction level LℓL_ for ℓ∈0,1,2,3 ∈\0,1,2,3\. At each step, the controller selects a tool action at∈a_t , where =search,read_facts,read_turns,read_raw,interpret_dates,decompose,reflectA=\ search, read\_facts,\\ read\_turns, read\_raw, interpret\_dates,\\ decompose, reflect\ is the action space. Memory-read actions correspond to different resolutions of the Multi-Resolution Memory Substrate: finer layers expose higher-fidelity evidence but incur greater token and latency cost, i.e., c⁡(L0)<c⁡(L1)<c⁡(L2)<c⁡(L3)c(L_0)<c(L_1)<c(L_2)<c(L_3) and f⁡(L0)<f⁡(L1)<f⁡(L2)<f⁡(L3)f(L_0)<f(L_1)<f(L_2)<f(L_3), where c⁡(⋅)c(·) denotes access cost and f⁡(⋅)f(·) denotes evidence fidelity. The controller can therefore be viewed as optimizing a cost–fidelity trade-off: mina1:T∑t=1Tc(at)s.t.sufficient(T,q)=1, _a_1:T _t=1^Tc(a_t) .t. (V_T,q)=1, (1) where sufficient⁡(T,q)sufficient(V_T,q) indicates whether the collected evidence is adequate for answering the query. In practice, sufficiency is estimated through evidence reflection and bounded by the convergence criteria described in §3.2.2. Unlike flat retrieval systems, APDMem selects both the relevant memory region and the required evidence resolution. Backbone Method Temp. Multi-S. K-Upd. S-User S-Asst. S-Pref. Avg. GPT-4.1 Full-context∗ 51.9 39.1 70.5 65.7 96.4 16.7 56.7 Mem0∗ 43.6 54.9 75.6 54.3 39.3 83.3 58.5 RAPTOR† 38.4 51.9 68.0 95.7 92.9 60.0 62.0 LightMem∗ 85.0 57.9 89.7 87.1 71.4 70.0 76.9 SimpleMem∗ 86.5 81.2 80.8 98.6 76.8 80.0 84.0 APDMem† 90.2 77.4 91.0 92.9 100.0 80.0 87.8 GPT-4.1-mini Full-context∗ 27.1 30.1 41.0 47.1 32.1 60.0 39.6 Mem0∗ 40.6 50.4 69.2 87.1 48.2 63.3 59.8 RAPTOR† 38.4 55.6 69.2 90.0 98.2 66.7 63.4 LightMem∗ 85.7 47.4 92.3 88.6 21.4 76.7 68.7 SimpleMem∗ 83.5 60.9 79.5 85.7 75.0 76.7 76.9 APDMem† 77.4 66.2 85.9 91.4 96.4 76.7 79.8 † denotes experiments run by us; ∗ denotes prior results from Liu et al. (2026), reported under a unified protocol that we also follow for fair comparison. Table 1: Performance (% accuracy) on LongMemEval-S (n=500n=500). The highest value in each column is shown in bold; the second highest is underlined. 3.2.1 Controller Workflow A typical trajectory proceeds in three phases. Query preparation. Queries with relative dates (e.g., “last summer”) are normalized against the question timestamp via interpret_dates; multi-hop or compound queries are split into focused subqueries via decompose. Progressive disclosure. search retrieves the top-K candidate sessions over L0L_0 (hybrid lexical + dense retrieval fused with RRF; Appendix G). An auto-drill step selects the most promising unexplored sessions and read_facts retrieves their L1L_1 key facts. If these facts are insufficient, the controller descends further: read_turns surfaces L2L_2 evidence in temporal order, and read_raw retrieves L3L_3 messages restricted to the most relevant turns within selected sessions. At each step, retrieved session information is stored in evidence set V. Reflection and drafting. APDMem uses reflection Yao et al. (2023); Shinn et al. (2023) to avoid both premature answering and unbounded search. reflect summarizes V, identifies missing evidence, and assesses whether additional retrieval is likely to help. If more evidence is needed, it proposes follow-up queries and the controller re-enters the progressive disclosure phase. Once V converges (§3.2.2), the controller produces a draft answer adrafta_draft from the final evidence set TV_T, which is then passed to the Organized Notes Synthesizer. 3.2.2 Convergence Control The controller loop terminates when (1) reflection finds no new evidence, |t|=|t−1||V_t|=|V_t-1|, or (2) step budget TmaxT_ is reached. TmaxT_ caps the maximum number of controller iterations and therefore bounds the additional tool calls the controller can make before it must stop escalating and return the best available answer.22 2 In all experiments, we set Tmax=20T_ =20. Appendix D reports the observed iteration distribution and discusses how to choose TmaxT_ for other applications. 3.3 Organized Notes Synthesizer The Organized Notes Synthesizer converts the query q, evidence set V, and controller’s draft answer adrafta_draft into organized notes, a compact intermediate representation. Inspired by Chain-of-Note Yu et al. (2024), this step uses the draft to verify, correct, or supplement the controller’s initial reasoning. These notes organize relevant facts, temporal ordering, contradictions, enumeration evidence for counting queries, and an answer hint into a query-focused grounding context. Answer generation. The answer generator receives the organized notes and adrafta_draft to produce the final response. This synthesize-then-generate design preserves the controller’s retrieval trajectory while allowing the final answer to correct errors or omissions surfaced during evidence synthesis. 4 Experiments Experimental Setup. We evaluate on LongMemEval Wu et al. (2025) (specifically the LongMemEval-S split): 500 questions across six categories (Table 1 column headers), each paired with a per-question session haystack. We compare against Full-context (no retrieval), Mem0 Chhikara et al. (2025), LightMem Fang et al. (2026), and SimpleMem Liu et al. (2026). To ensure strict comparability, all baseline numbers are taken from Liu et al. (2026), and APDMem reuses the identical answer-generator prompt (Figure 10) and LLM-as-a-judge (GPT-4.1-mini, temp=0.0temp=0.0).33 3 Following Fang et al. (2026); Liu et al. (2026), all numbers are with decoding temperature fixed at 0.0. APDMem and each baseline are evaluated with GPT-4.1 and GPT-4.1-mini as backbones; for APDMem, a single backbone drives the Progressive Disclosure Controller, and the Organized Notes Synthesizer.44 4 Full implementation details and hyperparameters are provided in Appendix B, C, and G. 4.1 Main Experiments Table 1 presents the main results. APDMem reaches 87.8% with GPT-4.1 and 79.8% with GPT-4.1-mini, ahead of the best prior baseline (SimpleMem) by 3.8 and 2.9 points respectively. The gains are clearest on detail-oriented queries. For example, on S-Asst, APDMem reaches 100.0% with GPT-4.1, surpassing SimpleMem (76.8%) and Full-context (96.4%) while inspecting only a small slice of the haystack (§4.3). This highlights the value of drilling to raw turns. APDMem remains strong on multi-session synthesis with GPT-4.1, scoring 77.4%, though SimpleMem is higher at 81.2%. This reflects a breadth-depth trade-off: flat summary retrieval can expose more sessions per call, while APDMem investigates top-ranked candidates in greater detail. Notably, this is not a systematic weakness: with GPT-4.1-mini, APDMem achieves the best multi-session score, showing that targeted memory navigation can also benefit multi-session reasoning. 4.2 Inference Efficiency We decompose cost into offline (one-time L0L_0 construction) and online (per-query controller cost, including on-demand L1L_1/L2L_2 generation). Following Fang et al. (2026), (a) all systems use GPT-4o-mini, (b) the shared answer generator is excluded from online cost, and (c) numbers are per-question averages on LongMemEval (n=500n=500). Prior work reports only baseline construction cost, so online cost is available only for APDMem; baseline online cost is marked unavailable (-) in Table 2.55 5 See Appendix H for a per-backbone breakdown. Offline (Construction) Online (Controller) Method ACC Tok. (k) Lat. (s) Tok. (k) Lat. (s) Mem0 53.6 1,152.6 4,248.5 – A-MEM 62.6 1,605.8 5,132.1 – LightMem 68.6 28.3 283.8 – APDMem 74.4 145.4 101.5 124.3 37.7 Table 2: Efficiency on LongMemEval-S (GPT-4o-mini). Offline: memory construction; Online: controller cost (cold start: no cached state for L1L_1 & L2L_2). Baselines from Fang et al. (2026) (no online numbers available). Table 2 compares APDMem with two classes of prior memory systems. Update-heavy methods such as Mem0 and A-MEM rely on iterative memory maintenance or consolidation, incurring million-token and multi-thousand-second construction costs; APDMem uses roughly one-tenth of their offline token budget and a small fraction of their latency. By contrast, LightMem reduces offline tokens through query-agnostic pre-compression, which can discard fine-grained details. APDMem offers a practical efficiency–accuracy trade-off: it avoids the high overhead of update-heavy systems while reducing reliance on aggressive compression, with minimal latency. Figure 2: Progressive disclosure behavior (GPT-4.1). (a) Retrieval selectivity: fraction of haystack sessions drilled per category. (b) Disclosure depth distribution across memory levels. (c) Error decomposition (retrieval vs. generation) for GPT-4.1-mini and GPT-4.1. 4.3 Effectiveness of Progressive Disclosure We analyze whether progressive disclosure achieves its design goal: locating relevant evidence with minimal memory access. Unless stated otherwise, statistics use the GPT-4.1 configuration; the error decomposition additionally contrasts GPT-4.1-mini with GPT-4.1 to study how backbone strength affects retrieval versus generation failures. Retrieval selectivity. Figure 2(a) shows that the controller drills into only 8% of the haystack on average (3.7 out of 47.7 sessions per question). Single-session categories are the most selective (S-Asst.: 2%, S-User: 6%), while multi-session questions require broader access (12%). Despite this selectivity, APDMem achieves 87.8% overall accuracy, confirming that the Progressive Disclosure Controller enables precise evidence identification without exhaustive search. Disclosure depth distribution. Figure 2(b) shows that the controller usually stops shallow: among 1,8381,838 drills, 73.7% terminate at L1L_1, 20.2% descend to L3L_3, and 6.1% stop at L2L_2. Depth varies by question type: single-session queries use L3L_3 most often (S-Asst. 40.7%, S-User 35.8%) because they often require exact phrasing, whereas multi-session and knowledge-update queries remain mostly shallow (L3L_3 rates of 15.2% and 9.9%). This demonstrates that the controller adapts disclosure depth to evidence demand rather than using a fixed retrieval granularity. Controller Generator Avg. Acc. (%) GPT-4.1-mini GPT-4.1-mini 79.8 GPT-4.1 GPT-4.1-mini 86.8 GPT-5.2 GPT-4.1-mini 87.8 Table 3: Effect of controller backbone strength with a fixed generator on LongMemEval-S. Error decomposition. Using gold session annotations, we classify predictions by Correct Retrieval and Correct Generation. Figure 2(c) shows that scaling the backbone primarily reduces retrieval errors (22.2% → 10.6%), while generation errors remain near 8–10%, making evidence discovery the main bottleneck. This is confirmed by Table 3: with the generator fixed to GPT-4.1-mini, upgrading only the controller raises accuracy from 79.8% to 86.8%, and a GPT-5.2 controller reaches 87.8%. Thus, APDMem enables heterogeneous deployment: when model budget is limited, capacity can be allocated to the controller, where the dominant bottleneck lies, while a lightweight model serves as the generator. 4.4 Ablation Studies We ablate three aspects of APDMem on GPT-4.1 in Table 4: the controller, memory levels, and reasoning tools. To further disentangle the effect of hierarchical memory from agentic control, we additionally include a vanilla RAG (L3L_3-only) baseline, which removes both the controller and the hierarchy and retrieves directly from raw messages. A complementary ablation of the Organized Notes Synthesizer is reported in Appendix J. Configuration Avg. Acc. (%) Diff APDMem 87.8 — Vanilla RAG (L3L_3-only) 77.0 ↓ 12.3% Controller ablation w/o Controller† 83.2 ↓ 5.2% Memory hierarchy ablations w/o read_facts (L1L_1) 84.6 ↓ 3.6% w/o read_turns (L2L_2) 87.4 ↓ 0.5% w/o read_raw (L3L_3) 82.6 ↓ 5.9% Reasoning tool ablations w/o reflect 84.6 ↓ 3.6% w/o decompose 86.0 ↓ 2.1% w/o interpret_dates 87.6 ↓ 0.2% †RAG retrieves top-K L0L_0 sessions; same sessions are populated in L1L_1–L3L_3 Table 4: Ablation on memory hierarchy levels and reasoning tools (GPT-4.1). The “Diff” column is the percentage drop with respect to APDMem. Case 1: Multi-hop across sessions Q: “How old was I when Alex was born?” (gold: 11) Find first fact. search(L0L_0, “Alex birth year”) → S9; read_facts(L1L_1, S9) → “Alex is 21” Identify missing evidence. reflect(): need user’s age. Find second fact. search(L0L_0, “my age in 2023”) → S20; read_facts(L1L_1, S20) → “User turned 32 in 2023-04” Draft and verify. Draft: 32−21=1132-21=11. reflect(): verify with broader search. search(L0L_0, “family timeline”) → S0, S16, S38, S33; read_facts(L1L_1): no new evidence. Converge. reflect(): sufficient → Final answer: 11 ✓ Only L1L_1 evidence read; 6 sessions drilled. Case 2: Verbatim recall within a session Q: “Orlando dessert shop with giant milkshakes?” (gold: Sugar Factory at Icon Park) Locate candidate session. search(L0L_0, “Orlando giant milkshakes”) → S10; read_facts(L1L_1, S10) → topic ✓, no shop name. Drill for finer evidence. read_turns(L2L_2, S10) → relevant turn, still no exact name. Recover verbatim detail. read_raw(L3L_3, S10, “milkshakes”) → “Sugar Factory at Icon Park” Converge. Final answer: Sugar Factory at Icon Park ✓ Descends L1→L2→L3L_1\!→\!L_2\!→\!L_3 in 1 session. Figure 3: Two representative APDMem traces. Case 1 answers a cross-session multi-hop question using only L1L_1 facts, with reflect driving evidence-gathering and convergence. Case 2 answers a within-session verbatim question by descending the hierarchy from L1L_1 to L3L_3. The two cases highlight the breadth-vs.-depth behavior enabled by the controller. Results. Three trends emerge, with drops reported relative to APDMem. (i) Controller and hierarchy: replacing the controller with a non-agentic RAG baseline while preserving the L0L_0–L3L_3 hierarchy reduces accuracy from 87.8% to 83.2%, corresponding to a 5.2% relative drop. This shows that query-adaptive drilling and reflection add value over static retrieval. The vanilla RAG (L3L_3-only) baseline further removes the hierarchy and retrieves only from raw messages (L3L_3), reducing accuracy to 77.0%, corresponding to a larger 12.3% relative drop. This comparison separates the contribution of the two components: the controller improves over hierarchical RAG, while the hierarchy itself provides a substantial gain over raw-message retrieval. (i) Memory levels: key facts (L1L_1, ↓ 3.6%) and raw messages (L3L_3, ↓ 5.9%) cause the largest accuracy drops, consistent with APDMem’s broad-shallow and narrow-deep retrieval patterns. Turn-level evidence notes (L2L_2, ↓ 0.5%) have a smaller aggregate effect, serving primarily as an intermediate evidence layer. (i) Reasoning tools: reflection contributes most (↓ 3.6%), followed by decomposition (↓ 2.1%); date interpretation has little effect (↓ 0.2%), likely because the backbone model already handles many temporal cues. 4.5 Case Studies Figure 3 shows two representative LongMemEval traces illustrating how APDMem performs progressive disclosure in different scenarios. Case 1. The first retrieved session provides Alex’s age but not the user’s age, so reflect identifies the missing evidence and triggers a second search. After deriving the draft answer, a broader L1L_1 check over four additional sessions finds no new evidence, allowing the controller to converge without descending to L2L_2 or L3L_3. Case 2. The controller first localizes the relevant Orlando session, but L1L_1 only confirms the topic and does not preserve the specific shop name. APDMem therefore drills progressively: L2L_2 narrows the evidence region, and L3L_3 recovers the verbatim detail needed for the final answer. These traces illustrate APDMem’s adaptive behavior: the controller expands across sessions when evidence is scattered, but descends within a session when the answer depends on fine-grained details. 5 Conclusion We present APDMem, a lightweight hierarchical memory architecture that frames long-term memory access as a query-adaptive disclosure problem. A controller first reads coarse abstractions and drills into finer-grained evidence only when needed, while a notes synthesizer organizes the surfaced evidence for grounded answer generation. On LongMemEval, APDMem achieves a substantial improvement over prior work, reaching 87.8% accuracy with GPT-4.1. Our key findings are: (i) disclosure depth adapts to question type, with most questions answered from the high-level key-fact layer, while certain detail-oriented question categories benefit from raw-message access; (i) controller ablations show that agent-controlled progressive disclosure is a significant contributor to performance; and (i) APDMem offers a practical efficiency–accuracy trade-off, balancing token cost and latency while maintaining strong answer accuracy. Limitations APDMem’s retrieval recall depends on the quality of the L0L_0 thematic summaries: if a summary omits a relevant detail, the corresponding turn may receive lower BM25 and dense-retrieval scores. The keyword-field boost (Appendix G) and the controller’s reflect tool provide partial recovery mechanisms, but initial ranking remains sensitive to summary fidelity. To this end, developing a systematic summary-quality evaluation and monitoring for L0L_0 is a natural and important direction for future work. As one potential mitigation, summary quality can be assessed using an LLM-as-a-judge style evaluation (e.g., checking faithfulness and coverage against the underlying raw messages). Lazy materialization of L1L_1 and L2L_2 may introduce cold-start latency when a session is accessed for the first time. To mitigate first-access latency, L1L_1 and L2L_2 can be proactively materialized (e.g., offline or in the background). That said, our design intentionally follows progressive disclosure and lazy materialization: precomputing everything can be unnecessarily costly when many sessions (and fine-grained layers) are never queried. In production, this becomes an explicit cost–latency trade-off: deployments that prioritize low tail-latency can pre-warm likely-to-be-accessed sessions, while cost-sensitive settings can keep on-demand generation to minimize wasted computation. Finally, APDMem does not explicitly model cross-session relationships in the way graph-based memory structures can. Exploring lightweight mechanisms for cross-session linking is a promising direction for future work. Disclaimer This paper was prepared for informational purposes in part by the Machine Learning Center of Excellence group of JPMorgan Chase & Co. and its affiliates (“JP Morgan”) and is not a product of the Research Department of JP Morgan. JP Morgan makes no representation and warranty whatsoever and disclaims all liability, for the completeness, accuracy or reliability of the information contained herein. This document is not intended as investment research or investment advice, or a recommendation, offer or solicitation for the purchase or sale of any security, financial instrument, financial product or service, or to be used in any way for evaluating the merits of participating in any transaction, and shall not constitute a solicitation under any jurisdiction or to any person, if such solicitation under such jurisdiction or to such person would be unlawful. References Asai et al. (2024) A. Asai, Z. Wu, Y. Wang, A. Sil, and H. Hajishirzi Self-RAG: learning to retrieve, generate, and critique through self-reflection. In The Twelfth International Conference on Learning Representations, External Links: Link Cited by: §2.2, §2.3. Chhikara et al. (2025) P. Chhikara, D. Khant, S. Aryan, T. Singh, and D. Yadav Mem0: building production-ready ai agents with scalable long-term memory. arXiv preprint arXiv:2504.19413. External Links: Link Cited by: §1, §2.1, §4. Cormack et al. (2009) G. V. Cormack, C. L. Clarke, and S. Buettcher 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, p. 758–759. Cited by: Appendix G. Fang et al. (2026) J. Fang, X. Deng, H. Xu, Z. Jiang, Y. Tang, Z. Xu, S. Deng, Y. Yao, M. Wang, S. Qiao, H. Chen, and N. Zhang LightMem: lightweight and efficient memory-augmented generation. In The Fourteenth International Conference on Learning Representations, External Links: Link Cited by: §1, §1, §2.1, §4, §4.2, Table 2, footnote 3. Gao et al. (2023) Y. Gao, Y. Xiong, X. Gao, K. Jia, J. Pan, Y. Bi, Y. Dai, J. Sun, M. Wang, and H. Wang Retrieval-augmented generation for large language models: a survey. arXiv preprint arXiv:2312.10997. External Links: Link Cited by: §2.2, §2.3. Izacard and Grave (2021) G. Izacard and E. Grave Leveraging passage retrieval with generative models for open domain question answering. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, P. Merlo, J. Tiedemann, and R. Tsarfaty (Eds.), Online, p. 874–880. External Links: Link, Document Cited by: §2.2. Khattab and Zaharia (2020) O. Khattab and M. Zaharia ColBERT: efficient and effective passage search via contextualized late interaction over bert. In Proceedings of the 43rd International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’20, New York, NY, USA, p. 39–48. External Links: ISBN 9781450380164, Link, Document Cited by: §2.2. Lewis et al. (2020) P. Lewis, E. Perez, A. Piktus, F. Petroni, V. Karpukhin, N. Goyal, H. Küttler, M. Lewis, W. Yih, T. Rocktäschel, S. Riedel, and D. Kiela Retrieval-augmented generation for knowledge-intensive nlp tasks. In Advances in Neural Information Processing Systems, H. Larochelle, M. Ranzato, R. Hadsell, M.F. Balcan, and H. Lin (Eds.), Vol. 33, p. 9459–9474. External Links: Link Cited by: §2.2. Liu et al. (2025) D. Liu, Z. Wu, D. Song, and H. Huang A persona-aware LLM-enhanced framework for multi-session personalized dialogue generation. In Findings of the Association for Computational Linguistics: ACL 2025, W. Che, J. Nabende, E. Shutova, and M. T. Pilehvar (Eds.), Vienna, Austria, p. 103–123. External Links: Link, Document, ISBN 979-8-89176-256-5 Cited by: §1. Liu et al. (2026) J. Liu, Y. Su, P. Xia, S. Han, Z. Zheng, C. Xie, M. Ding, and H. Yao SimpleMem: efficient lifelong memory for llm agents. External Links: 2601.02553, Link Cited by: §1, §1, §2.1, Table 1, §4, footnote 3. Nielsen (1993) J. Nielsen Usability engineering. Morgan Kaufmann, San Francisco, CA. External Links: ISBN 978-0125184069 Cited by: §1, §2.2. Packer et al. (2024) C. Packer, S. Wooders, K. Lin, V. Fang, S. G. Patil, I. Stoica, and J. E. Gonzalez MemGPT: towards llms as operating systems. External Links: 2310.08560, Link Cited by: §1, §2.1. Press et al. (2023) O. Press, M. Zhang, S. Min, L. Schmidt, N. Smith, and M. Lewis Measuring and narrowing the compositionality gap in language models. In Findings of the Association for Computational Linguistics: EMNLP 2023, H. Bouamor, J. Pino, and K. Bali (Eds.), Singapore, p. 5687–5711. External Links: Link, Document Cited by: §2.3. Rasmussen et al. (2025) P. Rasmussen, P. Paliychuk, T. Beauvais, J. Ryan, and D. Chalef Zep: a temporal knowledge graph architecture for agent memory. arXiv preprint arXiv:2501.13956. External Links: Link Cited by: §1, §1, §2.1. Sarthi et al. (2024) P. Sarthi, S. Abdullah, A. Tuli, S. Khanna, A. Goldie, and C. D. Manning RAPTOR: recursive abstractive processing for tree-organized retrieval. In The Twelfth International Conference on Learning Representations, External Links: Link Cited by: §2.2. Schick et al. (2023) T. Schick, J. Dwivedi-Yu, R. Dessi, R. Raileanu, M. Lomeli, E. Hambro, L. Zettlemoyer, N. Cancedda, and T. Scialom Toolformer: language models can teach themselves to use tools. In Advances in Neural Information Processing Systems, A. Oh, T. Naumann, A. Globerson, K. Saenko, M. Hardt, and S. Levine (Eds.), Vol. 36, p. 68539–68551. External Links: Document, Link Cited by: §2.3. Shinn et al. (2023) N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao Reflexion: language agents with verbal reinforcement learning. In Advances in Neural Information Processing Systems, A. Oh, T. Naumann, A. Globerson, K. Saenko, M. Hardt, and S. Levine (Eds.), Vol. 36, p. 8634–8652. External Links: Document, Link Cited by: §3.2.1. Trivedi et al. (2023) H. Trivedi, N. Balasubramanian, T. Khot, and A. Sabharwal Interleaving retrieval with chain-of-thought reasoning for knowledge-intensive multi-step questions. In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), A. Rogers, J. Boyd-Graber, and N. Okazaki (Eds.), Toronto, Canada, p. 10014–10037. External Links: Link, Document Cited by: §2.2, §2.3. Wu et al. (2025) D. Wu, H. Wang, W. Yu, Y. Zhang, K. Chang, and D. Yu LongMemEval: benchmarking chat assistants on long-term interactive memory. In The Thirteenth International Conference on Learning Representations, External Links: Link Cited by: 4th item, §4. Xu et al. (2025) W. Xu, Z. Liang, K. Mei, H. Gao, J. Tan, and Y. Zhang A-mem: agentic memory for llm agents. In Advances in Neural Information Processing Systems, D. Belgrave, C. Zhang, H. Lin, R. Pascanu, P. Koniusz, M. Ghassemi, and N. Chen (Eds.), Vol. 38, Main Conference, p. 17577–17604. External Links: Document, Link Cited by: §1, §1, §2.1. Xu et al. (2026) Y. Xu, Q. Chen, Z. Ma, D. Liu, W. Wang, X. Wang, L. Xiong, and W. Wang Toward personalized llm-powered agents: foundations, evaluation, and future directions. arXiv preprint arXiv:2602.22680. External Links: Link Cited by: §1, §2.1. Yao et al. (2023) S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. R. Narasimhan, and Y. Cao ReAct: synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations, External Links: Link Cited by: §2.3, §3.2.1. Yu et al. (2024) W. Yu, H. Zhang, X. Pan, P. Cao, K. Ma, J. Li, H. Wang, and D. Yu Chain-of-note: enhancing robustness in retrieval-augmented language models. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, Y. Al-Onaizan, M. Bansal, and Y. Chen (Eds.), Miami, Florida, USA, p. 14672–14685. External Links: Link, Document Cited by: §2.3, §3.3. Yu et al. (2026) Y. Yu, L. Yao, Y. Xie, Q. Tan, J. Feng, Y. Li, and L. Wu Agentic memory: learning unified long-term and short-term memory management for large language model agents. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), M. Liakata, V. P. Moreira, J. Zhang, and D. Jurgens (Eds.), San Diego, California, United States, p. 21457–21483. External Links: Link, Document, ISBN 979-8-89176-390-6 Cited by: §1. Zhang et al. (2026) W. Zhang, X. Zhang, C. Zhang, L. Yang, J. Shang, Z. Wei, H. P. Zou, Z. Huang, Z. Wang, Y. Gao, X. Pan, L. Xiong, J. Liu, P. S. Yu, and X. Li PersonaAgent: bridging memory and action for personalized LLM agents. In Findings of the Association for Computational Linguistics: ACL 2026, M. Liakata, V. P. Moreira, J. Zhang, and D. Jurgens (Eds.), San Diego, California, United States, p. 26421–26439. External Links: Link, Document, ISBN 979-8-89176-395-1 Cited by: §2.1. Zhong et al. (2024) W. Zhong, L. Guo, Q. Gao, H. Ye, and Y. Wang Memorybank: enhancing large language models with long-term memory. In Proceedings of the AAAI conference on artificial intelligence, Vol. 38, p. 19724–19731. External Links: Document Cited by: §1, §2.1. Appendix A Progressive Disclosure Controller Algorithm Algorithm 1 summarizes the iterative protocol of progressive disclosure controller. Appendix B System Prompts This appendix provides all system prompts used in APDMem. Figures 4–6 show the memory construction prompts for L0L_0 - L2L_2; Figures 7–10 show the controller, evidence reflection, organized notes synthesis, and answer generation prompts. Memory construction prompts. All three construction prompts (Figures 4–6) enforce semantic disambiguation: pronouns are resolved to named entities and relative dates are converted to absolute dates using the session timestamp as anchor. Algorithm 1 Progressive Disclosure Controller 1: Query q, timestamp d, memory S, max steps TmaxT_ 2: 0←∅V_0← ; nudges ←0← 0 3: for t=1t=1 to TmaxT_ do 4: response ← LLM(q,d,t−1V_t-1,A) 5: if response contains tool calls then 6: t←t−1V_t _t-1 7: for all tool call τ in response do 8: t←t∪Execute(τ)V_t _t∪ Execute(τ) 9: end for 10: else if |t−1||V_t-1| grew since last reflection and nudges <2<2 then 11: Inject nudge message; nudges ← nudges +1+1 12: t←t−1V_t _t-1 13: else 14: adraft←a_draft← response 15: return adraft,t−1a_draft,V_t-1 16: end if 17: end for 18: return adraft,Tmaxa_draft,V_T_ ⬇ You are a memory-indexing assistant. For each user<->assistant turn in the conversation, produce: 1. A 1-sentence summary (max 30 words). 2. keywords (5-8): specific names, items, dates, locations, actions mentioned. 3. tags (3-5): broader category labels. Rules: - NO pronouns -- use actual names/entities. - NO relative dates -- convert to absolute dates using the [Session date] anchor. - Each summary must be self-contained. Session date: session_date [conversation window] Return JSON: "turns": ["turn_number": 1, "summary": "...", "keywords": ["kw1", ...], "tags": ["tag1", ...], ...] Figure 4: Prompt for L0L_0 turn summary and keyword generation (§3.1). ⬇ You are a memory-management assistant. Given a conversation between a user and an assistant, extract a bullet list of key facts, events, preferences, and knowledge mentioned. Semantic Disambiguation Rules (CRITICAL): 1. PROHIBIT all pronouns (he, she, it, they). Always use the actual person/item name. 2. PROHIBIT relative time expressions. Convert ALL time references to absolute dates using the [Session date] anchor. 3. Each bullet must be a complete, self-contained, lossless restatement understandable without the conversation. 4. Include specific: dates, person names, item names, locations, quantities, preferences. 5. Do NOT omit any factual information. Return ONLY the bullet list (use "- " prefix). Aim for 5-25 bullets depending on richness. Figure 5: Prompt for L1L_1 key fact extraction (§3.1). ⬇ You are a memory-management assistant. Given a conversation between a user and an assistant, produce per-turn atomic memory entries -- multiple self-contained fact bullets for each user<-> assistant exchange (turn). Semantic Disambiguation Rules (CRITICAL): 1. PROHIBIT all pronouns (he, she, it, they). Always use the actual person/item name. 2. PROHIBIT relative time expressions. Convert ALL time references to absolute dates using the [Session date] anchor. 3. Each bullet must be a complete, independent, lossless restatement -- a single atomic fact fully understandable without other context. 4. Include specific: dates, person names, item names, locations, quantities, preferences. 5. Do NOT merge multiple facts into one bullet. Output format: Turn 1: - <atomic fact 1> - <atomic fact 2> Turn 2: - <atomic fact 1> - <atomic fact 2> Figure 6: Prompt for L2L_2 turn-level evidence generation (§3.1). Retrieval and reasoning prompts. The controller (Figure 7) operates the progressive disclosure loop, selecting tools based on question type and evidence sufficiency. The reflection prompt (Figure 8) performs structured gap analysis and generates follow-up queries when evidence is insufficient. ⬇ You are a personal-memory retrieval agent. The user previously had many conversations with an AI assistant. Those conversations have been stored in a multi-level memory system. Memory levels (progressive disclosure): Level 0 -- session summaries (per-turn one-liners + keywords) Level 1 -- key facts (bullet list extracted from a session) Level 2 -- turn summaries (self-contained, no pronouns, absolute dates) Level 3 -- raw messages (actual user<-> assistant text) STRATEGY GUIDELINES: 1. If the question contains relative time references, call interpret_dates FIRST. 2. If the question is complex, call decompose. 3. Call search with 3-5 diverse queries. 4. READ key facts for ALL possibly-relevant sessions. For counting questions, cast a WIDE net. 5. For counting/aggregation questions: MUST call reflect to check for gaps. 6. Use temporal reasoning: recent sessions’ items likely qualify. 7. Deduplicate items across sessions. CRITICAL: For counting questions, NEVER give a final answer without calling reflect at least once. Figure 7: System prompt for the Progressive Disclosure Controller (§3.2). ⬇ You are a reflection assistant for a memory retrieval system that uses BM25 keyword matching with English stemming and embedding similarity. The user asked (on question_date): question Sessions searched: all_sessions Sessions drilled (key facts read): drilled Previous queries tried: prev_queries Key facts gathered: gathered Your task: 1. ASSESS: Are facts sufficient for a COMPLETE answer? 2. CONVERGENCE CHECK: If same sessions keep appearing and no new ones found, mark sufficient. 3. ENTITY EXPANSION: Extract entities from facts as potential new search terms. 4. If NOT sufficient, generate 1-5 NEW search queries (3-8 words, different vocabulary from all previous queries). Return JSON: "is_sufficient": true/false, "items_found_so_far": [...], "potential_gaps": "...", "new_queries": [...] Figure 8: Prompt for the reflect tool (§3.2). Evidence organization and answer generation. The organized notes synthesizer prompt (Figure 9) instructs the model to structure retrieved evidence by relevance, temporal order, contradictions, and enumeration without producing a final answer. The answer generator (Figure 10) then independently verifies the evidence and produces the final response; this prompt is shared with SimpleMem for fair comparison. ⬇ Read the question and all the retrieved evidence below. Produce organized notes that will help an answer generator answer the question correctly. ## Question (asked on question_date) question ## Retrieved Evidence evidence_text ## Instructions Produce your notes following this structure: 1. **RELEVANT FACTS**: List every fact from the evidence that is directly relevant to answering the question. For each fact, note which session it comes from and the session date. Order by relevance (most relevant first). 2. **TEMPORAL ORDERING** (if dates matter): Arrange relevant facts chronologically. Clearly mark which is the MOST RECENT. If the question asks about the current/latest state, highlight it. 3. **CONTRADICTIONS / UPDATES**: If multiple sessions contain conflicting information about the same topic, note ALL versions with their dates. The LATEST date = current truth. 4. **ENUMERATION** (if "how many" or "list all"): Enumerate every qualifying item found. Deduplicate items appearing in multiple sessions. Flag uncertain items. 5. **ANSWER HINT**: Based on your organization of the evidence, what answer does the evidence point to? (This is a hint, not a final answer.) Rules: Include EVERY relevant detail -- do not summarize away specifics (names, numbers, dates, titles, locations). Be exhaustive for counting questions. Figure 9: Prompt for Organized Notes Synthesizer (§3.3). The system message instructs the model to organize evidence without answering the question itself. ⬇ System: You are a professional Q&A assistant. Extract concise answers from context. You must output valid JSON format. User: Answer the user’s question based on the provided context. User Question (asked on question_date): query Relevant Context: context_str Requirements: 1. Think through the reasoning process. 2. Provide a CONCISE but COMPLETE answer -- include specific names, titles, key details. 3. Answer must be based ONLY on context. 4. Independently scan ALL context entries. Do NOT simply trust the Agent’s preliminary answer -- verify it yourself. 5. Return JSON format. Output Format: "reasoning": "Brief thought process", "answer": "Concise answer in a short phrase" Figure 10: Answer generator prompt (§3.3). Identical to SimpleMem’s prompt for fair comparison; only the input context differs. Appendix C Hyperparameter Configuration Table 5 lists all hyperparameters used in the APDMem experiments. Memory construction parameters (L0L_0 window size and L1L_1 bullet bounds) are fixed across all backbone models. Retrieval parameters were selected based on preliminary experiments on a held-out development set of 20 questions and kept constant for all reported results. Module Parameter Value L0L_0 Turn window size W 4 turns L0L_0 Window overlap 1 turn L0L_0 Max chars/window 6000 L1L_1 Max input chars 12000 L1L_1 Bullet count 5–25 L1L_1 Generation On-demand L1L_1 Workers 8 Embedding Model Nomic-v1.5 Embedding Dimension 768 Retrieval RRF constant k 60 Retrieval Cosine weight wcosw_ 0.5 Retrieval Top-K sessions 20 Retrieval Keyword boost 0.1 Agent Max ReAct steps 20 Agent Auto-drill/search 3 Agent Max drill sessions 10 Agent Max raw turns 20 Agent Max reflection rounds 2 LLM Agent temperature 0.0 Table 5: Hyperparameter configuration for APDMem. Appendix D Setting the Controller Step Budget The controller step budget TmaxT_ is an explicit inference-time budget parameter. It caps the maximum number of convergence-control iterations and therefore bounds the maximum number of additional tool/LLM calls the controller can make before it must stop escalating and return the best available answer. Experimental setting. In all experiments, we set Tmax=20T_ =20. This is intentionally a generous cap: when the controller converges earlier, it terminates before reaching the budget, while TmaxT_ prevents rare difficult queries from incurring unbounded cost or latency. Table 6 reports the observed iteration distribution under this setting. Model Median p95 p99 Max GPT-4.1 5 12 17 20 GPT-4.1-mini 3 12 16 19 Table 6: Observed controller iteration statistics with Tmax=20T_ =20. The cap is reached only in rare cases, so it primarily acts as a worst-case cost and latency bound. With Tmax=20T_ =20, nearly all queries terminate before reaching the cap. Thus, in our experiments, the budget does not materially affect answer quality for most examples, but it still provides an explicit worst-case compute bound. Choosing TmaxT_ in other applications. TmaxT_ controls a quality–cost trade-off: larger values allow the controller to continue searching and reflecting on difficult queries, whereas smaller values reduce worst-case latency and tool/LLM usage. In practice, we recommend setting TmaxT_ as follows: 1. Profile demand. On a representative sample, measure the empirical iteration distribution and set TmaxT_ near a high percentile, such as p95–p99, so truncation is rare. 2. Apply operational bounds. Ensure the resulting maximum stays within deployment constraints, including latency and cost budgets. 3. Choose the tightest sufficient bound. Use the smallest TmaxT_ that keeps truncation rare while satisfying the operational constraints. Appendix E Statistical Significance Analysis To further validate the robustness of the main results, we conduct a controlled multi-run evaluation comparing APDMem with SimpleMem, the strongest prior baseline. Both methods are evaluated on the full LongMemEval-S benchmark, which contains 500 questions, using GPT-4.1 as the backbone model. We run each method for 10 independent runs under the same evaluation protocol and report the mean and standard deviation of accuracy across runs. Method Accuracy (%) APDMem 87.5±1.087.5± 1.0 SimpleMem 84.1±0.784.1± 0.7 Table 7: Multi-run accuracy on the full LongMemEval-S benchmark using GPT-4.1. We report mean and standard deviation over 10 independent runs. APDMem improves over SimpleMem by +3.4 percentage points on average. APDMem achieves an average accuracy of 87.5%, compared with 84.1% for SimpleMem, yielding an average improvement of +3.4 percentage points. To test whether this improvement is statistically significant, we report both a parametric significance test and a non-parametric confidence interval. As the primary parametric test, we use Welch’s t-test, which compares the run-level means while allowing the two methods to have unequal variances. As a complementary robustness check, we also compute a bias-corrected and accelerated bootstrap confidence interval, which makes fewer distributional assumptions. The results are shown in Table 8. Test Type 95% CI of Δ Statistic / Details Welch’s t-test Parametric [+2.55,+4.25][+2.55,+4.25] t=8.44t=8.44, p=2.6×10−7p=2.6× 10^-7 BCa bootstrap Non-parametric [+2.70,+4.20][+2.70,+4.20] B=10,000B=10,000 Table 8: Statistical significance analysis of the APDMem–SimpleMem accuracy gap on LongMemEval-S using GPT-4.1. Here, Δ denotes the accuracy difference between APDMem and SimpleMem in percentage points. Both confidence intervals are strictly above zero, indicating that the improvement is statistically significant. Both confidence intervals are well above zero and provide consistent estimates of the APDMem–SimpleMem performance gap. These results indicate that, when evaluated using GPT-4.1, the observed improvement is statistically significant and unlikely to be explained by run-to-run variation alone. Appendix F Human Validation of the LLM-as-a-Judge All accuracy results in our main experiments use the LongMemEval LLM-as-a-judge protocol. Following prior work, we use the official judge prompt with GPT-4.1-mini at temperature 0.00.0, applied uniformly to APDMem and all baselines. Since our reported gains depend on this evaluation protocol, we conducted an additional human validation study to verify that the judge is reliable in our setting. Human verification. We manually validated a stratified subset of 120 question–prediction pairs, with 20 examples from each of the six LongMemEval-S categories. One author, blind to the judge decision, labeled each prediction as Correct or Wrong according to whether it matched the gold answer, using the same criterion as the judge. To stress-test reliability, we over-sampled examples that the judge labeled Wrong, enriching the subset with borderline cases where disagreements are more likely. Agreement. Human and judge labels agreed on 119 of 120 examples, corresponding to 99.2% agreement and Cohen’s κ=0.98κ=0.98, indicating near-perfect agreement. Agreement was consistently high across all categories, as shown in Table 9. Category n Agree. κ knowledge-update 20 0.950 0.886 multi-session 20 1.000 1.000 single-session-assistant 20 1.000 1.000 single-session-preference 20 1.000 1.000 single-session-user 20 1.000 1.000 temporal-reasoning 20 1.000 1.000 Overall 120 0.992 0.980 Table 9: Human validation of the LongMemEval judge on 120 stratified question–prediction pairs. The single disagreement was a case where the human annotator marked the prediction as correct while the judge marked it as wrong, suggesting that the judge is not biased in favor of APDMem. Overall, this validation provides direct evidence that the LongMemEval judge is reliable in our setting and mitigates the concern that the reported gains are driven by an unvalidated LLM-as-a-judge protocol. Appendix G Hybrid Retriever The Hybrid Retriever retrieves candidate sessions using two complementary indexes over all L0L_0 thematic-summary units ct\c_t\. Lexical index. A BM25 inverted index with stemming indexes each ctc_t and its keyword set tK_t as separate fields, capturing exact matches for entities, proper nouns, actions, and dates. Dense index. Each ctc_t is embedded with a sentence encoder fencf_enc using task-specific prefixes. Embeddings are L2-normalized, reducing dense retrieval to dot-product search. Reciprocal Rank Fusion. Given a query q, the lexical and dense indexes each produce a ranking over turns. The Hybrid Retriever combines them using Reciprocal Rank Fusion (RRF) Cormack et al. (2009): rrf(q,ct)=∑j∈lex,densewjk+rj(ct),rrf(q,c_t)= _j∈\lex,dense\ w_jk+r_j(c_t), (2) where rj(ct)r_j(c_t) is the 1-based rank from index j, k is a smoothing constant, and wjw_j are equal weights. Session scoring. Each session is scored by its best-matching turn: s⁡(q,Si)=maxt∈Si⁡rrf(q,ct).s(q,S_i)= _t∈ S_i\;rrf(q,c_t). (3) To preserve lexical precision for entity-heavy queries, the Hybrid Retriever adds a keyword-field boost for exact matches: s′(q,Si)=s⁡(q,Si)+α⋅smax⋅ni,s (q,S_i)=s(q,S_i)+α· s_ · n_i, (4) where smaxs_ is the top hybrid score, nin_i is a discretized match count, and α is a small constant. Multi-query fusion. For decomposed questions, the controller may issue multiple queries Q=q1,…,qmQ=\q_1,…,q_m\. The Hybrid Retriever scores each session by its best match across the query set: sfinal(Si)=maxqj∈Q⁡s′(qj,Si).s_final(S_i)= _q_j∈ Q\;s (q_j,S_i). (5) The top-K sessions are returned with their thematic summaries. Appendix H Per-Model Efficiency Breakdown Table 10 reports the per-model token usage and latency for both offline memory construction and online retrieval. All numbers are per-question averages on LongMemEval (n=500n=500). Offline (Construction) Online (Controller) Model In Out Tot. In Out Tot. Lat. GPT-4o-mini 130.1 15.2 145.4 121.5 2.8 124.3 37.7s GPT-4.1-mini 130.1 20.6 150.7 86.9 2.4 89.3 57.7s GPT-4.1 130.1 21.2 151.3 125.3 3.2 128.5 45.9s GPT-5.2 130.1 23.7 153.8 84.8 1.7 86.5 42.7s Table 10: Per-model efficiency breakdown (per-question averages, LongMemEval n=500n=500). Input/output token counts and total are in thousands (k). Offline cost is identical across models except for output tokens; online cost reflects the agentic controller only. Offline cost. All models share the same input cost (130.1k tokens) because L0L_0 generation processes identical conversation windows. Output tokens increase slightly with model capability (15.2k for GPT-4o-mini vs. 23.7k for GPT-5.2), reflecting richer summaries and keywords, but the total remains within a narrow 145–154k range. Online cost. Stronger models exhibit more efficient retrieval: GPT-4.1-mini and GPT-5.2 consume only 86–89k tokens compared to 121–129k for GPT-4o-mini and GPT-4.1. This suggests that more capable models require fewer ReAct steps to converge, they generate better initial search queries and identify evidence gaps earlier, reducing iterative exploration. GPT-5.2 achieves the lowest token cost (86.5k) and competitive latency (42.7s), indicating that its retrieval efficiency translates to both cost and speed improvements. GPT-4.1-mini shows the highest latency (57.7s) despite low token usage, likely due to slower per-request API response times. Appendix I Multi-Resolution Memory Substrate: Construction and Examples This section describes the construction process for each layer of the Multi-Resolution Memory Substrate (§3.1) and provides real output examples from the LongMemEval dataset. Prompts for L0L_0, L1L_1, and L2L_2 are shown in Figures 4, 5, and 6, respectively. All examples below are from the same user (0a995998, 44 sessions). I.1 L0L_0: Thematic Summaries Construction. Each session is split into user–assistant turns. A sliding window of W=4W=4 turns (overlap 1) is passed to the LLM, which produces a one-sentence summary (max 30 words), 5–8 keywords, and 3–5 tags per turn. Pronouns are resolved and relative dates are converted to absolute dates using the session timestamp as anchor. Summaries are stored in Markdown and embedded with a sentence encoder for dense retrieval. L0L_0 is materialized at ingestion time. Figure 11 shows a real L0L_0 output. ⬇ ## Session 0 (date=2023/02/15, id=f10be626) Turn 1: - Summary: 2023-02-15 conversation covered solo-trip destination ideas for user with $2000 budget over 5-7 days. - Keywords: 2023-02-15, solo trip planning, $2000 budget, 5-7 days, Airbnb, Southeast Asia, Portugal, Costa Rica - Tags: travel planning, budgeting, accommodations, solo travel Turn 2: - Summary: Assistant recommended Lisbon and Porto in Portugal with estimated daily costs of $80-120. - Keywords: Lisbon, Porto, Portugal, daily budget $80-120, hostels, local food - Tags: destination recommendation, Europe, budget travel Figure 11: L0L_0 output example: per-turn thematic summaries with keywords and tags. I.2 L1L_1: Personalized Key Facts Construction. When the progressive disclosure controller calls read_facts on a session, the LLM extracts a bullet list of 5–25 self-contained key facts about user information, preferences, plans, and constraints. Each bullet resolves all pronouns and relative dates. Generated facts are cached for subsequent accesses. L1L_1 is generated on demand (lazy materialization). Figure 12 shows a real L1L_1 output. ⬇ ## Session 2 (date=2023/02/15, id=750b437b_3) - User was looking for recipe ideas that incorporate seasonal ingredients. - User made a batch of roasted root vegetables before 2023-02-15. - User was interested in citrus fruit recipes, including oranges and lemons. - User stated that oranges and lemons are in season from 2022-12 to 2023-05. - User was particularly interested in trying Citrus and Avocado Salad. - User was particularly interested in trying Lemon and Herb Roasted Chicken. - User planned to try Citrus and Avocado Salad for a lunch break at work. - User usually took a 10-minute walk outside during a work break. - User spotted daffodils blooming in a nearby park before 2023-02-15. - User had been experimenting with spring desserts including lemon bars. Figure 12: L1L_1 output example: self-contained key facts extracted from a single session. I.3 L2L_2: Turn-Level Evidence Notes Construction. When the controller calls read_turns on a session, the LLM decomposes each turn into multiple atomic fact bullets grouped by turn number. Each bullet is a complete, independent, self-contained statement preserving all specifics (names, dates, quantities). Like L1L_1, L2L_2 is generated on demand and cached. The prompt (Figure 6) instructs the model to split distinct facts into separate bullets and never merge multiple facts into one. Figure 13 shows a real L2L_2 output. ⬇ ## Session 7 (date=2023/05/21) Turn 1: - The user asked how hydraulic fracturing affected groundwater quality in the Marcellus Shale region. - The assistant stated that the Marcellus Shale region was located in the eastern United States. - The assistant stated that some studies found higher levels of methane, benzene, and arsenic in groundwater near hydraulic fracturing wells. - The assistant stated that other studies found no significant groundwater quality changes near hydraulic fracturing wells. - The assistant stated that Pennsylvania required hydraulic fracturing companies to monitor groundwater quality at nearby wells before drilling. Turn 2: - The user stated distrust of hydraulic fracturing companies properly monitoring operations. - The assistant stated that the EPA set and enforced regulations on hydraulic fracturing operations. - The assistant stated that citizens could report suspected violations or file lawsuits against hydraulic fracturing companies. Figure 13: L2L_2 output example: atomic fact bullets grouped by turn number. I.4 L3L_3: Raw Messages Construction. No LLM processing is required. The verbatim user–assistant messages are stored directly, grouped by turn number. L3L_3 is materialized at ingestion time by simply formatting the original conversation into a structured Markdown file. The controller accesses L3L_3 via read_raw when exact wording or fine-grained details not preserved in higher layers are needed. Figure 14 shows a real L3L_3 output. ⬇ ## Session 0 (date=2023/02/15, id=f10be626) ### Turn 1 User: I’m trying to plan my next trip and was thinking about my past travel experiences. Can you help me find some good destinations for a solo trip? Assistant: I’d be happy to help you plan your next solo adventure. To get started, can you tell me: 1. What type of activities do you enjoy? 2. What’s your budget for the trip? 3. How long do you have for the trip? 4. Are you open to exploring new destinations? 5. What type of accommodation do you prefer? Figure 14: L3L_3 output example: verbatim user–assistant messages grouped by turn. Appendix J Generator-Side Ablation To isolate the generator’s contribution, we fix the retrieval results from a single run and vary only the generation strategy: whether evidence passes through the Organized Notes Synthesizer or is fed raw to the answer generator, and whether the controller’s draft answer is included. Table 11 reports results. Configuration Avg. Acc. (%) APDMem (full) 87.8 w/o draft answer 86.6 w/o Organized Notes 85.2 w/o Organized Notes & draft 83.6 Table 11: Generator ablation: effect of Organized Notes and draft answer on final accuracy (GPT-4.1, fixed retrieval). The full system achieves 87.8%. Removing the draft answer reduces accuracy by 1.2 points, while removing Organized Notes causes a larger drop of 2.6 points. Without both, accuracy falls to 83.6% (−4.2-4.2), confirming that structured evidence synthesis and the controller’s draft reasoning provide complementary benefits. Organized Notes primarily helps categories requiring evidence aggregation: multi-session synthesis (+6.0 over raw) and temporal reasoning (+3.0), where the structured format, which organizes facts by relevance, enumerates items explicitly, and highlights contradictions, prevents the generator from anchoring on a subset of evidence. The draft answer primarily benefits single-session categories (S-User: +2.9, S-Assistant: +1.8), where the controller’s focused reasoning about a specific session provides useful context for the generator.

Paper	Published	Area	Tags	Intel	Citations