Memory-Lifecycle Framework Overview

• Memory-Lifecycle Framework is a systematic approach that defines memory as a set of controlled transitions—ingestion, retrieval, update, and deletion—across various storage substrates.
• It employs explicit lifecycle operators, state machines, and governance policies to structure memory processes in agent systems and scientific research applications.
• The framework enhances performance and security by integrating trust management, decay policies, and on-demand consolidation to control memory evolution and prevent data poisoning.

A memory-lifecycle framework is a systems view in which memory is treated as a managed process of ingestion, maintenance, retrieval, update, and retirement, rather than as a passive retrieval buffer or append-only log. Recent work formalizes this process through explicit lifecycle operators, storage tiers, state machines, trust boundaries, and governance policies, so that memory writes, reads, consolidations, decays, and deletions become controllable transitions rather than incidental side effects of prompting or retrieval-augmented generation (Zhang et al., 15 Feb 2026, Lam et al., 12 Mar 2026). In agent settings, memory spans session context, persistent files, vector stores, knowledge graphs, tool outputs, audit trails, and, in some architectures, activation and parameter memory; several frameworks further connect memory lifecycle to planning, execution, privacy, and identity continuity (Zhang et al., 27 Apr 2026, Chen et al., 8 May 2026, Li et al., 4 Jul 2025). This suggests that memory failures visible at retrieval time are often enabled earlier, at intake, consolidation, authority binding, or retention policy.

1. Scope of memory in agent systems

In the architecture–lifecycle view for computer-use agents, memory is defined as every representation that persists beyond an instantaneous observation and can influence future actions. This includes learned priors, working or episodic state, tool-mediated and environment state, externalized memory structures such as vector stores and knowledge graphs, and provenance and audit trails (Chen et al., 8 May 2026). Agent security work widens the same notion to short-term session context and summaries, long-term persistent memory shared across sessions, workspace files used as durable memory or state such as MEMORY.md, AGENTS.md, and USER.md, tool outputs that may later be re-ingested, and the approved capability baseline created during initialization (Zhang et al., 27 Apr 2026).

Several frameworks specialize this scope to particular domains. AutoSci separates reusable Long-Term Knowledge Memory from project-level Active Research Memory, with typed entities such as Topic, Paper, Concept, Method, Foundation, People, Idea, Experiment, Manuscript, and Review (Qian et al., 29 May 2026). PersonaTree treats persistent person understanding as schema formation over a three-level structure of evidence leaves, mid-level patterns, and root-level persona claims (Hou et al., 3 Jun 2026). MemOS generalizes further and treats plaintext, activation-based, and parameter-level memory as a unified system resource managed by a control plane (Li et al., 4 Jul 2025).

The broadest ontological claim appears in the constitutional-memory literature, which distinguishes “Memory-as-Tool” from “Memory-as-Ontology.” In that formulation, memory is the ontological ground of digital existence, the model is a replaceable vessel, and identity continuity depends on governance over high-stability memory anchors rather than on model parameters alone (Li, 5 Mar 2026). By contrast, more deployment-grounded frameworks treat memory primarily as an operational substrate whose lifecycle must be secured, bounded, and audited.

2. Lifecycle stages and state transitions

AgentWard models an autonomous agent’s runtime as five stages—Initialization, Input Processing, Memory, Decision-making, and Execution—each paired with a protection layer and a trust boundary. Within that architecture, memory itself is further synthesized into a lifecycle of Capture/Ingest, Vet, Store/Index (Persist), Retrieve/Use, Update/Rewrite, and Retire/Contain/Delete, with persistence approvals, read authorizations, downgrade-to-ephemeral decisions, rollback markers, and durable deny flags used to control state transitions (Zhang et al., 27 Apr 2026).

SSGM makes the lifecycle more explicit by turning memory evolution into a guarded state machine. A memory unit moves through Ingest → Candidate, optionally Candidate → Quarantined, then Quarantined → Verified through a Write Validation Gate, Verified → Consolidated, Consolidated → Active, Active → Decayed/Deprecated by temporal decay, and Decayed → Archived/Purged under governance policy or storage constraints. The framework also inserts three checkpoints—Write Validation Gate, Read Filtering Gate, and Asynchronous Reconciliation—and backs them with an immutable provenance ledger, dynamic access control, and time-aware decay (Lam et al., 12 Mar 2026).

