Persistent Event Memory Forest

• Persistent Event Memory Forest is a framework for long-term spatiotemporal memory that organizes event streams into multiple, temporally structured trees.
• It adaptively transforms raw input—such as video frames or language interactions—into canonical facts and tree nodes to facilitate efficient retrieval and maintenance.
• The architecture emphasizes localized updates, merging strategies, and, in some variants, parameter consolidation to preserve durable, actionable memory traces.

Persistent Event Memory Forest denotes a class of memory organizations in which a system maintains a persistent substrate over an event stream and structures that substrate as multiple temporally organized units rather than a single flat store. In StreamForest, the term names a long-term spatiotemporal memory that adaptively organizes video frames into multiple event-level tree structures under hard token and compute budgets (Zeng et al., 29 Sep 2025). In MemForest, the same phrase maps almost literally onto a forest of MemTrees over canonical facts extracted from long-running language-agent sessions, with separate session, entity, and scene trees (Chen et al., 16 May 2026). In EVAF, the phrase is explicitly interpretive rather than nominal: a surprise- and valence-gated LoRA consolidation mechanism is presented as the kind of parametric mechanism one would build for a persistent event memory forest, because durable traces written from an event stream continue to shape behavior after the originating text has left context (Han, 25 Jun 2026).

1. Conceptual scope and lineage

Across the cited systems, the concept has three stable components. Persistent denotes memory that survives across sessions, maintenance operations, or context unload. MemForest separates persistent state from derived artifacts, so canonical facts, scope assignments, and MemTree structures remain the substrate while summaries, embeddings, and indices can be refreshed or rebuilt (Chen et al., 16 May 2026). StreamForest uses persistence differently but analogously: older video is not discarded by a sliding window, but retained at progressively coarser granularity in event trees (Zeng et al., 29 Sep 2025). EVAF supplies a parametric version of persistence, where selected events are consolidated into a small LoRA adapter that remains active after working context is cleared (Han, 25 Jun 2026).

Event denotes the atomic or near-atomic write unit. In MemForest, this unit is the canonical fact, a temporally anchored atomic memory item derived from the interaction stream and linked to source session and turn IDs, timestamp or time interval, entity mentions, topical indicators, and scope assignments (Chen et al., 16 May 2026). In StreamForest, the event unit is an event node summarizing a contiguous temporal segment of video as compressed visual tokens plus metadata such as timestamp and merge count (Zeng et al., 29 Sep 2025). In EVAF, the event is an element of the stream $x_1, x_2, \ldots, x_T$, typically a user message plus the agent’s response, which may or may not be admitted to the write buffer depending on the gate (Han, 25 Jun 2026).

Forest denotes multiplicity of structured memories. MemForest is explicit: each temporal scope $\sigma$ is materialized as a MemTree $\mathcal{T}_\sigma$, and the total memory is a forest of session, entity, and scene trees rather than one global tree (Chen et al., 16 May 2026). StreamForest likewise maintains multiple event-level tree structures over streaming video (Zeng et al., 29 Sep 2025). EVAF uses “forest” metaphorically: each buffer flush can be seen as adding or reinforcing low-rank directions in parameter space, so the forest is not a literal external tree index but a sparse parametric substrate (Han, 25 Jun 2026).

System	Persistent substrate	Forest interpretation
MemForest	Canonical facts plus MemTrees	Explicit forest of session, entity, and scene trees
StreamForest	Compressed event nodes over video frames	Explicit event-level tree structures
EVAF	LoRA adapter updated from event stream	Metaphorical low-rank parametric “trees”

2. Event schema and forest organization

MemForest provides the clearest formalization of the event-centric language-agent variant. The incoming workload is a session stream

$\mathcal{D}_T = (S_1, S_2, \ldots, S_T),$

with each session

$S_t = (u_{t,1}, u_{t,2}, \ldots, u_{t,n_t}),$

where each $u_{t,i}$ is a timestamped turn (Chen et al., 16 May 2026). From this stream, the system produces evidence items $e_{\sigma,j}$ for each temporal scope $\sigma$, collected as

