PaperlayerView exact revision on arXiv

Source-linked AI summary

MemForest: An Efficient Agent Memory System with Hierarchical Temporal Indexing

Han Chen, Zining Zhang, Wenqi Pei, Bingsheng He, Ming Wu, Jason Zeng, Michael Heinrich, Wei Wu, Hongbao Zhang

arXiv:2605.23986v2cs.DBcs.AIcs.MA

TL;DR

Long-context agent memory is slowed by serialized extraction and state-dependent maintenance, delaying when new evidence becomes queryable. MemForest uses parallel extraction and hierarchical temporal indexing, achieving strong quality–write-efficiency results across LongMemEval-S and LoCoMo, including 81.8% pass@1 on LongMemEval-S with Qwen3-30B.

  • Problem

    Stateful memory systems often serialize extraction and depend on accumulated state during maintenance, limiting write efficiency and delaying access to new evidence.

  • Method

    MemForest combines parallel extraction and canonical facts with MemTrees, balanced time-ordered hierarchies that refresh summaries only along affected paths.

  • Results

    Across LongMemEval-S and LoCoMo, MemForest achieves strong quality–write-efficiency results, including 81.8% pass@1 on LongMemEval-S with Qwen3-30B.

  • Takeaways & Limitations

    MemForest reduces memory-freshness latency through parallel independent extraction and localized history-dependent maintenance while retaining strong answer quality across the evaluated benchmarks.

  • Takeaways & Limitations

    Production deployment requires available serving capacity, transactional publication, and crash recovery beyond the prototype.

Abstract

from arXiv · show

Memory is a fundamental component for long-context LLM agents, supporting persistent state across interactions through a continuous serve-and-update lifecycle. Despite substantial prior work, many stateful systems retain sequential autoregressive extraction or state-dependent maintenance on the write path, delaying when new evidence becomes queryable. To address these challenges, we present MemForest, a memory framework that reformulates agent memory as a write-efficient temporal data-management problem. MemForest breaks the sequential bottleneck via parallel extraction, decoupling memory construction into concurrent, independent operations. We further introduce MemTree, a hierarchical temporal index that organizes memory as time-ordered trees and replaces global rewrites with localized dirty-path refresh. Dirty summaries can be refreshed in parallel across nodes and trees. End-to-end work remains proportional to incoming content; the logarithmic bound applies only to structural insertion and level-dependent refresh depth in balanced trees. We evaluate MemForest on two long-context benchmarks, LongMemEval-S and LoCoMo. Experiments use Qwen3-4B, Qwen3-30B, and Gemma-4-12B-IT. With Qwen3-30B, MemForest reaches 81.8 percent pass at 1 on LongMemEval-S, while its input-normalized build rate is 6.0 times that of EverMemOS. On LoCoMo categories 1 to 4, it reaches 84.09 percent, within 0.13 percentage points of EverMemOS; on a matched conversation, its build rate is 9.5 times higher. These results show that MemForest reduces memory-freshness latency while retaining strong answer quality.

1 INTRODUCTION

MemForest frames long-context agent memory as a write-efficient temporal data-management problem, addressing serialized extraction and state-dependent maintenance with parallel extraction and hierarchical temporal indexing. It targets lower freshness latency while preserving strong benchmark accuracy across LongMemEval-S and LoCoMo.

  • Motivation: Serialized extraction and state-dependent maintenance create structural write-path bottlenecks that delay memory freshness.History-independent extraction cells can run concurrently, while same-level nodes and nodes in different trees can refresh in parallel.
  • Motivation: Long-context memory must represent evolving user states while supporting current-state, historical, and transition queries.The introduction motivates a temporal organization because facts can be revised while older information remains necessary for complex reasoning.
  • Architecture: MemForest combines parallel extraction, canonical fact consolidation, and MemTree, a hierarchical temporal index of time-ordered trees.Canonical facts provide stable, provenance-linked write units, while structural edits and summary regeneration are confined to affected paths.
  • Evaluation: 81.8% pass@1 was achieved on LongMemEval-S with Qwen3-30B, alongside a 6.0× higher build rate than EverMemOS.The evaluation covers LongMemEval-S and LoCoMo using Qwen3 and Gemma-4 model families.
  • Evaluation: On LoCoMo categories 1–4, MemForest remained within 0.13 points of EverMemOS.Gemma results demonstrate applicability across a second model family, with mixed relative rankings.

