PaperlayerView exact revision on arXiv

Source-linked AI summary

ArborMem: Navigating Interaction States with Memory Forests

Zongwei Lv, Yuemeng Xu, Yilun Yao, Siyi Ding, Xinyu Tan, Yaoming Li, Guangxiang Zhao, Weihong Lin, Lin Sun, Xiangzheng Zhang, Tong Yang

arXiv:2608.17534v1cs.CL

TL;DR

Persistent assistants must resume the correct prior interaction state when conversations interleave tasks and plans. ArborMem navigates a forest of interaction states and outperforms strong baselines across four benchmarks, by 3.36–10.31 points on established benchmarks and 5.0 points on BranchMemEval.

  • Problem

    Existing memory systems retrieve relevant history without first identifying which prior interaction state the current turn resumes, despite interleaved tasks and revisited plans.

  • Method

    ArborMem represents conversations as a navigable forest, restores the relevant branch’s local context, and retrieves reusable evidence across branches.

  • Results

    ArborMem outperforms the strongest baselines across all four benchmarks, by 3.36–10.31 points on three established benchmarks and 5.0 points on BranchMemEval.

  • Takeaways & Limitations

    BranchMemEval provides a controlled assessment of branch-structured conversational memory involving interleaving, delayed resumption, and parallel agendas.

  • Takeaways & Limitations

    ArborMem depends on reliable memory extraction, summarization, retrieval, updating, and revision, while existing benchmarks do not fully capture open-ended interaction or long-term update errors.

Abstract

from arXiv · show

Large language models increasingly serve as persistent conversational assistants, requiring memory that preserves relevant experience and maintains continuity across interactions. Existing methods improve access to conversational history through long-context processing, selective retrieval, and structured memory organization. However, most systems treat memory access as retrieving relevant past information without first determining which prior interaction state the current turn resumes. This limitation becomes particularly important when conversations interleave multiple tasks, people, and plans that may be interrupted and later revisited. We introduce ArborMem, an online memory framework that represents a long-running conversation as a navigable forest of interaction states. Each branch preserves a locally coherent trajectory, while the forest maintains multiple trajectories that may later be resumed. For each new input, ArborMem localizes the relevant state, restores its branch-local context, and augments it with reusable evidence retrieved across branches, preserving interaction continuity without conflating semantically related but structurally distinct trajectories. Existing long-term memory benchmarks cover diverse memory and reasoning capabilities but do not explicitly isolate branch-structured challenges. We therefore introduce BranchMemEval, a controlled diagnostic benchmark for interleaved and resumable interaction trajectories. Experiments on LongMemEval, LoCoMo, BEAM 100K, and BranchMemEval show that ArborMem outperforms the strongest baselines by 3.36 to 10.31 percentage points on the three established benchmarks and by 5.0 points on BranchMemEval. Its advantage grows under constrained read budgets, while complete memory queries remain below half a second.

Introduction

Persistent conversational assistants need memory that preserves relevant experience and continuity across evolving, long-running interactions. ArborMem addresses branch-interleaved conversations by localizing the resumed interaction state before restoring context and retrieving reusable evidence, and BranchMemEval diagnoses these challenges.

  • Motivation: Persistent assistants must remember prior discussions, track ongoing tasks, and resume earlier plans as interactions extend over days or weeks.Long-running agents need durable memory because language models lack state beyond their current context.
  • Problem: Most existing systems retrieve relevant history without first identifying which prior interaction state the current turn resumes.Interleaved trajectories can cause relevance-based retrieval to mix distinct tasks, people, projects, or plans.
  • ArborMem: ArborMem represents long-running conversations as a navigable forest whose branches preserve locally coherent trajectories that can later be resumed.For each input, it identifies the relevant branch, restores branch-local context, and retrieves reusable evidence across branches without conflating trajectories.
  • Evaluation: BranchMemEval is a controlled diagnostic benchmark for topic interleaving, delayed trajectory resumption, and confusion between parallel agendas.Existing long-term memory benchmarks cover other capabilities but do not explicitly isolate these branch-structured challenges.
  • Results: 3.36 to 10.31 percentage points: ArborMem outperforms the strongest baselines on three established benchmarks, while achieving 5.0 points on BranchMemEval.Its advantage grows under constrained read budgets, and complete memory queries remain below half a second.