$$E_\sigma = (e_{\sigma,1}, e_{\sigma,2}, \ldots, e_{\sigma,m_\sigma}).$$

In implementation, these evidence items become canonical facts: normalized, de-duplicated snippets with temporal anchors, entity mentions, topical indicators, source references, and scope assignments. The event schema therefore treats atomic facts as the persistent ground truth and higher-level structures as derived views.

Each MemTree node contains a payload, summary, embedding, time range, and metadata. Leaves store either canonical facts or dialogue cells; internal nodes store references to children. Summaries are textual descriptions of leaf payloads or unions of child summaries, embeddings support vector retrieval, and time ranges aggregate start and end intervals over subtrees. Time is represented implicitly by leaf order and node time ranges: leaves are ordered by event time, while internal nodes summarize contiguous intervals (Chen et al., 16 May 2026).

The forest organization is scope-specific. Session trees contain dialogue cells for a single session. Entity trees contain canonical facts about an entity across sessions. Scene trees contain canonical facts participating in a scene or topic. This multi-view organization means that a single fact may appear in multiple trees. The example given in the source is “Bob moved from Davis to Miami,” which can update Bob’s entity tree, a residence scene tree, and the corresponding session tree (Chen et al., 16 May 2026). A plausible implication is that the forest is not only a storage layout but also a mechanism for preserving parallel explanatory views over the same event stream.

StreamForest instantiates an analogous organization for video. Each event node represents a contiguous chunk of time and a set of visual tokens summarizing that chunk. If a node covers frames from $t_{\text{start}}$ to $\sigma$0, its timestamp is initialized as the average time of the frames it represents. When two nodes merge, the new timestamp is a token-count-weighted average,

$\sigma$1

where $\sigma$2 are timestamps and $\sigma$3 are token counts (Zeng et al., 29 Sep 2025). Leaves correspond to finer-grained segments, internal nodes to merged segments, and the forest gradually deepens as capacity pressure forces compression.

3. Maintenance, update locality, and retrieval

A central property of the persistent event memory forest is write efficiency. MemForest explicitly reformulates agent memory as a write-efficient temporal data management problem and identifies two sources of prior maintenance overhead: coarse-grained state management and sequential update pipelines (Chen et al., 16 May 2026). The proposed remedy has two stages. First, sessions are divided into small extraction chunks,

$\sigma$4

with default chunk size $\sigma$5 turns, and each chunk is processed by an independent LLM call. This parallel chunk extraction is decoupled from existing memory state and MemTree structure. Second, chunk outputs are canonicalized, duplicates are merged, and facts are routed to relevant scopes. Updates therefore become “write facts” rather than “rewrite global profile.”

Localized maintenance follows insertion. For each record, a leaf is inserted in time order, ancestors are marked dirty, and dirty nodes are refreshed bottom-up. Leaf summaries are either passthroughs of canonical facts or summaries of session cells; internal nodes are recomputed from child summaries; embeddings are then refreshed and written into a NodeIndex and a RootIndex (Chen et al., 16 May 2026). For a balanced $\sigma$6-ary tree with $\sigma$7 leaves and height $\sigma$8, one insertion touches one root-to-leaf path, so dependent maintenance is $\sigma$9. The paper emphasizes that nodes at the same level and in different trees can be processed in parallel, which replaces full-state rewrites with localized, height-bounded updates.

Retrieval is hierarchical rather than flat. MemForest first performs forest recall by embedding the query and searching over RootIndex, while also retrieving facts from a global fact index and mapping them back to their trees. It then performs tree browse, either in an embedding-only mode or an LLM-guided mode. In the latter, child summaries are presented to the LLM to choose the best branch; an optional planner can generate tree-specific sub-queries, yielding the LLM+planner mode used for the highest accuracy (Chen et al., 16 May 2026). Retrieved leaves map back to canonical facts or original dialogue cells, are reranked across trees, truncated to a fixed top-$\mathcal{T}_\sigma$0, and inserted into the final prompt.