2 PROBLEM FORMULATION

The problem formulation models agent memory as an online, time-ordered session workload and analyzes how temporal organization and write-path dependencies affect when new evidence becomes queryable. It motivates MemForest’s design around stable write units, selectively regenerated access artifacts, and hierarchical temporal scopes.

  • 2.1 Workload Model: Agent memory is modeled as an online, time-ordered stream of bounded interaction sessions, each containing timestamped user or assistant turns.After T sessions, the system state is defined over the observed finite stream prefix.
  • 2.1 Workload Model: New dialogue becomes reliably usable only after extraction, memory-state maintenance, and access-artifact refresh advance the maintained memory to a stable version.The workflow separates extraction, maintenance, and retrieval, with retrieval operating on the maintained memory state.
  • 2.2 Temporal Scope: A temporal scope groups time-ordered evidence about an evolving target, representing either a state trajectory or a chronological timeline.State-bearing examples include residence, health, project, and relationship status; broader targets include sessions and recurring scenes.
  • 2.2 Temporal Scope: Independent records preserve local evidence but lose temporal relations, whereas mutable summaries simplify current-state access but risk erasing historical states and transitions.These complementary failures motivate temporal organization beyond embedding similarity or a single latest-state summary.
  • 2.3 Write-Path and Retrieval Trade-offs in Existing Designs: MemForest’s evaluated ingestion path uses bounded-concurrency extraction and refresh, while baseline implementations retain an O(N) per-instance LLM dependency in at least one stage.MemForest’s dirty-node refresh contributes O(⌈N/P⌉) worker waves plus O(log N) dependent tree levels, while its fixed-P end-to-end construction remains O(N).
  • 2.3.2 Mutable Scope States and Accumulative Maintenance.: Mutable scope maintenance serializes later writes behind earlier generated states, creating a growing-or-compressing dilemma that can discard intermediate states and transitions.The dependency may arise in extraction or maintenance across systems such as Mem0, MemoryOS, EverMemOS, LightMem, and related designs.
  • 2.4 Problem Formulation: MemForest uses canonical facts as stable write units, separates persistent state from derived access artifacts, and materializes each temporal scope as a MemTree.MemTree leaves preserve time-local evidence, internal nodes summarize contiguous intervals, and writes affect only the impacted paths.

3 MEMFOREST ARCHITECTURE

MemForest organizes agent memory around canonical facts, a shared persistent substrate, and scoped MemTrees that preserve temporal evidence while enabling localized updates. Its workflows support parallel ingestion, hierarchical retrieval, and selective maintenance without global memory rewrites.

  • Runtime workflows: Session ingestion extracts candidates in parallel, canonicalizes and routes facts into scoped MemTrees, while maintenance edits persistent state and refreshes only affected derived artifacts.This makes new sessions queryable through local insertion rather than a global memory rewrite and supports incremental addition, merge, and targeted deletion.
  • Shared memory substrate: The shared substrate separates persistent state—the source of truth—from derived summaries, embeddings, and index rows that can be selectively regenerated.Persistent state includes canonical facts, scope assignments, MemTree structure, and source-session references.
  • Shared memory substrate: Canonical facts are stable, temporally anchored write units containing retrieval-ready text, provenance, entity and topical signals, and source-session timestamps.Source time and resolved event time remain separate when available, supporting low-latency construction without confusing provenance with asserted time.
  • MemTree design: Each temporal scope becomes a balanced MemTree whose ordered leaves preserve local evidence, internal nodes summarize contiguous intervals, and roots support coarse recall.Older states remain represented rather than being overwritten by a latest-state summary.
  • MemTree design: MemTree unifies temporal fidelity, coarse-to-fine retrieval, and localized maintenance by refreshing only affected ancestor paths during writes and descending selectively during reads.Forest-level recall selects trees first, followed by browsing from interval summaries to leaf evidence.

4 DESIGN AND IMPLEMENTATION