Related Work

Prior memory systems improve history visibility, selective storage, and retrieval, while conversation-structure research recovers threads mainly from fixed transcripts. ArborMem instead models evolving interaction trajectories online, separating continuity structure from reusable evidence and motivating BranchMemEval’s controlled diagnostics.

  • Memory systems: Long-context models expose more history, whereas selective and agent-memory methods externalize, retrieve, reflect on, update, forget, or consolidate conversational information.These approaches address access to interaction history through longer context or explicit memory operations.
  • Memory systems: Existing memory approaches organize information through semantic association, hierarchy, events, or entity relations, primarily deciding what to store, organize, or retrieve.Their structures focus on information content and organization rather than continuity across interaction trajectories.
  • Conversation structure: Conversation-structure studies recover threads or hierarchies from interleaved dialogue, but primarily analyze fixed transcripts rather than evolving interaction states.Topic segmentation, reply prediction, and conversation disentanglement show that dialogue cannot always be represented as one chronological sequence.
  • ArborMem’s distinction: ArborMem decides online whether each input continues an existing trajectory or starts a new one, representing tasks, entities, goals, assumptions, and local context.Its memory topology represents continuity across trajectories while reusable evidence is retrieved separately, preventing distinct but semantically related states from merging.
  • Benchmark gap: BranchMemEval isolates branch localization, delayed resumption, and parallel-thread confusion, which existing factual, temporal, multi-session, and interleaving benchmarks do not control separately.Existing benchmarks include cross-topic interleaving and thread resumption, but do not isolate these branch-structured diagnostic factors.

Navigable Memory Forest

ArborMem models long-running conversations as a navigable forest of interaction states, preserving multiple trajectories that can be interrupted and resumed. It localizes each new input to a trajectory, restores its local context, and reuses evidence across branches without conflating their structure.

  • Memory representation: ArborMem represents conversational memory as a forest of interaction states, preserving multiple trajectories for later resumption.The forest supports trajectories that may be interrupted and revisited.
  • State navigation: For each input, ArborMem localizes the resumed interaction state, reconstructs its branch-local trajectory, and augments it with cross-branch evidence.After generation, the completed interaction and extracted memories are committed for subsequent turns.
  • Memory representation: Each node is a committed local state, each parent edge denotes continuation, and each root-to-node path forms a locally coherent trajectory.The forest is paired with a reusable evidence store.
  • State navigation: The prior forest supplies primary interpretive context, while the evidence store provides reusable facts across trajectory boundaries.The system reads only the selected prior state before generating a response.
  • State updates: After responding, ArborMem attaches the completed interaction to the selected trajectory or starts a new root, then commits the updated state.This separation preserves interaction continuity while allowing information reuse across branches.

ArborMem

ArborMem models conversation continuity as an online forest of interaction states, preserving locally coherent trajectories while allowing semantically related interactions to remain structurally distinct. For each input, it localizes the resumed state, combines branch-local context with cross-branch evidence, generates a response, and commits the interaction for future turns.

  • Conversation forest: Each forest node represents one interaction state and stores its original turn, summaries, extracted entities and keywords, vector representation, and structural metadata.Metadata includes parent, root, depth, and global sequence position.
  • Conversation forest: The forest grows online by attaching interactions to existing states or creating new roots, so each root-to-node path forms a resumable, locally coherent trajectory.Its topology encodes discourse continuity rather than semantic relevance alone, allowing semantically related interactions to remain on different trajectories.
  • State localization: ArborMem localizes each input using continuation and temporal-return fast paths, then combines semantic, keyword/entity, and topic-anchor recall with branch-aware reranking.The reranker evaluates the candidate node together with its topic key, path summary, node summary, and extracted entities.
  • Context assembly: The selected root-to-state path supplies branch-local context, while cross-branch retrieval adds supplemental turns, reusable atomic facts, and structured records for broader reasoning.Long trajectories are compressed into summaries with a recent raw-turn tail when they exceed the read budget.
  • Online updates: ArborMem writes memory only after generation, making the response depend on the previously committed state and exposing newly extracted information from turn t + 1.This preserves the causal boundary between memory reading and writing.