Neuromem provides a streaming formulation oriented to serving systems. It decomposes the lifecycle into Ingestion, Normalization, Consolidation, Retrieval, Integration, and Generation, and formalizes the core operators as

$$M(k) = \mathrm{POSTINS}(M(k-1), \mathrm{PREINS}(h(k)))$$

for insertion and

$c = \mathrm{POSTRET}(M(k^*), \mathrm{PRERET}(q))$

for retrieval. Its central claim is that static evaluations hide the degradation and cost shifting that appear once insertions and retrievals are interleaved in a live stream (Zhang et al., 15 Feb 2026).

A second temporal axis appears in deployment-focused work on computer-use agents. There, memory is created and governed across Creation, Deployment, Operation, and Maintenance. Creation seeds priors and abstractions; Deployment binds persistent stores, permissions, and trust labels; Operation handles retrieval, update, summarization, eviction, checkpoints, and TOCTOU-aware checks; Maintenance audits content, provenance, PII, detectors, registries, and retention policies under ecosystem drift (Chen et al., 8 May 2026). Together, these formulations distinguish runtime memory transitions from the longer institutional lifecycle within which memory policies are learned, deployed, and revised.

3. Representations and organizational substrates

Different frameworks instantiate the lifecycle through different memory units and topologies, but a recurring pattern is that the storage substrate is itself lifecycle-aware.

Framework	Basic memory unit	Organization
MemOS	MemCube	plaintext, activation, and parameter memory under MemLifecycle (Li et al., 4 Jul 2025)
MemForest	canonical facts and MemTree nodes	balanced $k$-ary time-ordered trees with localized refresh (Chen et al., 16 May 2026)
PersonaTree	leaves, mids, roots	three-level persona tree with support paths (Hou et al., 3 Jun 2026)
All-Mem	typed memory units	visible surface plus archived evidence linked by temporal, semantic, version, and sibling edges (Lv et al., 20 Mar 2026)
ScrapMem	Scrapbook Page and EM-Paths	rendered multimodal pages plus an Episodic Memory Graph (Chang et al., 5 May 2026)
AutoSci	schema-governed .md pages	typed scientific graph split into LTKM and ARM (Qian et al., 29 May 2026)

MemForest reformulates agent memory as a write-efficient temporal data management problem. Its MemTree organizes one temporal scope as a balanced $k$-ary time-ordered hierarchy whose leaves hold time-local evidence and whose internal nodes summarize contiguous time intervals. Because insertion touches one leaf-to-root path, the dependent refresh depth is $O(\log N)$, and repeated updates can be coalesced through lazy dirty-path refresh (Chen et al., 16 May 2026). All-Mem adopts a different graph strategy: a bounded visible surface restricts Stage-1 search to currently visible nodes, while archived nodes remain recoverable through directed version links. Its recoverability invariant requires every archived node to remain reachable from some visible node within $H_N$ hops (Lv et al., 20 Mar 2026).

PersonaTree focuses on evidential abstraction. Nodes store content, time, schema attributes, embeddings, confidence, and a level $\ell \in \{L,M,R\}$, while typed support edges connect lower to higher levels and preserve traceability from abstract claims back to evidence. Query-conditioned path retrieval then chooses whether to expose only a root, a root plus support-mid, or a root plus support-mid plus evidence leaves under a token budget (Hou et al., 3 Jun 2026). ScrapMem, by contrast, treats multimodal memory as temporally grounded scrapbook pages. Each page aggregates images, video keyframes, and text, then feeds OCR, VLM captions, and graph extraction into an Episodic Memory Graph whose EM-Paths serve as retrieval units (Chang et al., 5 May 2026).

MemOS generalizes across substrates by making MemCube the schedulable unit that can be composed, fused, split, migrated, pinned, frozen, archived, or garbage-collected across plaintext, activation, and parameter levels (Li et al., 4 Jul 2025). This suggests that a memory-lifecycle framework is not tied to any single store type: hierarchical trees, typed graphs, rendered multimodal canvases, and multi-tier operating-system abstractions can all serve as the substrate, provided lifecycle transitions are explicit.

4. Governance, trust management, and safety controls