MemForest implements memory construction as parallel extraction followed by canonicalization, temporal-scope routing, localized tree updates, and hierarchical query browsing. Its post-extraction work depends on affected scopes and dirty paths rather than the full accumulated memory state, while the guarantee excludes distributed and crash-recovery features.

  • Write Path: Two-turn chunks are processed independently up to the concurrency budget, avoiding a single serialized LLM pass over the full session.Chunking preserves local context while keeping extraction calls short and parallelizable.
  • Write Path: Canonicalization normalizes surface forms, merges only semantic equivalents, and preserves non-equivalent updates as separate temporally anchored facts.Canonical facts retain source references, temporal anchors, entities, topics, and other metadata for routeable indexing.
  • Routing and Maintenance: Facts are routed to session, entity, and scene scopes, with entity trees serving as a precision-oriented selective overlay rather than the sole retrieval path.A 300-fact audit found 124/127 active entity assignments semantically valid.
  • Routing and Maintenance: O(log N) dependent refresh depth applies to a single dirty leaf-to-root path in a balanced k-ary MemTree, while batch work follows distinct dirty nodes.Structural edits are eager, whereas semantic artifacts are refreshed lazily and locally.
  • Query Path: Forest recall combines root-summary and fact-to-tree signals before browsing temporal hierarchies down to leaf evidence resolved to canonical facts or source dialogue cells.This preserves both broad scope relevance and local lexical, entity-specific, and date-specific cues.
  • Scope and Limitations: The post-extraction locality guarantee excludes MVCC, snapshot reads, atomic multi-file commits, crash recovery, and distributed writers.MemForest limits its systems claim to materialization and semantic refresh bounded by affected scopes, dirty paths, and distinct dirty nodes.

5 EVALUATION

MemForest is evaluated as a persistent-memory system for long-context agents, measuring write latency, query overhead, answer quality, and post-build maintenance across LongMemEval-S and LoCoMo. It achieves substantial write-path speedups while preserving competitive, balanced accuracy and enabling efficient memory-state migration.

  • Evaluation setup: All methods use native persistent-memory write paths and are evaluated with Qwen3-4B-Instruct-2507, Qwen3-30B-A3B-Instruct-2507, and Gemma-4-12B-IT.Qwen3-Embedding-0.6B is fixed for retrieval and indexing, with cross-system latency reported for Qwen.
  • Write-path efficiency: MemForest reaches 24.9× speedup on LongMemEval-S and 32.5× on the matched LoCoMo conversation when normalized to the slowest measured method.Parallel extraction and dirty-path refresh reduce wall time by scheduling independent calls as parallel request waves.
  • Write-path efficiency: 83.58% of build time comes from two autoregressive stages, while structural insertion, index update, and persistence together remain below one percent.Parallel chunk extraction avoids serialized full-session processing, and MemTree replaces global rewrites with scoped insertion and dirty-path refresh.
  • Query overhead: 2.19s (30B) and 2.42s (4B) are the embedding-only retrieval latencies, compared with 4.60s and 4.30s for planner-guided retrieval.Query latency remains small relative to the write path, while planner guidance adds tree-browse reasoning.
  • Answer quality: 81.80% is MemForest-Planner’s LongMemEval-S pass@1 accuracy with 30B, while EverMemOS leads MemForest by only 0.13 points on LoCoMo under 30B.MemForest’s variants remain close on both benchmarks, with category performance generally balanced and backbone-dependent.
  • Post-build maintenance: 2.70× is the peak migration speedup around N=5–6, while merged states differ from sequential-write states by less than 1% in facts and at most about 8% in trees.Migration reuses already materialized states and avoids repeated extraction or rebuilding unaffected trees.

6 MECHANISM, REPRESENTATION, AND SCALING ANALYSIS

This section isolates MemTree’s maintenance mechanism, equal-budget retrieval behavior, and frozen-index scaling. It shows that parallel dirty-path refresh shortens the observed critical path, while hierarchy improves recall at larger evidence budgets without making full construction logarithmic.

  • MemTree maintenance: Parallel dirty-path refresh reduces the observed maintenance critical path, although full memory construction remains linear in incoming content rather than O(log N).Figure 6 separates call-count reduction from MemTree-only maintenance timing and attributes the short observed path to level-wise and cross-tree parallelization.
  • Evaluation design: The controlled retrieval study uses 82 development and 237 held-out LoCoMo temporal questions with six frozen pre-answer evidence budgets from 5 to 100 facts.Controls share canonical facts and embeddings, omit a final LLM reranker, and freeze selector choices after development selection.
  • Equal-budget retrieval: At k = 20, frozen MemTree and tuned Log-TimeRerank remain within 0.8 points, while MemTree leads from k = 30 and remains highest at k = 100.Its clearest margin occurs at k = 50 under equal pre-answer evidence budgets.
  • Frozen-index scaling: 37.63–39.24 ms retrieval p50 and 41.79–44.13 ms p95 persist as frozen forests scale from 1,428 facts and 250 trees to 10,781 facts and 1,868 trees.The benchmark uses fixed top-10 embedding browse and excludes planner calls, answer generation, and index loading.
  • Frozen-index scaling: 0.114 to 0.413 ms is the increase in Exact RootIndex recall p95 across the same frozen-forest scaling sweep.This is a deployed retrieval microbenchmark rather than an end-to-end latency measurement.