BranchMemEval

BranchMemEval is a controlled diagnostic benchmark designed to isolate interference from interleaved and resumable interaction trajectories, a gap in existing conversational-memory benchmarks. It uses structured, validated sessions with multiple topical branches and an online replay protocol that restricts answers to prior dialogue context.

  • Scope and dimensions: BranchMemEval targets trajectory localization under interleaved and resumable interaction trajectories, which existing benchmarks do not explicitly isolate.Existing benchmarks instead cover factual retention, temporal and multihop reasoning, knowledge updates, and long histories.
  • Construction: Automatic validation checks answer support from preceding history, prevents answer or confounder leakage, and preserves distinguishability among parallel trajectories.Questions and canonical answers are derived from structured metadata; latent branch annotations are reserved for construction and analysis.
  • Online protocol: Online replay requires each question to use only the previously committed dialogue prefix, while canonical turns—not generated responses—determine subsequent history.Most sessions fit within the 32K answer-time evidence budget.

Experiments

ArborMem is evaluated across four conversational-memory benchmarks, under constrained evidence budgets, for efficiency, and through component ablations. It achieves the best overall accuracy, remains effective with limited reads, offers practical runtime, and benefits from state localization and complementary evidence-processing components.

  • Overall accuracy: ArborMem achieves the best result on all four benchmarks, outperforming the strongest baseline by 9.00 points on LongMemEval, 10.31 on LoCoMo, 3.36 on BEAM 100K, and 5.00 on BranchMemEval.The benchmarks are LongMemEval, LoCoMo Categories 1–4, BEAM 100K, and BranchMemEval.
  • Constrained evidence budgets: ArborMem achieves the best result at six of eight evidence budgets and ties at 32K, exceeding the strongest competitor by 16–26 points from 256 to 1K tokens.The fixed subset contains 50 LongMemEval questions, with budgets spanning 256 through 32K tokens.
  • Efficiency: 1.363 seconds per ingested turn is ArborMem’s construction cost, compared with 1.543 seconds for Mem0 and 3.091 seconds for A-MEM.ArborMem has the lowest memory-construction cost in the efficiency comparison.
  • Efficiency: 10.45 questions per hour is ArborMem’s end-to-end case throughput, compared with 9.39 for Mem0 and 4.69 for A-MEM, while full-query latency remains below half a second.Mem0 and A-MEM have lower query latency, but ArborMem completes the evaluation fastest because ingestion dominates total runtime.
  • Ablations: 12 points is the 30B-model accuracy decrease after removing state localization, from 82.0% to 70.0%; the corresponding 4B decrease is from 48.0% to 46.0%.The ablation indicates that globally retrieved facts and structured records cannot fully replace coherent resumed-state context.

Discussion

ArborMem uses localized trajectories as primary conversational context while retrieving reusable evidence across branches, but its single-parent routing can struggle with ambiguous or multi-intent turns. Like other structured memory systems, it also depends on reliable memory operations and benchmarks that incompletely capture open-ended interaction and memory management.

  • Conversational state and forest structure: ArborMem separates conversational continuation from semantic relevance by prioritizing localized trajectory context and retrieving reusable evidence across branches.Its single-parent forest supports a clear primary context and compact path-based context construction.
  • Conversational state and forest structure: Ambiguous or multi-intent turns may correspond to multiple states, allowing routing errors to propagate into subsequent memory updates.
  • Limitations of current memory systems: ArborMem depends on reliable extraction, summarization, retrieval, updating, and revision, while incorrect, stale, or conflicting memories may persist.Richer memory construction also introduces additional write-time cost.
  • Limitations of current memory systems: Existing benchmarks focus mainly on answering questions over fixed histories and incompletely capture open-ended interaction, user-requested deletion, and cumulative effects of incorrect memory updates.

Conclusion