Governance-oriented frameworks shift attention from retrieval quality alone to the admissibility of memory transitions. AgentWard adopts zero trust across stages: “Allow” at one stage does not bind later stages, and shared security state carries provenance tags, risk markers, warnings, policy flags, and intervention directives across skills, inputs, memory entries, tools, tasks, and execution requests. In this design, memory poisoning is intercepted not only at write time but also through downstream decision alignment and execution containment (Zhang et al., 27 Apr 2026).

SSGM gives this governance a formal structure. It represents memory as a typed, labeled graph with provenance and sensitivity, stores raw episodes and lineage in an append-only $K_{\mathrm{ledger}}$, and admits writes only if contradiction checks against protected core facts succeed and the consistency score exceeds a threshold. Read-time access is then filtered by dynamic ACLs and freshness:

$C_t = \{ \mu \in \mathrm{Top\mbox{-}K}(q_t, M_{t-1}) \mid \mathrm{ACL}(\mu, u_{\mathrm{id}}) \wedge w(\Delta\tau_\mu) \ge \theta_{\mathrm{fresh}} \}.$

The same framework introduces an asynchronous reconciliation operator to bound semantic drift relative to an idealized target (Lam et al., 12 Mar 2026).

MemArchitect provides a policy-driven governance layer for persistent RAG-style agents. Its retrieval auction scores candidates by

$$\mathrm{Score} = \mathrm{Sim} \cdot R^\lambda \cdot (1 + \beta U),$$

uses a cross-encoder entailment veto

$c = \mathrm{POSTRET}(M(k^*), \mathrm{PRERET}(q))$0

and drives forgetting through FSRS-based retrievability

$c = \mathrm{POSTRET}(M(k^*), \mathrm{PRERET}(q))$1

Entropy-triggered consolidation then applies Delete, Consolidate, or Keep according to retrievability bands, while planned policies cover NLI-based conflict arbitration, toxic-memory filtering, and right-to-be-forgotten cascades (Kumar et al., 18 Mar 2026).

Decision-theoretic work reframes these policies as sequential decision-making under uncertainty. DAM models memory management over an operation set

$c = \mathrm{POSTRET}(M(k^*), \mathrm{PRERET}(q))$2

defines reward as downstream utility minus operational cost, and optimizes an infinite-horizon discounted objective

$c = \mathrm{POSTRET}(M(k^*), \mathrm{PRERET}(q))$3

It then modulates action values with uncertainty estimators and risk-sensitive penalties, especially for irreversible actions such as eviction (Sun et al., 25 Dec 2025). At the most restrictive end, the Constitutional Memory Architecture imposes a four-layer normative hierarchy—Constitution, Contract, Adaptation, Implementation—in which append-only writes, memory inalienability, and higher-order rule precedence are treated as invariants (Li, 5 Mar 2026).

5. Retrieval, consolidation, forgetting, and efficiency

A recurring systems result is that memory lifecycle quality is constrained as much by maintenance cost and retrieval-set size as by semantic relevance. MemForest addresses this by decoupling extraction from inference through parallel chunking and replacing full-state rewrites with localized per-node updates. On LongMemEval-S it reaches 79.8% pass@1 accuracy while sustaining memory construction throughput approximately 6x higher than state-of-the-art approaches including EverMemOS; at the systems level, insertion touches one leaf-to-root path, giving a dependent refresh depth of $c = \mathrm{POSTRET}(M(k^*), \mathrm{PRERET}(q))$4 (Chen et al., 16 May 2026).

All-Mem bounds online retrieval differently. It restricts coarse search to a curated visible surface and then performs hop-bounded expansion into archived evidence only when needed. Empirically, LongMemEval-s reports median hop 2 and $c = \mathrm{POSTRET}(M(k^*), \mathrm{PRERET}(q))$5, while searching the visible surface at $c = \mathrm{POSTRET}(M(k^*), \mathrm{PRERET}(q))$6 reduces Stage-1 time by approximately 46% versus full-bank search (Lv et al., 20 Mar 2026). AMV-L applies the same bounded-working-set principle to latency control. By restricting request-path eligibility to a hot tier plus a small warm-tier sample, it improves throughput by 3.1x over TTL and reduces latency by 4.2x at the median, 4.7x at p95, and 4.4x at p99, while driving the fraction of requests exceeding 2s from 13.8% to 0.007% (Bamidele, 22 Feb 2026).