7 RELATED WORK

Related memory systems differ in how they construct, organize, and maintain persistent state. MemForest instead combines queryable-state construction with derived-index refresh under continuous updates, occupying distinct maintenance and retrieval trade-offs.

  • Memory Construction: Memory construction spans persistent-record extraction, personalization, staged short-, mid-, and long-term memory, and modular cross-interaction handling.Examples include SeCom, Mem0, LightMem, MemoryOS, and context-dependent frameworks.
  • Memory Organization: MemForest constructs queryable state and refreshes derived indexes, preserving compatibility with retrieval and generation optimizations during continuous updates.This differs from database systems that optimize retrieval, generation, or vector search, including AquaPipe, Cache-Craft, GaussDB, and HAKES.
  • Memory Organization: Memory organization includes semantic consolidation and recollection, transactive memory, A-Mem, collaborative approaches, and graph-based evidence for structured retrieval.GraphRAG and Zep/Graphiti organize graph evidence, while MemTree adopts a different maintenance/retrieval-granularity trade-off.
  • Memory Maintenance: Memory maintenance ranges from reflective refinement and near-verbatim history preservation to MemForest’s canonical-fact merging approach.RMM reflectively refines retained and consumed memory, while MemPalace defers abstraction to query time.

8 CONCLUSION · A PROMPTS

MemForest frames persistent agent memory as a write-efficient temporal data system, using concurrent extraction and localized temporal maintenance to reduce freshness latency while preserving strong benchmark quality. The appendix documents public and strict judge prompts, including their evaluation criteria and released template provenance.

  • 8 CONCLUSION: MemForest separates canonical evidence from derived access artifacts, extracts dialogue cells concurrently, and refreshes MemTree summaries only along affected dirty paths.Extraction and refresh work still grow with incoming content; the system targets lower memory-freshness latency rather than sublinear construction.
  • 8 CONCLUSION: MemForest leads both Qwen LongMemEval-S settings and nearly matches EverMemOS on LoCoMo categories 1–4 while achieving substantially higher measured build rates.Gemma-4-12B-IT results indicate cross-family applicability with mixed rankings.
  • 8 CONCLUSION: Tuned temporal logs remain competitive under tight pre-answer evidence budgets, while MemTree provides the paper’s alternative temporal-memory operating point.The conclusion identifies this as a boundary established by controlled studies.
  • 8 CONCLUSION: Production deployment requires available serving capacity, transactional publication, and crash recovery beyond the prototype.These requirements qualify the reported system gains and deployment readiness.
  • A PROMPTS: The paper’s main tables use public Mem0 benchmark judges, whereas paired sensitivity analysis and LoCoMo category-5 evaluation use a stricter judge.Table A1 compares their operative policies, and complete public prompts, internal prompts, and hashes are released in the artifact.
  • A.1 Public and Strict LLM-as-Judge Prompts: The exact public templates are the Mem0 LongMemEval prompt at commit 7ba1bd3 and the tuned LoCoMo prompt at commit edcd6f1.Strict templates are also available in the revision artifact.
  • A.1 Public and Strict LLM-as-Judge Prompts: The strict LongMemEval judge labels answers CORRECT or WRONG using the question type, question, gold answer, and generated answer.It accepts semantic equivalents, equivalent relative or absolute times, and more specific consistent answers; it marks WRONG for contradiction, missing key facts, a different question, or incorrect abstention.
  • A.1 Public and Strict LLM-as-Judge Prompts: The other strict judge labels answers CORRECT or WRONG from the question, gold answer, and generated answer.It accepts semantic and time-expression equivalents plus more specific consistent answers, while rejecting contradiction, missing key facts, non-answer, or incorrect abstention.