ArborMem organizes long-running conversations as navigable forests of interaction states, localizing inputs to coherent trajectories while reusing evidence across branches. The paper also introduces BranchMemEval to evaluate interleaved, resumable trajectories and reports consistent results across four benchmarks.

  • Framework: ArborMem organizes long-running conversations as navigable forests of interaction states.Each forest represents multiple interaction trajectories that can be navigated over time.
  • Framework: ArborMem localizes each input to a coherent trajectory and augments it with reusable cross-branch evidence.This supports state-consistent interpretation and long-term information reuse.
  • Evaluation: BranchMemEval is a controlled benchmark for interleaved, resumable trajectories.The benchmark isolates the trajectory-structure challenges targeted by ArborMem.
  • Evaluation: ArborMem demonstrates consistent performance across LongMemEval, LoCoMo, BEAM 100K, and BranchMemEval.The conclusion reports results on all four benchmarks but does not provide their quantitative values in the supplied passage.

ArborMem Implementation Details

ArborMem processes each turn by selecting a prior interaction state, restoring its trajectory with independently retrieved evidence, and then committing the completed interaction to the forest. Context packing and post-generation extraction preserve branch continuity, provenance, and revisions.

  • Online execution: At turn t, ArborMem resolves continuation or temporal-return cues, otherwise retrieves and reranks candidate states, then combines the selected trajectory with factual and structured evidence.After answering, it attaches the completed interaction below the selected parent or inserts it as a new root.
  • Context packing: When a trajectory exceeds the branch budget, ArborMem retains the four most recent nodes as raw turns and represents earlier nodes with summaries.Atomic facts and structured records are retrieved independently and appended without replacing the selected trajectory as primary context.
  • Post-generation updates: After generation, separate extractors update node and path summaries, entities, atomic facts, and structured records while preserving provenance to source interactions.Revision checks determine whether new facts or mutable states coexist with existing attributes or supersede earlier values.
  • Post-generation updates: Superseded records remain traceable but may be filtered or deprioritized during subsequent retrieval.This revision policy distinguishes retained history from records no longer prioritized for access.

BranchMemEval Construction and Validation

BranchMemEval is a controlled diagnostic benchmark testing whether memory systems identify and retrieve from the correct state in interleaved, resumable, and structurally similar trajectories. Its programmatic construction, confounders, replay protocol, and rule-based scoring support controlled validation.

  • Diagnostic scope: The benchmark tests state identification and state-associated retrieval rather than transcript-length scaling alone.Its target conditions are interleaved, resumable, and structurally similar interaction trajectories.
  • Benchmark composition: BranchMemEval contains 33 sessions, 100 in-dialogue questions, and 1,442 non-question interactions spanning three or four interleaved topical branches.Sessions contain 42–52 total turns, averaging 46.73 turns.
  • Construction controls: A programmatic planner fixes branch structure, factual slots, updates, artifacts, distractors, question positions, gold answers, and confounders before language-model realization.Question turns and canonical responses remain grounded in the programmatic specification; DeepSeek-V4-Pro verbalizes non-question turns in the formal set.
  • Construction controls: Each question includes a structurally plausible confounder from a similar trajectory, distinguishing retrieval failure from trajectory confusion.For example, one person’s travel budget may be paired with a parallel person’s agenda budget as the confounder.
  • Validation and scoring: Evaluation replays sessions chronologically, freezes each question’s dialogue prefix, and scores answers with normalized rule-based accuracy.Canonical responses, rather than evaluated predictions, continue the replay, while overall accuracy is primary and per-dimension accuracy plus three error categories support diagnosis.

Baseline and Experimental Configurations

The experiments standardize answer generation and evidence budgets across methods while using benchmark-specific memory construction and evaluation protocols. Supplementary analyses vary read budgets, efficiency settings, and isolated ArborMem components under explicitly controlled configurations.

  • Shared controls: All methods use the same answer model, decoding configuration, evidence limit, and answer template whenever supported.Retrieved evidence from external memory systems is passed to the shared answer model rather than a method-specific generator.
  • Benchmark protocols: LongMemEval evaluates 500 questions independently with isolated, independently reconstructed memory states and a local correctness judge.LoCoMo constructs memory once per conversation for 1,540 Category 1–4 questions, while BEAM 100K constructs memory once for 20 conversations and evaluates 400 questions.
  • Benchmark protocols: BranchMemEval replays each session chronologically, answering from only the previously committed conversation prefix before continuing with the canonical assistant response.This protocol prevents future turns from being available when in-dialogue questions are answered.
  • Baseline configurations: ArborMem sequentially ingests interactions with state localization, branch-local context, routing, fact retrieval, and structured evidence enabled, while supplemental cross-branch raw turns receive zero budget.All external-memory methods remain constrained by the shared answer-time evidence limit.
  • Supplementary analyses: The read-budget analysis varies only evidence exposed to the answer model after complete-history ingestion, with identical final answer-time budgets across methods.External memory methods may prefilter up to twice the target budget before final packing.
  • Supplementary analyses: Component analysis removes one ArborMem component at a time, including state localization, routing, atomic-fact retrieval, structured extraction, or structured evidence.Ablation results are compared within each model column because the two model settings use different automatic judges.