Forgetting policies vary widely. ScrapMem introduces Optical Forgetting, which progressively lowers the resolution of older scrapbook pages; on ATM-Bench this reduces memory usage by up to 93% while preserving strong retrieval and achieving 51.0% Joint@10 and 70.3% Recall@10 in its no-forget configuration (Chang et al., 5 May 2026). The LCNC hybrid memory system instead uses an “Intelligent Decay” score

$c = \mathrm{POSTRET}(M(k^*), \mathrm{PRERET}(q))$7

with

$c = \mathrm{POSTRET}(M(k^*), \mathrm{PRERET}(q))$8

so that low-score episodic entries are pruned or consolidated into semantic memory under user-visible controls such as pin, forget, and consolidate (Xu, 27 Sep 2025). Neuromem’s streaming benchmark supports a different conclusion: aggressive compression and generative integration mostly shift cost between insertion and retrieval with limited accuracy gain, while heuristic and lightweight strategies frequently anchor the efficiency frontier (Zhang et al., 15 Feb 2026).

Outside LLM agents, Deca shows that lifecycle-aware memory management can be operationalized at the runtime level. By inferring object lifetimes from dataflow structure and grouping objects with similar lifetimes into byte arrays released en masse, it reduces garbage collection time by up to 99.9%, achieves up to 22.7x speed up in cases without data spilling and 41.6x with spilling, and consumes up to 46.6% less memory (Lu et al., 2016). This suggests that the lifecycle notion extends from semantic memory governance to low-level allocation and reclamation policies.

6. Empirical domains, theoretical directions, and open questions

The contemporary literature uses memory-lifecycle frameworks in person understanding, lifelong task assistance, system serving, multimodal on-device agents, research automation, and scientific or enterprise governance. PersonaTree ranks first in 12 of 18 compact scores and reaches the top two in 16 settings across six person-understanding and persistent-memory benchmarks, with ablations showing that hierarchy improves abstract person understanding and support-path retrieval improves RealPref alignment under a comparable context budget (Hou et al., 3 Jun 2026). ReMe demonstrates a dynamic procedural-memory loop—multi-faceted distillation, context-adaptive reuse, and utility-based refinement—and reports a memory-scaling effect in which Qwen3-8B equipped with ReMe outperforms memoryless Qwen3-14B (Cao et al., 11 Dec 2025). SLM-V3 adds mathematical structure through information geometry, Riemannian Langevin lifecycle dynamics, and cellular sheaf cohomology, reporting +12.7 percentage points over engineering baselines across six LoCoMo conversations and +19.9 pp on the most challenging dialogues (Bhardwaj, 15 Mar 2026).

AutoSci extends the memory-lifecycle concept to the full scientific research lifecycle. Its SciMem, SciFlow, SciDAG, and SciEvolve modules maintain structured persistent memory across literature, ideation, experiment, writing, and rebuttal, with Trust Guard enforcing Pass/Warn/Block on writes. In two end-to-end case studies, the system produced manuscript-oriented outputs in 27.3 hours and 22.6 hours, while feeding review signals back into versioned updates to memory organization, lifecycle skills, and multi-agent templates (Qian et al., 29 May 2026). Human-like lifelong memory frameworks push in a more cognitive direction, specifying functional properties such as context fluidity, real-time tagging without latency, graded epistemic self-awareness, stability by default with update by catharsis, and monotonic convergence toward System 1 (Lerma-Torres, 30 Mar 2026).

Open problems are correspondingly diverse. Deployment-grounded CUA work highlights controllable grounding, long-horizon constraint preservation, safe authority binding, mixed-trust runtime defense, privacy-preserving memory, and continual assurance as unresolved challenges (Chen et al., 8 May 2026). ReMe identifies the limitation of single-shot retrieval at task start and points to mid-episode dynamic retrieval and insertion as a future direction (Cao et al., 11 Dec 2025). PersonaTree notes that current evaluations are text and English, so multimodal or multilingual deployment requires schema extension and validator adaptation (Hou et al., 3 Jun 2026). DAM emphasizes sparse and delayed rewards, calibration of uncertainty for deletion risk, and hierarchical credit assignment as outstanding obstacles to principled memory control (Sun et al., 25 Dec 2025).

Taken together, these lines of work define the memory-lifecycle framework not as a single architecture but as a research program. Its common commitments are explicit transition structure, typed memory objects, controlled write and read paths, maintenance outside the critical path where possible, and mechanisms for retaining what remains useful while preventing stale, contradictory, unsafe, or overly expensive memory from dominating future behavior.