StreamForest uses a different but structurally similar maintenance logic. New frame tokens create new leaf event nodes; if the spatiotemporal memory quota is exceeded, candidate merges are selected according to penalty functions over content similarity, temporal distance, and merge count. The reported penalty weights are 0.4 for similarity, 0.4 for merge count, and 0.2 for temporal distance (Zeng et al., 29 Sep 2025). This induces quasi-chronological trees that remain semantically coherent while avoiding over-compression of the same region of the timeline. The memory is persistent because earlier frames are not forgotten outright; they survive as increasingly coarse summaries.

4. Parametric consolidation as a complementary interpretation

EVAF broadens the concept by separating memory access from memory depth. The core claim is that retrieval systems can fetch past facts at query time, but they do not determine which experiences continue to shape behavior after working context is unloaded (Han, 25 Jun 2026). EVAF addresses this distinct problem through selective parametric consolidation: a sparse, gated mechanism that writes a small number of behaviorally important events into a LoRA adapter attached to a frozen base model.

Formally, for each event $\mathcal{T}_\sigma$1, EVAF computes surprise $\mathcal{T}_\sigma$2 from token-level negative log-likelihood and valence $\mathcal{T}_\sigma$3 from embedding similarity to a representation of the user’s durable goal or preferences. These are combined through a two-factor sigmoid gate,

$\mathcal{T}_\sigma$4

with $\mathcal{T}_\sigma$5, $\mathcal{T}_\sigma$6, $\mathcal{T}_\sigma$7, and write threshold $\mathcal{T}_\sigma$8; surprise threshold $\mathcal{T}_\sigma$9 is set by a per-user median warmup (Han, 25 Jun 2026). If $\mathcal{D}_T = (S_1, S_2, \ldots, S_T),$0, the event enters the write buffer. When the buffer fills, EVAF trains the LoRA adapter on the current buffer plus replay of previously consolidated events, with an $\mathcal{D}_T = (S_1, S_2, \ldots, S_T),$1 anchor toward initial adapter parameters: $\mathcal{D}_T = (S_1, S_2, \ldots, S_T),$2

The paper explicitly frames this as the kind of mechanism one would build for a persistent event memory forest, but the forest structure is metaphorical rather than literal. The low-rank adapter is a small set of directions in parameter space; each consolidation step can be viewed as adding or reinforcing one or a few low-rank “trees,” while replay stabilizes previously planted traces (Han, 25 Jun 2026). This suggests a useful conceptual distinction: explicit forests such as MemForest and StreamForest preserve structured external records, whereas EVAF internalizes selected event regularities into parameters.

A recurring misconception addressed by this line of work is that improved retrieval alone yields durable memory. EVAF’s loop-drift protocol is designed precisely to show otherwise: the retrieval index remains intact, yet goal-conditioned behavior must persist after context unload and long-loop interference. Within this probe, retrieval is strongest on shallow factual recall, while EVAF is strongest on goal persistence and post-unload recovery (Han, 25 Jun 2026).

5. Multimodal and streaming realization

StreamForest is the source that names the Persistent Event Memory Forest directly and grounds it in streaming video understanding. The incoming video is processed frame-by-frame at 1 FPS, and the vision encoder produces visual tokens that are compressed and organized into a forest of event trees (Zeng et al., 29 Sep 2025). This forest is one of two main memory tracks. The real-time perception quota is 729 tokens for current fine-grained frames; the spatiotemporal memory quota is $\mathcal{D}_T = (S_1, S_2, \ldots, S_T),$3 tokens, or 2,304 tokens, allocated to the event forest; and the total visual token limit is 8,192. The architecture therefore separates detailed short-term perception from compressed long-term event memory.

Adaptive organization is driven by penalty functions. Although the appendix does not print the exact merge formula, it reports a three-term design based on similarity, merge count, and temporal distance, with the balanced setting $\mathcal{D}_T = (S_1, S_2, \ldots, S_T),$4 giving the best performance (Zeng et al., 29 Sep 2025). The temporal term favors chronologically local merges, the similarity term favors semantically coherent merges, and the merge-count term discourages repeated coarsening of the same segment. The result is a persistent memory that increases abstraction over older history while keeping recent or rapidly changing regions more detailed.