B EVALUATION PROTOCOLS AND SENSITIVITY … C.1 Temporal Diagnostic Subset Map

The evaluation freezes or controls retrieval, answer generation, prompts, budgets, and judge policies to distinguish protocol effects from memory-system behavior. Temporal subsets and coverage diagnostics supplement, rather than replace, full-benchmark pass@1 results.

  • B.1 Judge, Retrieval, and Answer Interfaces: MemForest uses schema-aware answer interfaces with native top-k=10 tree browsing, while other methods retain their native memory-object interfaces.MemForest fully expands selected tree units; equal-flat-fact comparison is limited to the controlled setting.
  • B.1 Judge, Retrieval, and Answer Interfaces: Frozen answers are judged with deepseek-v4-flash at temperature zero with thinking disabled.The evaluation uses heterogeneous evidence objects, with a limit of 10 per evidence class and separate reporting of object counts and context-token lengths.
  • B.2 Strict/Public Judge Sensitivity: 8,496 successful judge calls with zero errors support the paired diagnostic, which changes only the judge prompt while freezing retrieval and generated answers.The broader frozen samples contain 172 LongMemEval and 200 LoCoMo questions across the specified judge arms and votes; temporal slices contain 122 and 150 questions, respectively.
  • B.3 LoCoMo Adversarial Category: Category 5 is evaluated under the same strict answerability prompt for every method, while the headline public-prompt comparison uses the released 1,540-question scope.Category 5 asks whether a question is answerable and lacks the non-empty reference answer assumed by released public LLM-judge runners.
  • B.4 Mem0 Budget Occupancy: 83.11% of a local Mem0 store is exposed on average at top-200, making the public top-200 result a broad high-coverage, different-budget setting.The corrected snapshot contains 121,594 memory units across 500 isolated LongMemEval-S stores; top-200 exhausts 40/500 stores and exposes 82.48% on temporal questions.
  • B.5 Answer-Prompt Coupling: A shared schema-neutral answer prompt can increase abstention and changes schema interpretation, abstention behavior, and evidence use across methods.Because context objects are serialized heterogeneously, the experiment is not a pure substrate-isolation test.
  • B.5 Answer-Prompt Coupling: Retrieval coverage, rather than shared-prompt QA, is the primary representation-level diagnostic because answer prompts are part of each memory system’s retrieval interface.The shared-prompt experiment is therefore not used to replace the main benchmark.
  • C.1 Temporal Diagnostic Subset Map: Temporal subsets serve distinct diagnostic purposes and do not replace the full-benchmark pass@1 results.Table C1 explicitly maps the non-overlapping purposes and relationship among the temporal diagnostic subsets.

C.2 Fixed-Retrieval Dual-Time Control … F.2 Frozen-Index Query Scaling

The supplementary analyses validate MemForest’s temporal controls, routing and maintenance choices, chunking defaults, and bounded system costs through targeted diagnostics. They report measurable gains, constrained operating points, and clarified limitations across retrieval, extraction, scaling, and fragmentation tests.

  • C.2 Fixed-Retrieval Dual-Time Control: 10 additional correct answers were obtained by dual-time rendering with identical top-30 retrieval IDs across 321 LoCoMo temporal questions.The diagnostic isolates context rendering from retrieval and does not establish that the complete LoCoMo gap is removed.
  • C.2 Fixed-Retrieval Dual-Time Control: p=0.0309 in the exact paired McNemar test, while dual time preserves source time, event time, temporal expressions, and resolution bases.
  • C.3 Log-TimeRerank Development Grid: (0.12, 1.0) is the best Log-TimeRerank point in the predefined development grid, but 0.12 lies on its lexical-weight boundary and is not a global optimum.The grid uses lexical weights {0, 0.04, 0.08, 0.12} and temporal weights {0, 0.5, 1.0, 1.5}; both selected settings are frozen on held-out budgets.
  • C.4 Representation Maintenance Design Space: Local maintenance avoids rewriting all prior evidence, while the shared-fact control intentionally excludes native extraction and storage engines from this qualitative design-space comparison.
  • C.5 Entity-Routing Audit; C.6 Planner versus Embedding Browse: 124/127 active entity assignments were semantically valid, but exact-all activation succeeded for only 9/127 facts because entity trees prioritize precision over per-mention recall.Facts without active entity assignments remain reachable through session and scene trees and bottom-up fact-to-tree recall.
  • C.6 Planner versus Embedding Browse: Planner and Embed provide a quality–cost comparison rather than an equal-compute ablation because they use different native browse pools and Planner makes one LLM browse call.
  • C.7 Scene-Threshold Stability; C.8 Author-Adjudicated Fragmentation Diagnostic; D ADDITIONAL DESIGN SENSITIVITY ANALYSES: 231 supported mappings were retained after adjudication, with specific-tree fragmentation in 4/130 retained LoCoMo and 37/101 retained LongMemEval questions.The audit contained 249 questions, excluded 18 unsupported rows, and defines fragmentation as non-colocation of all supporting facts in one specific tree.
  • E CHUNK-SIZE DIAGNOSTIC FOR RAW-FACT EXTRACTION; E.1 MemTree Branching Factor: 2-turn extraction preserves full Ent-GR and improves token efficiency over 1-turn extraction, whereas chunks beyond 8 turns visibly degrade fidelity and whole-session extraction is least faithful.The diagnostic uses manually concatenated long sessions and Ent-GR rather than benchmark pass@1; the selected branching region balances dependency depth with summary retention rather than answer-judge tuning.