Prompts and Memory Schemas

ArborMem’s experiments use dedicated prompts for answer generation, retrieval reranking, memory commitment, and BranchMemEval query processing. Its answer-time assembly combines routed history, retrieved evidence, and optional structured memory under explicit evidence-priority rules.

  • Prompts and Memory Schemas: The prompt suite covers answer generation, retrieval reranking, post-generation memory commit, and BranchMemEval-specific query processing.Benchmark scoring directives are excluded because they belong to the evaluation harness rather than the memory system.
  • Prompt Usage and Runtime Assembly: Artifact, event, and mutable-state extractors run in the main LongMemEval, LoCoMo, and BEAM configuration, while the attribute-tag predictor is BranchMemEval-only.The prompt invocation conditions differ between the main benchmark configuration and the BranchMemEval evaluation path.
  • Prompt Usage and Runtime Assembly: At answer time, method-side prompts and retrieved memory are assembled into messages, omitting evidence blocks with no retrieved content.Table 12 documents this runtime assembly, excluding benchmark scoring directives.
  • Answer-Generation and Retrieval Prompts: Every answer request begins with a system anchor that defines a warm, precise assistant persona and establishes the answer-generation protocol.The anchor is inserted as the first system message of every answer request.
  • Answer-Generation and Retrieval Prompts: The protocol uses current time, timestamped conversation history, retrieved facts, update evidence, and supplemental evidence to resolve temporal references and past-information queries.It prioritizes precise factual answers and instructs the assistant to answer directly without rigid response headers.
  • Answer-Generation and Retrieval Prompts: Memory is organized into four evidence layers: verified atomic facts, old-to-new updates, the primary routed history, and strictly matched supplemental turns.Supplemental evidence is restricted to direct entity, time, or exact-value matches rather than generic semantic overlap.
  • Answer-Generation and Retrieval Prompts: Evidence conflicts are resolved by deterministic computed answers first, old values for “previous” questions, new values for “current” questions, and specific recent evidence over generic supplemental matches.The protocol also gives update evidence priority for update questions and prevents supplemental evidence from overriding the primary path merely through semantic similarity.
  • Answer-Generation and Retrieval Prompts: The evidence-first prompt requires fact scanning, update checking, primary-history review, supplemental matching, and structured-memory checks before answering.Structured blocks include ArtifactEvidence for ordered items, EventEvidence for count/sum/latest/earliest/compare questions, and CountSourceEvidence for cross-session counts and sums.

8 Prefer implied narrative mentions too (e.g. "growing up in X", "living in Y now", "my

The memory-write prompts extract compact mutable states from explicit or implied narrative mentions, while BranchMemEval uses predicted ontology tags to filter query-side atomic facts.

  • Memory-write output: The prompts extract mutable states from implied mentions, such as growing up in a city or living somewhere now, not only explicit current-value statements.Values are short exact current states, including inferred ones supported by evidence snippets.
  • Memory-write output: The output is a JSON list with at most 6 slots, each using a stable lower_snake_case key and fields for value, attribute tag, entities, and evidence text.Canonical keys include home_city, hometown, pet_name, hobby, workplace, and dietary_pref.
  • Memory-write output: The format must be strictly valid JSON without markdown fences or trailing commas, and returns [] when no mutable state or preference appears.String fields must remain under 180 characters.
  • Memory-write output: The memory manager attaches provenance, timestamps, structural identifiers, and revision links during commit rather than having the prompts generate them.Table 13 summarizes the model-produced outputs of ArborMem’s prompts.
Loading 2608.17534v1…