The forest is read by the multimodal LLM as part of the token sequence. StreamForest combines text tokens, current-window visual tokens, and memory-forest tokens in a standard transformer pipeline, with novelty located in the memory organization rather than a custom attention rule (Zeng et al., 29 Sep 2025). This enables long-range tasks such as backward tracing, past memory, future prediction, event continuity, and multi-step reasoning under bounded memory. A plausible implication is that the Persistent Event Memory Forest functions simultaneously as a compression mechanism and as a structural prior for spatiotemporal reasoning.

6. Empirical profile, misconceptions, and unresolved boundaries

MemForest reports strong long-context language-agent results. On LongMemEval-S, it achieves 79.8% pass@1 accuracy, with MemForest (emb) at 78.4%, EverMemOS at 66.2%, LightMem at 67.0%, MemoryOS at 50.0%, and Mem0 at 40.2%; on LoCoMo, EverMemOS reaches 69.6% while MemForest reaches 68.4% and MemForest (emb) 66.9% (Chen et al., 16 May 2026). On the write path for LongMemEval-S, MemForest has a build time of about 178s, compared with about 1049s for EverMemOS and about 2440s for MemoryOS, corresponding to about $\mathcal{D}_T = (S_1, S_2, \ldots, S_T),$5 higher throughput than EverMemOS and 13.7× versus the slowest baseline. In migration experiments, merging pre-built memory states is 2–2.7× faster than replaying sessions through the write path, and resulting memory size is within about 1–8% of sequential write.

EVAF shows a different empirical signature. Across GPT-2 and TinyLlama, retrieval attains short-fact accuracy 0.956–0.973, while EVAF attains goal persistence and post-unload recovery 0.812–0.904 with only 2–3 parametric writes per 200 events (Han, 25 Jun 2026). The paper describes this as a “depth flip”: retrieval wins shallow factual access, but EVAF wins deep goal-conditioned persistence. Routed EVAF+RAG combines near-RAG short-fact performance with EVAF-like goal and post-unload performance. At the same time, mechanism audits show that selective consolidation factorizes into selection and actuation, and that actuation is model-dependent. On Mistral-7B, overly strong actuation can invert matched-gate comparisons and increase contamination, which the paper terms asymmetric selection–actuation coupling (Han, 25 Jun 2026).

StreamForest reports state-of-the-art streaming-video performance: 77.3% on StreamingBench, 60.5% on OVBench, and 55.6% on OVO-Bench (Zeng et al., 29 Sep 2025). Under extreme visual token compression limited to 1024 tokens, it retains 96.8% of its average accuracy in eight benchmarks relative to the default setting. In a 1k context setting on a 600s video at 1 FPS input, it runs at 9.9 FPS, whereas Qwen2.5-VL is reported as OOM in the same setting (Zeng et al., 29 Sep 2025).

Several misconceptions are clarified by these results. First, a persistent event memory forest is not equivalent to a global summary continually rewritten from scratch: MemForest explicitly replaces full-state rewrites with localized per-node updates (Chen et al., 16 May 2026). Second, memory access is not identical to memory depth: EVAF’s post-unload results are obtained while the retrieval index remains intact (Han, 25 Jun 2026). Third, “forest” does not always denote the same substrate. In MemForest and StreamForest it is an explicit external hierarchy; in EVAF it is an interpretive description of sparse low-rank parametric traces.

The unresolved boundaries are equally clear. MemForest still incurs LLM summarization cost during node refresh, and its current design does not explicitly model cross-agent or cross-tree relations such as causality graphs (Chen et al., 16 May 2026). EVAF remains append-only in a strong sense: on Memora event streams, improvements in stale-memory rejection are directionally positive but statistically insignificant, and stale-memory invalidation is described as an unresolved boundary (Han, 25 Jun 2026). StreamForest currently relies on inter-frame similarity and local minima for coarse event boundary detection, which may miss fine-grained semantic transitions; its merge policy is driven by similarity, temporal distance, and merge count rather than direct semantic understanding of tasks or queries (Zeng et al., 29 Sep 2025). Taken together, these limits indicate that the persistent event memory forest is a family of architectures for long-horizon retention and structured compression, not a solved theory of memory correctness, deletion, or universal retrieval.