F.3 Freshness Contract and Limitations

MemForest provides same-user freshness through serialized lifecycle operations, making committed cells and refreshed indexes visible together after ingest. Its guarantees exclude automatic fact verification and several advanced consistency, recovery, and concurrency features.

  • Freshness contract: A same-user query blocks during ingest and observes rebuilt state after successful return, with newly committed cells and refreshed indexes becoming visible together.One process-local reentrant lock serializes same-user ingest, query, save, and lifecycle operations; save/reload preserves the committed version.
  • Limitations: Extraction errors can propagate across scopes and dirty-node summaries because canonicalization and deduplication do not verify extracted facts.Provenance links trace affected leaves and derived artifacts for deletion and refresh, while automatic fact verification remains future work.
  • Limitations: The implementation lacks MVCC, concurrent snapshot reads during refresh, atomic multi-file publication, rollback, crash recovery, multi-process writer safety, and distributed linearizability.These are stated limitations rather than inferred guarantees.

G DETAILED WRITE-PATH AND PARALLELISM ANALYSIS … H.1 Baseline Workflow Settings

The paper analyzes write-path dependency depth across memory systems and presents MemForest as exposing parallel extraction while localizing history-dependent maintenance to a dirty-node DAG. It also documents baseline workflow settings and releases a frozen artifact for reproducibility and audit.

  • G DETAILED WRITE-PATH AND PARALLELISM ANALYSIS: Native-unit analysis separates extraction from maintenance and measures logical autoregressive dependency depth without treating LLM requests as constant-time.N denotes method-native input units, while total work, token costs, concurrency, search, and persistence remain measurable.
  • G.1 Independent Records and Mutable States: Independent records support parallel retrieval but can miss temporal predecessor, successor, and interval relations, whereas mutable states may require processing accumulated history and lose transitions when compressed.For hot scopes, triggered updates can be proportional to accumulated state size N.
  • G.2 Mem0: Mem0 performs extraction, fact embedding, candidate retrieval, and LLM reconciliation, but its evaluated adapter reports O(N) extraction because each complete add is awaited before the next.The path includes add, update, delete, and no-op decisions after retrieving existing candidates.
  • G.3 MemoryOS: MemoryOS appends QA pairs without an LLM, then conditionally performs page continuity, meta-summary, and multi-topic maintenance; profile and knowledge analyses parallelize, but same-state commits remain ordered.Its two-worker pool separates trigger frequency from the cost of a triggered update.
  • G.4 EverMemOS: EverMemOS has O(N) ordered extraction depth because later conversation boundaries depend on earlier decisions, while frozen MemCells undergo serialized enrichment, embedding, and index writes.The benchmark configuration reports O(C) post-extraction work for C cells without an additional history-size-dependent LLM commit-path call.
  • G.5 LightMem; G.6 MemPalace: LightMem’s evaluated turn-by-turn runner has O(N) extraction, while snapshot-based consolidation can touch O(N) candidates and uses O(⌈N/P⌉) LLM waves despite a global write lock.MemPalace instead uses no autoregressive LLM for chunk formation or index insertion, with O(N) logical write work for N chunks.
  • G.7 Zep Local / Graphiti; G.8 MemForest: Zep Local/Graphiti requires sequential same-namespace episodes, giving O(N) ordered extraction and maintenance depth, while candidate-search cost depends on graph size and query behavior.MemForest partitions input into N extraction cells, achieving O(N) total extraction work and ⌈N/P⌉ request-wave depth under its semaphore.
  • G.8 MemForest; G.9 Summary; H REPRODUCIBILITY AND AUDIT ARTIFACTS; H.1 Baseline Workflow Settings: MemForest refreshes dirty summaries with O(|D|) LLM work and O(⌈N/P⌉ + max_s∈S log N_s) request waves, while same-level and cross-tree execution localizes history dependence without changing maintenance semantics.The paper frames this as schedule and state-dependency analysis rather than a universal asymptotic ranking; the artifact freezes code, protocols, outputs, rankings, sweeps, and intervals.

H.2 MemForest Experimental Configuration … H.6 Manual Audit Provenance

The supplementary sections specify MemForest’s retrieval configuration, validate protocol and timestamp handling, reproduce Zep Local, and document manual-audit provenance. Together, they define reproducible evaluation procedures and explicit quality controls across systems and judgments.

  • H.2 MemForest Experimental Configuration: MemForest uses 1,024-dimensional Qwen3-0.6B embeddings with exact FAISS inner-product search, top-eight canonicalization, and a 0.93 similarity threshold.Canonicalization permits at most four concurrent LLM equivalence checks per new item; entity scopes activate after three facts across two sessions.
  • H.3 Qwen MemForest-Embed Protocol Validation: Qwen MemForest-Embed uses native top-k=10 tree browsing, fully expands selected tree units, and generates answers with MemForest-Planner’s default prompt and Qwen backbone.Automated gates require complete expansion metadata, unique question identifiers, non-empty answers, and no context truncation at the 60,000-character validation bound.
  • H.3 Qwen MemForest-Embed Protocol Validation: The Qwen Embed validation protocol requires 500 LongMemEval-S and 1,986 LoCoMo answers per backbone, with normalized records, source hashes, manifests, and score checks released.The artifact documents the validated per-question records and associated provenance checks.
  • H.4 Mem0 Timestamp and Retrieval Validation: The Mem0 adapter propagates benchmark event time through timestamp arguments and metadata, exposes stored timestamps in retrieved contexts, and prevents LoCoMo add batches from crossing source sessions.Validation records source session, timestamp, and contiguous message range while checking complete non-overlapping message coverage for both speakers and rejecting runtime dates.
  • H.5 Zep Local: The reproduced Zep Local path uses MemoryData’s specified commit, Graphiti v0.24.1, Neo4j 5.26.2, raw-episode ingestion, self-hosted endpoints, and native heterogeneous retrieval.The implementation is explicitly a reproducible local Zep architecture, not Zep Cloud or the deprecated self-hosted Community Edition.
  • H.5 Zep Local: Graphiti’s native recipe usually serializes approximately 20 heterogeneous objects rather than ten flat facts, with graph differences arising across generative backbones.These graph-construction differences explain the small cross-backbone context-length differences.
  • H.6 Manual Audit Provenance: The temporal audit retains 231/249 supported mappings and records 18 exclusions with reasons, while author-adjudicating 87 flagged temporal rows, three routing exceptions, and 12 judge-policy cases.Published materials include model-assisted labels, independent review, author decisions, exclusions, and validation summaries, making the hybrid provenance explicit.

I DETAILED MEMORY SCALE IN MIGRATION

The migration experiment shows that migration merge preserves memory states at a scale comparable to sequential writing. It reduces maintenance time without systematically collapsing persistent evidence or tree structure.

  • Memory scale: Less than 1%: fact counts differ across merged sizes, while tree counts differ by at most about 8%.Both strategies produce memory states of comparable scale.
  • Memory scale: Migration merge reconciles already materialized states, whereas sequential writing replays sessions through the full write path.The procedures can differ because fact extraction, tree-summary refresh, and scope routing involve LLM-based or heuristic decisions.
  • Memory scale: Migration preserves similar persistent evidence and scoped tree structure while reducing maintenance time.The comparable scale indicates no systematic blow-up or collapse of memory state.
Loading 2605.23986v2…