Is Agent Memory a Database? Rethinking Data Foundations for Long-Term AI Agent Memory Abdelghny Orogat
Essam Mansour
Concordia University
Concordia University
arXiv:2605.26252v1 [cs.AI] 25 May 2026
ABSTRACT Long-running AI agents need persistent memory. Memory supports learning across sessions, reduces repeated context injection, and enables auditing of past decisions. Current agent memory systems and database paradigms treat memory as storage. They localize correctness at records, embeddings, or edges. Each supplies only some of the capabilities that long-term memory requires. The result is four recurring failure modes: unregulated growth, missing semantic revision, capacity-driven forgetting, and read-only retrieval. In our vision, long-term agent memory is a new data-management workload. Its correctness is a property of the state trajectory, not of individual records. We formalize this as Governed Evolving Memory (GEM). GEM replaces record-level database operations with four state-level operators: ingestion, revision, forgetting, and retrieval. Six correctness conditions govern how the state evolves. Three structural observations establish that no record-level system can satisfy these conditions, regardless of the storage model. We realize the abstraction in MemState, a prototype on a propertygraph backend. MemState validates feasibility and exposes the gap to a native engine. We outline three research directions that define memory-centric data management as a workload. Key Contributions • A data-centric formalization of long-term agent memory as 𝑀𝑡 = (𝐷𝑡 , 𝑆𝑡 , 𝑃𝑡 ) with four operators (ingestion, revision, forgetting, retrieval) and six correctness conditions • A reframing of agent memory as a new data-management workload, identifying where existing data systems fall short • MemState: a prototype built on an embedded property graph engine demonstrating the proposed foundations • A research agenda for governed, evolving memory in long-lived AI agents Code: § https://github.com/CoDS-GCS/MemState
1
INTRODUCTION
AI agents operate as persistent systems that interact with users, tools, and environments [9, 19, 28]. Unlike question answering systems [25, 26], they must maintain and revise information across sessions [16, 37]. To support this behavior, agents persist information in external memory beyond the context window [20, 29, 34, 39, 43]. This persistent state shapes whether agent behavior remains stable as interactions accumulate or its performance degrades [16, 42]. Long-term memory therefore changes what agents can do. It lets agents learn across tasks and sessions by carrying prior decisions and constraints forward. It also reduces inference cost and latency by avoiding repeated context injection. Current memory designs do not preserve these properties. Most instead follow an accumulation strategy that continuously appends new information while leaving stored entries unchanged [19, 28, 34,
T0 (Week 0)
T1 (Week 1)
T0: 1:30 PM Project: Website Redesign | Deadline: March 15
T0: 1:30 PM Project: Website Redesign | Deadline: March 15
...
...
① UNREGULATED GROWTH
T1: 1:00 PM Project: Website Redesign | Deadline: March 15
Redundant entries accumulate without consolidation.
② MISSING SEMANTIC REVISION Updated facts coexist with outdated ones.
③ ABSENCE OF SELECTIVE
FORGETTING Eviction by age, not relevance to the user.
④ READ-ONLY RETRIEVAL
Retrieval leaves memory state unchanged.
T2 (Week 2)
... T1: 1:03 PM Deadline UPDATED: April 20 T1: 1:33 PM
T1: 1:33 PM
T1: 2:30 PM Project completed
T1: 2:30 PM Project completed
Discussed lunch preferences
What is the deadline of Website Redesign ? March 15 Redundant
Low Relevance
Discussed lunch preferences
... What is the deadline of Website Redesign ? I do not know Outdated Info
Query operation
Figure 1: Agent memory as an append-only record store over three weekly snapshots. Built on database operations, it appends new records and evicts old ones by age, never consolidating the state. This exposes four failures (①, ②, ③, and ④). 39, 43]. Figure 1 traces this behavior over three weekly snapshots of the same memory. Each column represents the memory state at one week, and each box represents a stored entry. From Week 0 to Week 1, new records are added and redundant entries accumulate. As the state grows, updated facts remain beside obsolete ones. By Week 2, older entries are evicted by age rather than by their importance to the user. Retrieval then operates over this evolving clutter. These behaviors already appear in daily LLM applications. ChatGPT [27] and Claude [2] retain user preferences yet still surface outdated facts as current. Cursor [4] and Claude Code [3] learn a codebase yet lose earlier decisions as context grows. The cost falls on the user. Users re-explain context the system has already seen. They pay rising inference cost as context grows. These systems inherit record-level CRUD operations (create, read, update, delete) from traditional databases. As a result, memory operations act on individual records rather than on the evolving memory state itself. This mismatch produces the four recurring failure modes shown in Figure 1. ① Unregulated growth. Append-only ingestion accumulates redundant and low-relevance entries. When the user re-explains a task, the same facts are ingested again (e.g., the project record “Website Redesign | Deadline: March 15” is stored twice at Week 1). These redundant entries compete at retrieval time and consume LLM context window space, crowding out useful content. ② Missing semantic revision. Updates are appended rather than integrated into existing entries. At Week 1, “Deadline UPDATED: April 20” is stored as a new entry while “Deadline: March 15” remains. A query “What is the deadline of Website Redesign?” may return “March 15” instead of “April 20” (based on semantic similarity between the query and message embeddings) [16, 37].
Abdelghny Orogat and Essam Mansour
Table 1: Coverage of the four capabilities required by governed memory across database paradigms and agent memory systems. Each cell describes how the family addresses the capability. “None” denotes no native support. No family supports all four, and each contributes one substrate strength the others lack. Relevance-driven retention
Dependency-aware propagation
Graded attenuation
State-modifying retrieval
Substrate strength
None None None None None
Foreign key only None Typed, entity-grain None Geometric proximity
None None None None None
None None None None None
Schema, ACID Flexible or no schema Typed structural relations Versioned histories Semantic similarity
Tiered (MemGPT, MemOS) Fact-extraction (Mem0) Graph-structured (Zep) Consolidation-based (MIRIX, EverMemOS) RL-driven (Mem-𝛼 , Memory-R1)
None None None None None
None None Single-edge invalidation None None
None None None Foresight expiry None
None None None None None
Two-level paging Atomic fact maintenance Bi-temporal edges Typed components, scene consolidation Learned update policies
Generative Agents
Importance ranking
None
None
Recency on access
Importance + reflection
Family Database paradigms Relational Key-value / Document RDF / Property Graph Temporal DB Vector DB Agent memory systems
③ Absence of selective forgetting. Memory must evict content as storage fills. But eviction is driven by age or capacity rather than by importance to the user. At Week 2 in Figure 1, the project deadline is evicted while the low-relevance entry “Discussed lunch preferences” persists. The same deadline query now returns “I do not know,” even though the user asked it before. The system cannot retain facts according to their relevance to the user [21]. ④ Read-only retrieval. Retrieval returns facts but never updates the memory state [42]. The user queries the project deadline every week, yet that entry gains no importance and is later evicted like any other (Failure ③). User interaction patterns cannot reinforce useful information or protect it from forgetting. Frequently accessed facts therefore compete with stale content on equal terms. These limitations reflect an abstraction gap, not implementation issues. Each failure traces to one CRUD operation: create cannot integrate, update cannot propagate, delete cannot regulate relevance, and read cannot adapt. Larger context windows or better retrieval do not resolve this mismatch [16, 37]. The limitation lies in missing evolution semantics, not in retrieval quality. Contributions. This paper positions long-term agent memory as a new data-management workload whose correctness lives in the state trajectory, not in individual records. Our contributions are: • A four-capability analytical lens (relevance-driven retention, dependency-aware propagation, graded attenuation, and statemodifying retrieval) showing that no database paradigm or agent memory system supplies all four (Section 2). • Governed Evolving Memory (GEM), a state abstraction that replaces record-level CRUD with four state-level operators (ingestion, revision, forgetting, retrieval) and defines six correctness conditions over the state trajectory. Three structural observations show that no CRUD-based system can satisfy these conditions, regardless of substrate (Section 3). • MemState, a prototype that realizes GEM on a property-graph backend with topic-based storage, typed dependencies, and declarative policies. The prototype validates feasibility and exposes what a native engine must provide (Section 4). • A research agenda of three directions covering a native engine, trajectory-level correctness, and privacy under multi-tenant memory, with explicit success criteria. (Section 5).
2
WHY CURRENT ABSTRACTIONS FAIL
We examine database paradigms and recent agent memory systems through four capabilities required by governed memory. Each is a column in Table 1 and a failure mode in Figure 1. Table 1 covers five database paradigms and five families of agent memory systems, plus Generative Agents [32] as the closest single approach. Each contributes one substrate strength. None covers all four capabilities. Database paradigms and memory families. Database paradigms differ by what they store and how they update. Relational stores manage records under a fixed schema [8]. Key-value and document stores relax this, using no schema or a flexible one [6, 10]. RDF and property graphs add typed relations between entities [1, 14, 23, 33]. Temporal databases version tuples to preserve history [17, 35]. Vector databases index embeddings for semantic similarity [30, 38]. Agent memory systems group into five families by their primary mechanism. Tiered designs (MemGPT [29], MemOS [20]) implement two-level paging: a small in-context active tier and a larger external storage tier. Evicting from the active tier by age or size when it fills. Fact-extraction systems (Mem0 [7]) parse interactions into atomic facts and overwrite on conflict. Graph-structured systems (Zep [34]) link entries via typed edges and invalidate them bi-temporally to preserve history. Consolidation-based systems (MIRIX [39], EverMemOS [15]) route content into specialized memory types and cluster related entries into higher-level structures. RL-driven systems (Mem-𝛼 [40], Memory-R1 [44]) learn update policies by reinforcement, rewarding operations by downstream answer quality. Generative Agents [32] rank memories by importance and update recency on read. Each family contributes one substrate strength; Table 1 shows where each falls short. The rest of this section examines each capability in turn.
2.1
Relevance-Driven Retention
Relevance-driven retention bounds active memory by utility, stabilizing inference cost as interactions grow. Without it, memory grows monotonically and redundant entries crowd out useful ones (failure mode ①). Database paradigms cap growth by capacity or time, not utility. Relational and document stores use TTL expiry or manual delete [11]; temporal databases enforce retention windows on versioned tuples [17]; vector databases prune embeddings by capacity
Is Agent Memory a Database? Rethinking Data Foundations for Long-Term AI Agent Memory
or age [31, 38]. High- and low-utility facts age out equally (in Figure 1, “Discussed lunch preferences” expires on the same schedule as the project deadline). No paradigm bounds memory by relevance. Agent memory systems repeat the pattern. Tier-based, lifecyclebased, capacity-based, and learned-controller eviction all key on age or size [7, 15, 20, 29, 40, 44]. Generative Agents [32] come closest. They combine an importance score with recency decay to rank observations at retrieval. Both are local heuristics applied at retrieval time, not policies that bound the active footprint. Memory grows because low-importance observations are never attenuated.
2.2
Dependency-Aware Propagation
Dependency-aware propagation keeps related facts consistent when one changes. The agent then reasons over coherent state rather than divergent values. Without it, contradictions yield wrong answers (failure mode ②). Database paradigms offer two relevant techniques, neither propagating along semantic dependencies. Active databases [5, 41] propagate via ECA rules over flat relational state, so updates are referential, not content-aware. Materialized view maintenance [24] propagates along fixed view schemas, not evolving semantic units. Elsewhere, append-only relational and vector stores return outdated and current values [8, 30, 38]; in-place updates destroy the evidence chain [6, 10]; temporal stores return superseded values as current [17, 35]; and property graph or RDF stores desynchronize at entity grain [1, 13, 14, 23, 33]. No DBMS re-evaluates dependent facts when one fact changes. Agent memory systems inherit the gap. Mem0 [7] overwrites or deletes on conflict, destroying the evidence chain. Zep [34] invalidates edges bi-temporally. It is the strongest mechanism but operates one edge at a time. In Figure 1, invalidating the deadline edge at Week1 does not re-evaluate edges to team assignments or meetings. Dependencies then drift silently. Consolidation-based systems [15, 39] overwrite or re-cluster at component grain, not along dependencies. RL-driven systems [40, 44] update without dependency structure.
2.3
Graded Attenuation
Graded attenuation deprioritizes obsolete content while preserving history for audit, unlike tiering, which moves whole entries by capacity. Without it, obsolete entries compete with current ones (failure mode ③). Database paradigms attenuate by time or capacity. TTL, retention windows, and version pruning act on age and size, not importance [17, 35, 38]. Removal is binary. No paradigm demotes content while keeping it recoverable. In Figure 1, the high-utility project deadline ages out while a low-relevance entry survives. Agent memory systems evict by FIFO, lifecycle stage, or store size [15, 20, 29], or delete locally [7], without relevance. EverMemOS [15] is the partial exception. It expires time-bounded foresight at retrieval while keeping the rest. Zep [34] caches ingestiontime summaries that aid retrieval but can inflate the store [7]. Generative Agents [32] rank observations at retrieval by recency, importance, and relevance but never attenuate them from the store.
Input It
① REGULATED MEMORY GROWTH New information is integrated into memory state instead of blindly appended.
Dt
Dt Revision U(Δ)
St
Retrieval Rq
④ RETRIEVAL-INDUCED
Dt
STATE EVOLUTION Retrieval reinforces important facts and updates memory structure.
Dt Forgetting F
Dt
evidence Δ
③ SELECTIVE FORGETTING
② SEMANTIC REVISION
Reconciles and consolidates existing facts to maintain a consistent memory state.
Output o
Memory State: Mt
Ingestion U(It )
Evolution Policies: Pt
Completed tasks are summarized or attenuated based on usage, preventing reuse of obsolete information.
Figure 2: Our GEM Abstraction. The state 𝑀𝑡 = (𝐷𝑡 , 𝑆𝑡 , 𝑃𝑡 ) holds semantic units (𝐷𝑡 ), their structural organization (𝑆𝑡 ), and declarative evolution policies (𝑃𝑡 ). These three elements must be explicit in any compliant implementation; their realization varies by backend. Four state-level operators replace record-level CRUD: ingestion, revision, forgetting, retrieval.
2.4
State-Modifying Retrieval
State-modifying retrieval updates salience on each read so important content stays prominent and stale content fades. Without it, accessed and stale facts compete equally (failure mode ④). Database paradigms treat retrieval as a pure read. A query returns content and leaves state unchanged. Recent retrieval indexes scale read-only access [22] but do not let a read update the state it reads. Agent memory systems do the same. In Figure 1, the Week1 deadline query returns the stored value without reinforcing it, propagating access, or shaping future retrievals. Zep[34] reranks by mention frequency, a read-time heuristic, not a committed state change. Generative Agents [32] update a memory’s recency on access, but only as an embedded heuristic with no correctness condition. Governed memory needs retrieval as a first-class operator that returns output and a state transition (Section 3). ★ Is Agent Memory a Database? No. CRUD governs records; correctness here lives in the state trajectory. Agent memory is a new data-management workload, not a database problem.
3
GOVERNED EVOLVING MEMORY
This section introduces our Governed Evolving Memory (GEM), the abstraction that supplies the four capabilities. Memory is a global state that evolves through structured operations rather than append-only accumulation. Figure 2 illustrates GEM.
3.1
Memory State
Three elements must be explicit in the data model. Content 𝐷𝑡 specifies what is stored. Structure 𝑆𝑡 specifies how stored elements connect. Policies 𝑃𝑡 specify how the state is allowed to change. If any element remains implicit, evolution semantics cannot be enforced. A semantic unit is the atom of 𝐷𝑡 , carrying a value history and a salience signal. Its boundary is a design decision. Finer units scatter related facts across boundaries, requiring graph traversal at retrieval and risking partial recall.
Abdelghny Orogat and Essam Mansour
Definition 1 (Governed Evolving State). At time 𝑡, an agent’s memory state is the tuple 𝑀𝑡 = (𝐷𝑡 , 𝑆𝑡 , 𝑃𝑡 ), where 𝐷𝑡 denotes stored content organized as semantic units that hold all related data elements, 𝑆𝑡 denotes the structural organization over that content, and 𝑃𝑡 denotes policies governing access, ingestion, revision, and forgetting.
C3 (Dependency consistency). For every pair (𝑢𝑖 , 𝑢 𝑗 ) connected by a typed edge 𝑒 ∈ 𝑆𝑡 with propagation semantics, an update to 𝑢𝑖 triggers evaluation of 𝑢 𝑗 under 𝑃𝑡 .
Definition 2 (Memory Evolution). Memory evolves according to a state transition function 𝑀𝑡 +1 = U (𝑀𝑡 , 𝐼𝑡 , 𝑅𝑡 ), where 𝐼𝑡 is new external input and 𝑅𝑡 is an internal operation that may alter state. The sequence {𝑀𝑡 }𝑡 ≥0 is the memory trajectory.
C5 (Bounded active state). For every interaction count 𝑛, the active memory satisfies |𝐷𝑡active | ≤ 𝛽 (𝑛) for a policy-defined bound 𝛽; archived content remains recoverable.
Definition 3 (Evolution Policies). 𝑃𝑡 is a set of typed rules ⟨event, condition, action⟩, where event identifies the operation that triggers evaluation, condition is a predicate over 𝑀𝑡 , and action is a state-level transition. Policies are declarative: they specify what transitions occur and when, independent of how operators execute them.
3.2
C6 (Retrieval-induced adaptation). Every retrieval that accesses 𝑢𝑖 induces a transition in which the salience of 𝑢𝑖 is updated. Repeated retrieval strictly reduces 𝑢𝑖 ’s eligibility for attenuation. C1–C2 govern what queries return. C3–C4 govern what the state preserves. C5–C6 govern how the state adapts. They define correctness as a property of {𝑀𝑡 }𝑡 ≥0 , not of any individual record. Every failure mode in Figure 1 reduces to the violation of at least one.
State-Level Operators
Four operators act over global memory under policy constraints, each supplying one capability from Section 2. Ingestion integrates input 𝐼𝑡 into the existing state by producing 𝑀𝑡 +1 = U (𝑀𝑡 , 𝐼𝑡 , ∅) under constraints in 𝑃𝑡 . An updated value is recorded against the existing semantic unit; the prior value is retained as historical evidence. Revision produces 𝑀𝑡 +1 = U (𝑀𝑡 , ∅, rev(Δ)) from internal evidence Δ under 𝑆𝑡 and 𝑃𝑡 . It reconciles overlapping units, propagates updates along 𝑆𝑡 , and preserves superseded values with provenance. Forgetting is a policy-governed transition 𝑀𝑡 +1 = U (𝑀𝑡 , ∅, F ), where F regulates the influence of stored content by relevance signals without destructive deletion. Content in 𝐷𝑡 carries salience signals that rise on access and decay on disuse, at sub-unit granularity, so part of a unit may be attenuated while the rest stays current. Attenuation runs as a ladder from partial compression to full archiving, so the operator is graded rather than binary. Retrieval maps query 𝑞 to output 𝑜 via R (𝑀𝑡 , 𝑞) → 𝑜 and induces 𝑀𝑡 +1 = U (𝑀𝑡 , ∅, R𝑞 ) under 𝑃𝑡 . Every read updates the salience of accessed units, so retrieval is a state transition rather than a read-only operation.
3.3
C4 (Provenance preservation). Forgetting and revision preserve the provenance chain of any unit that remains reachable.
Memory Correctness
Correctness cannot be defined at the level of individual records, because contradictory or outdated entries may coexist within 𝐷𝑡 . Correctness is a property of the trajectory along three axes: what queries return, what the state preserves, and how the state adapts. Definition 4 (Memory Correctness). Let 𝑢𝑖 ∈ 𝐷𝑡 be a semantic unit with a value history 𝑉𝑖 = ⟨(𝑣 1, 𝑡 1, 𝜋1 ), . . . , (𝑣𝑘 , 𝑡𝑘 , 𝜋𝑘 )⟩, where each entry records a value 𝑣, a timestamp 𝑡, and provenance 𝜋. A memory system is correct if the following six conditions hold. C1 (Query soundness). The response R (𝑀𝑡 , 𝑞) → 𝑜 reflects the most recent non-archived value 𝑣𝑘 as current; prior values appear only when 𝑞 explicitly requests historical context. C2 (Transition soundness). Every transition 𝑀𝑡 → 𝑀𝑡 +1 respects 𝑃𝑡 , and no revision produces a state in which a superseded value is returned as current.
3.4
Three Structural Observations
The four operators are not a recombination of CRUD: Observation 1 (Retrieval). A pure-function retrieval operator cannot satisfy C6. C6 requires retrieval itself to induce a state transition. Caches, materialized views, and post-retrieval triggers can record that an access occurred, but they cannot lift the operator out of being a pure function, because the state-modifying step is decoupled from the query. Observation 2 (Forgetting). C5 in its relevance-driven form is jointly unenforceable with C6 above any CRUD-based engine. If retrieval is read-only, relevance must be approximated by external signals, and capacity-driven or time-based attenuation can bound size but not relevance. Observation 3a (Ingestion). Append-only storage without semantic units cannot satisfy C2. Two appended values for the same fact coexist with equal status, and a default query has no engine-level mechanism to select between them. Observation 3b (Revision). Untyped propagation cannot satisfy C3. Updates propagate along exact-match references or untyped edges, so dependencies that the abstraction requires to re-evaluate are not visible to the engine. These are structural claims, not theorems. Their consequence: governed memory requires four state-level operators inside the data model, with 𝑃𝑡 checked at commit and retrieval treated as a write.
4
REALIZING GEM IN MEMSTATE
We instantiate GEM (Section 3) in our prototype, MemState1 . The data model supplies C1, C3, and C4 by construction and lifts C2 to a data-model guarantee. The four operators of Section 3.2 run over this data model and supply C5 and C6 under transitions.
4.1
Data Model
MemState realizes 𝑀𝑡 = (𝐷𝑡 , 𝑆𝑡 , 𝑃𝑡 ) as an evolving graph of topics on Kuzu [13], an embedded property graph engine. Each topic is a self-contained semantic unit with a title, a summary, a dense embedding, and a set of fields with value histories (Figure 3(a)). 1 Code: https://github.com/CoDS-GCS/MemState.
Is Agent Memory a Database? Rethinking Data Foundations for Long-Term AI Agent Memory (b) Topics Graph
(a) One topic Topic: Website Redesign Field
Value
Time
Deadline
April 20
T1: 1:03 PM
March 15 [Alice
Team
(Frontend),
T0: 1:30 PM
Topic: Website Redesign
Provenance Who? Why? …
association
-
T1: 1:00PM
History -
T0: 1:32 PM
-
-
-
extension
T1: 2:30 PM
-
-
-
Topic: Alice
-
Bob
Topic: New project idea
(Backend)]
Status Meeting
Complete
Feb 10
T1: 1:02 PM
-
Low Salience, to be- forgotten
Potential Topic Split
Figure 3: MemState data model. (a) A self-contained topic stores fields, values, histories, and provenance; low-salience content can be forgotten. (b) Topics form a typed graph through association and extension edges; revision may promote subsets (e.g., Alice) into new topics. Self-contained topics with field histories (C1, C4). A topic groups all fields of one concept in a single unit; entity-grain designs (Zep) scatter attributes across nodes, requiring multiple accesses to reconstruct one concept. Each field is maintained as a history 𝐻𝑖,𝑗 = ⟨(𝑣, 𝑡, 𝜋)⟩: updates append a new entry rather than overwrite. Default retrieval returns only 𝑣𝑘 (C1); explicit temporal queries can read any 𝑣 𝑗 and its provenance (C4). Once sufficient knowledge accumulates around a subset of fields, revision promotes it into a standalone topic: Alice splits out of Website Redesign once enough interactions reference her directly (Figure 3(a,b)). Typed edges in 𝑆𝑡 (C3). 𝑆𝑡 distinguishes two edge types (Figure 3(b)). Extension edges connect topics where a change in one can entail a change in the other; a deadline change on Website Redesign may entail a milestone reschedule. Association edges connect related but independent topics. C3 propagation must follow entailment, not relatedness, so revision traverses extension edges only. Association edges support retrieval context expansion without propagation. Declarative policies 𝑃𝑡 in state (C2). Policies live inside 𝑀𝑡 as ⟨event, condition, action⟩ rules whose conditions reference 𝑀𝑡 directly (Definition 3). The postcondition on a proposed 𝑀𝑡 +1 is evaluated against 𝑃𝑡 before commit, and a violating transition is rejected. This lifts C2 to a data-model-level guarantee, closing Observation 3a. Listing 1 shows a representative policy. Policies can be added, modified, or replaced without changing operator code.
4.2
Operators on the Kuzu Substrate
State evolution is realized through the four operators of Section 3.2. Ingestion and retrieval are client-facing and synchronous. Revision and forgetting run asynchronously as policy-triggered maintenance. Algorithm 1 shows their unified template on Kuzu. An incoming event is dispatched to one of four operator branches (lines 3–12), each writing through field-level, topic-level, and graph-level primitives on the property graph. 𝑃𝑡 is then evaluated against the proposed 𝑀𝑡 +1 and the transition either commits atomically or aborts (line 14). The atomic commit is the mechanism that lifts C2 to a data-model-level guarantee. The salience increment inside the retrieval branch (line 11) is the mechanism for C6. Ingestion. The LLM reads topic titles and summaries to select a host topic, then reads the topic schema to place the new value in an existing or new field. For the deadline update from Figure 1, the new entry (April 20,𝑇1, 𝜋1 ) is appended to 𝐻 deadline while (March 15,𝑇0, 𝜋0 )
Listing 1: A representative MemState policy: when a field changes, mark dependent topics for revision (C3). POLICY propagate-on-change ON field_updated WHEN EXISTS dependent_topic DO flag_for_revision(dependent_topic) WITH evidence = {updated_field, timestamp}
Algorithm 1 GEM transition on a property-graph substrate. Require: Memory state 𝑀𝑡 = (𝐷𝑡 , 𝑆𝑡 , 𝑃𝑡 ); event 𝑒 ∈ {𝐼𝑡 , 𝑞, Δ} Ensure: Updated state 𝑀𝑡 +1 ; output 𝑜 if 𝑒 = 𝑞 1: op ← dispatch(𝑒 ) ⊲ ingest, revise, forget, retrieve 2: begin transaction 3: if op = ingest then 4: LLM picks host topic 𝜏; for each fact ( 𝑓 , 𝑣, 𝑡, 𝜋 ), append to 𝐻𝜏,𝑓 or create 𝑓 ; refresh 𝜏’s embedding; flag extension-linked topics 5: else if op = revise then 6: apply repair (conflict, merge, propagate) for each evidence 𝛿 ∈ Δ 7: else if op = forget then 8: attenuate each 𝑢 with salience(𝑢 ) < 𝜃 ∗ (compress, hide, archive) 9: else if op = retrieve then 10: route 𝑞; read selected units; build 𝑜; increment salience of accessed units ⊲ C6 11: end if 12: evaluate 𝑃𝑡 on proposed 𝑀𝑡 +1 ; commit if all postconditions hold, else abort ⊲ atomic commit lifts C2 13: return 𝑀𝑡 +1 (and 𝑜 if applicable)
remains. The embedding is refreshed and extension-linked topics are flagged for revision. C1, C2, and C4 hold by construction. Revision. Revision detects evidence items in 𝑀𝑡 (duplicate topics, conflicting field values, schema drift, dependency inconsistencies) and applies the corresponding repair. Dependency repair walks extension edges, halting at any topic whose policy condition does not fire. Topic granularity keeps this frontier far smaller than an entitygrain graph (Zep), so the walk terminates in few hops. This supplies the dependency-aware propagation capability of Section 2.2 at the global level. Conflict resolution marks superseded values with their provenance rather than deleting them, preserving C4. Forgetting. Each field maintains a salience score that rises on access and decays on disuse. Three thresholds define a graded ladder. Below 𝜃 summary , a history is compressed. Below 𝜃 remove , a field is hidden from active retrieval. Below 𝜃 archive , the topic is archived but remains recoverable through explicit lookup. Retention is driven by salience rather than age or capacity, satisfying C5. Retrieval routes a query into topic-based, temporal, or structural mode. In topic-based mode, it inspects titles and summaries, selects candidate topics, reads schemas, and reads required field values. For “What is the deadline for the Website Redesign?” it returns the current Deadline value. The salience increment on every accessed unit is part of the operator semantics, closing Observation 1.
4.3
From Prototype to Native Engine
What MemState validates. MemState is a feasibility sketch on a property-graph substrate. GEM is realizable on commodity infrastructure: topics, field histories, embeddings, and policy postcondition checks all attach to one Kuzu transaction, so C1, C2, and C4 hold by construction and C5, C6 hold under transitions.
Abdelghny Orogat and Essam Mansour
What MemState exposes. The substrate is a compatibility layer, not a native expression of GEM. Field histories, propagation-bearing edges, and postcondition-checked commits are reconstructed from generic graph primitives, so several optimizations are not directly expressible. A native engine would store field histories as first-class bitemporal attributes, attach propagation semantics to extension edges in the schema, and compile policy postconditions into the commit protocol. Retrieval-induced salience updates would compile into a single read-modify-write primitive, and relevance-driven forgetting would be scheduled like index maintenance. These are not implementation gaps; they are research directions for a datamanagement workload that no current engine targets.
5
RESEARCH AGENDA
This section presents three research directions and the success criteria of the vision. The directions follow from GEM and MemState, grounded in capabilities no current engine supports natively. A Native Engine for Governed Memory. MemState reconstructs topic records, field histories, propagation-bearing edges, and policychecked commits from generic property-graph primitives, at a compatibility-layer cost. A native engine must address three problems. (i) Storage layout: co-locate topics, field histories, and embeddings on pages to reduce I/O cost per read, following the node and neighbor co-location used in graph-based vector engines [36], adapted to units that carry both a value history and typed dependencies. (ii) Unified indexing: jointly support semantic similarity and history predicates, so vector-based, temporal, and structural queries route through the same physical organization without duplicating data. (iii) Retrieval as a write: C6 requires every read to update salience, but existing query languages separate reads from writes [14, 18, 33] and existing indexes optimize read-only access at scale [22]. A native engine needs an operator that unifies search, traversal, temporal lookup, and salience updates, with a buffer strategy that keeps hot topics and dependency context resident. First targets: (i) an I/O-aware page layout for topics with field histories and extension edges, (ii) a joint index over semantic similarity and history predicates, and (iii) the consistency cost of retrieval-induced salience updates under concurrent access. Correctness and Evaluation. Correctness in GEM is a property of the state trajectory {𝑀𝑡 }𝑡 ≥0 , not of individual records. Three sub-problems follow. (i) Trajectory benchmark. Current benchmarks measure answer-level recall and exercise C1 only partially [16, 21, 37, 42]. A system that overwrites history or never forgets can still score well if its recent answers are correct. A trajectory benchmark needs ground truth at three levels: the current value of each unit over time (C2), the dependent units that change after each update (C3), and the active footprint at each interaction count (C5). No existing benchmark provides all three. (ii) Policy language for conflict resolution. Existing systems either overwrite on conflict [7] or invalidate edges through an LLM gate that silently misses contradictions [34]. A declarative policy language must express conflictresolution rules over field histories with provenance, exploiting typed edges rather than LLM gating. (iii) Constrained learned controllers. Mem-𝛼 [40] and Memory-R1 [44] learn update policies over flat fact stores without 𝑆𝑡 or field histories. The open problem is a controller that optimizes within trajectory-level constraints
enforced by the commit protocol. First targets: (i) a 500-turn adversarial workload scoring Mem0, Zep, and MemState on answerand trajectory-level metrics, (ii) a policy language prototype on LongMemEval [42] and LoCoMo [21], and (iii) an RL controller trained against C2–C5 constraints. Privacy and Multi-Tenancy. A third direction concerns shared memory. Production agents often serve multiple tenants over a common memory instance, which introduces two problems that do not arise in single-tenant settings. (i) Retrieval-induced information leakage. C6 makes retrieval a write operation. If tenant 𝐴’s query reinforces topic 𝜏, the salience update is committed to 𝑀𝑡 as a state transition. A later query from tenant 𝐵 surfaces 𝜏 through similarity ranking because its salience score is high. The salience signal acts as an information leakage path across tenant isolation boundaries, even when topic content is access-controlled. Existing memory systems treat retrieval as a read-only operation and do not account for this side effect. (ii) Verifiable erasure under evolving state. Privacy regulations require provable removal of a tenant’s data upon request. GEM makes erasure strictly harder than relational delete, because a forgetting operator must compose with C4 (provenance preservation) and C6 (derived salience). A tenant’s data shapes provenance chains on other topics and salience aggregates that influenced other tenants’ query results. Deleting the base records does not erase these derived signals. Data exchange research [12] addresses cross-boundary consistency but not privacy-preserving forgetting over an evolving state trajectory. First targets: (i) the information leakage rate between two tenants on a shared MemState instance and a retrieval operator with bounded salience side effects, and (ii) a forgetting operator that erases derived salience and provenance traces under C4 and C6. Success Criteria. The vision succeeds when four conditions hold. (i) At least one DBMS exposes governed-evolution operators as first-class primitives, and agent frameworks declare retention and propagation policies declaratively. (ii) Standardized trajectory-level benchmarks measure C2–C6 violations across long interaction histories. (iii) Long-horizon deployments show measurable reductions in temporal-reasoning errors attributable to GEM-conformant memory. (iv) Privacy and forgetting guarantees over evolving memory become as well-understood as ACID guarantees over transactional storage. The arc parallels stream processing, which became a recognized workload once continuous state and event-time semantics moved from application code into the data model.
6
CONCLUSION
Long-term agent memory is the workload behind every persistent AI agent, but no current system treats it as one. We argued that its correctness is a property of the state trajectory, not of individual records. This paper envisions Governed Evolving Memory, an abstraction that enforces this property through four state-level operators and six correctness conditions. Our MemState prototype realizes the abstraction on a property-graph substrate and exposes what a native engine must deliver. Three directions define memory-centric data management as a workload: a native engine for governed memory, trajectory-level correctness and evaluation, and privacy under shared salience. The vision succeeds when long-term memory joins transactions and streams as a recognized data-management workload.
Is Agent Memory a Database? Rethinking Data Foundations for Long-Term AI Agent Memory
REFERENCES [1] Renzo Angles and Claudio Gutierrez. 2008. Survey Of Graph Database Models. ACM Computing Surveys (CSUR) 40, 1 (2008), 1–39. https://dl.acm.org/doi/ pdf/10.1145/1322432.1322433 [2] Anthropic. 2025. Claude. Anthropic (2025). https://www.anthropic.com [3] Anthropic. 2025. Claude Code. Anthropic (2025). https://www.anthropic. com/claude-code [4] Anysphere. 2025. Cursor. Anysphere (2025). https://cursor.com [5] Stefano Ceri and Jennifer Widom. 1990. Deriving Production Rules for Constraint Maintenance. In Proceedings of the International Conference on Very Large Data Bases (VLDB). 566–577. [6] Fay Chang, Jeffrey Dean, Sanjay Ghemawat, Wilson C. Hsieh, Deborah A. Wallach, Mike Burrows, Tushar Chandra, Andrew Fikes, and Robert E. Gruber. 2008. Bigtable: A Distributed Storage System For Structured Data. ACM Transactions on Computer Systems (TOCS) 26, 2 (2008), 1–26. https://dl.acm.org/doi/ pdf/10.1145/1365815.1365816 [7] Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav. 2025. Mem0: Building Production-Ready AI Agents With Scalable Long-Term Memory. arXiv Preprint (2025). https://arxiv.org/pdf/2504.19413 [8] Edgar F. Codd. 1970. A Relational Model of Data for Large Shared Data Banks. Commun. ACM 13, 6 (1970), 377–387. https://dl.acm.org/doi/pdf/10. 1145/362384.362685 [9] CrewAI Inc. 2025. CrewAI: A Framework For Building Role-Based Multi-Agent Systems With LLMs. https://www.crewai.com/. Accessed: 2026. [10] Giuseppe DeCandia, Deniz Hastorun, Madan Jampani, Gunavardhan Kakulapati, Avinash Lakshman, Alex Pilchin, Swaminathan Sivasubramanian, Peter Vosshall, and Werner Vogels. 2007. Dynamo: Amazon’s Highly Available Key-Value Store. ACM SIGOPS Operating Systems Review 41, 6 (2007), 205–220. https: //dl.acm.org/doi/pdf/10.1145/1323293.1294281 [11] Ramez Elmasri and Shamkant Navathe. 2016. Fundamentals Of Database Systems. Pearson. [12] Ronald Fagin, Phokion G Kolaitis, Renee J Miller, and Lucian Popa. 2005. Data Exchange: Semantics and Query Answering. Theoretical Computer Science (2005). [13] Xiyang Feng, Guodong Jin, Ziyi Chen, Chang Liu, and Semih Salihoğlu. 2023. Kùzu Graph Database Management System. In Conference on Innovative Data Systems Research (CIDR). https://vldb.org/cidrdb/papers/2023/p48-jin. pdf [14] Nadime Francis, Alastair Green, Paolo Guagliardo, Leonid Libkin, Tobias Lindaaker, Victor Marsault, Stefan Plantikow, Mats Rydberg, Petra Selmer, and Andres Taylor. 2018. Cypher: An Evolving Query Language For Property Graphs. In Proceedings of the ACM SIGMOD International Conference on Management of Data (SIGMOD). 1433–1445. https://dl.acm.org/doi/pdf/10.1145/ 3183713.3190657 [15] Chuanrui Hu, Xingze Gao, Zuyi Zhou, Dannong Xu, and et al. 2026. EverMemOS: A Self-Organizing Memory Operating System for Structured Long-Horizon Reasoning. arXiv preprint arXiv:2601.02163 (2026). https://arxiv.org/abs/ 2601.02163 [16] Yuanzhe Hu, Yu Wang, and Julian McAuley. 2025. Evaluating Memory In LLM Agents Via Incremental Multi-Turn Interactions. In Proceedings of the ICML 2025 Workshop on Long-Context Foundation Models (ICML). https://openreview. net/forum?id=ZgQ0t3zYTQ [17] Christian S. Jensen and Richard T. Snodgrass. 2002. Temporal Data Management. IEEE Transactions on Knowledge and Data Engineering 11, 1 (2002), 36– 44. https://vbn.aau.dk/ws/files/310302702/tdb_tutorial_ed_csj_4_ uncommented.pdf [18] Haridimos Kondylakis, Stefania Dumbrava, Matteo Lissandrini, Nikolay Yakovets, Angela Bonifati, Vasilis Efthymiou, George Fletcher, Dimitris Plexousakis, Riccardo Tommasini, Georgia Troullinou, et al. 2025. Property Graph Standards: State of the Art and Open Challenges. Proc. VLDB Endowment (PVLDB) (2025). [19] LangChain Inc. 2026. LangGraph: A Library For Building Multi-Agent Workflows With LLMs. https://docs.langchain.com/oss/python/langgraph/. Accessed: 2026. [20] Zhiyu Li, Shichao Song, Chenyang Xi, Hanyu Wang, Chen Tang, Simin Niu, Ding Chen, Qingchen Yang, Pengyuan Yu, and Jiahao Huo. 2025. MemOS: A Memory OS For AI System. arXiv Preprint (2025). https://arxiv.org/pdf/2507.03724 [21] Adyasha Maharana, Dong-Ho Lee, Sergey Tulyakov, and Mohit Bansal. 2024. Evaluating Very Long-Term Conversational Memory Of LLM Agents. In Proceedings of the Annual Meeting of the Association for Computational Linguistics (ACL). 13851–13870. https://aclanthology.org/2024.acl-long.747.pdf [22] Yu A. Malkov and Dmitry A. Yashunin. 2018. Efficient And Robust Approximate Nearest Neighbor Search Using Hierarchical Navigable Small World Graphs. IEEE Transactions on Pattern Analysis and Machine Intelligence 42, 4 (2018), 824–836. https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=8594636 [23] Thomas Neumann and Gerhard Weikum. 2010. x-RDF-3X: Fast Querying, High Update Rates, And Consistency For RDF Databases. Proceedings of the VLDB Endowment (PVLDB) 3, 1-2 (2010), 256–263. https://vldb.org/pvldb/vol3/ R22.pdf
[24] Dan Olteanu. 2024. Recent Increments in Incremental View Maintenance. In PODS. 12–25. https://doi.org/10.1145/3635138.3654763 [25] Reham Omar, Ishika Dhall, Panos Kalnis, and Essam Mansour. 2023. A Universal Question-Answering Platform For Knowledge Graphs. Proceedings of the ACM on Management of Data (SIGMOD) 1, 1 (2023), 1–25. https://dl.acm.org/ doi/pdf/10.1145/3588696 [26] Reham Omar, Abdelghny Orogat, Ibrahim Abdelaziz, Omij Mangukiya, Panos Kalnis, and Essam Mansour. 2026. Chatty-KG: A Multi-Agent AI System For On-Demand Conversational Question Answering Over Knowledge Graphs. Proceedings of the ACM on Management of Data (SIGMOD) (2026). https: //dl.acm.org/doi/abs/10.1145/3786632 [27] OpenAI. 2025. ChatGPT. OpenAI (2025). https://chat.openai.com [28] OpenAI. 2025. OpenAI Agents SDK: A Python framework for building and orchestrating multi-agent systems. https://openai.github.io/openai-agentspython/. Accessed: Nov. 2025. [29] Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G. Patil, Ion Stoica, and Joseph E. Gonzalez. 2023. MemGPT: Towards LLMs As Operating Systems. arXiv Preprint (2023). https://arxiv.org/pdf/2310.08560 [30] James Jie Pan, Jianguo Wang, and Guoliang Li. 2024. Survey Of Vector Database Management Systems. The VLDB Journal 33, 5 (2024), 1591–1615. https: //doi.org/10.1007/s00778-024-00864-x [31] James Jie Pan, Jianguo Wang, and Guoliang Li. 2024. Vector Database Management Techniques And Systems. In Proceedings of the ACM SIGMOD International Conference on Management of Data (SIGMOD). 597–604. https: //dl.acm.org/doi/pdf/10.1145/3626246.3654691 [32] Joon Sung Park, Joseph C. O’Brien, Carrie J. Cai, Meredith Ringel Morris, Percy Liang, and Michael S. Bernstein. 2023. Generative Agents: Interactive Simulacra of Human Behavior. In Proceedings of the ACM Symposium on User Interface Software and Technology (UIST). https://arxiv.org/pdf/2304.03442 [33] Jorge Perez, Marcelo Arenas, and Claudio Gutierrez. 2009. Semantics And Complexity Of SPARQL. ACM Transactions on Database Systems (TODS) 34, 3 (2009), 1–45. https://dl.acm.org/doi/pdf/10.1145/1567274.1567278 [34] Preston Rasmussen, Pavlo Paliychuk, Travis Beauvais, Jack Ryan, and Daniel Chalef. 2025. Zep: A Temporal Knowledge Graph Architecture For Agent Memory. arXiv Preprint (2025). https://arxiv.org/pdf/2501.13956 [35] Richard Thomas Snodgrass. 1999. Developing Time-Oriented Database Applications In SQL. Morgan Kaufmann Publishers. [36] Ji Sun, Guoliang Li, James Pan, Jiang Wang, and et al. 2025. GaussDB-Vector: A Large-Scale Persistent Real-Time Vector Database for LLM Applications. Proc. VLDB Endowment (PVLDB) (2025). https://www.vldb.org/pvldb/vol18/ p4951-sun.pdf [37] Haoran Tan, Zeyu Zhang, Chen Ma, Xu Chen, and et al. 2025. MemBench: Towards More Comprehensive Evaluation On The Memory Of LLM-Based Agents. In Findings of the Association for Computational Linguistics (ACL). 19336–19352. https://aclanthology.org/2025.findings-acl.989.pdf [38] Jianguo Wang, Xiaomeng Yi, Rentong Guo, Hai Jin, Peng Xu, Shengjun Li, Xiangyu Wang, Xiangzhou Guo, Chengming Li, Xiaohai Xu, et al. 2021. Milvus: A Purpose-Built Vector Data Management System. In Proceedings of the ACM SIGMOD International Conference on Management of Data (SIGMOD). 2614–2627. https://dl.acm.org/doi/pdf/10.1145/3448016.3457550 [39] Yu Wang and Xi Chen. 2025. Mirix: Multi-Agent Memory System For LLM-Based Agents. arXiv Preprint (2025). https://arxiv.org/pdf/2507.07957 [40] Yu Wang, Ryuichi Takanobu, Zhiqi Liang, Yuzhen Mao, and et al. 2025. Mem-𝛼 : Learning Memory Construction via Reinforcement Learning. arXiv preprint arXiv:2509.25911 (2025). https://arxiv.org/pdf/2509.25911 [41] Jennifer Widom and Stefano Ceri. 1996. Active Database Systems: Triggers and Rules for Advanced Database Processing. (1996). [42] Di Wu, Hongwei Wang, Wenhao Yu, Yuwei Zhang, Kai-Wei Chang, and Dong Yu. 2025. LongMemEval: Benchmarking Chat Assistants On Long-Term Interactive Memory. In Proceedings of the International Conference on Learning Representations (ICLR). https://openreview.net/forum?id=pZiyCaVuti [43] Wujiang Xu, Zujie Liang, Kai Mei, Hang Gao, Juntao Tan, and Yongfeng Zhang. 2025. A-MEM: Agentic Memory For LLM Agents. In Proceedings of the Conference on Neural Information Processing Systems (NeurIPS). https://openreview.net/ pdf?id=FiM0M8gcct [44] Sikuan Yan, Xiufeng Yang, Zuchao Huang, Ercong Nie, and et al. 2025. MemoryR1: Enhancing Large Language Model Agents to Manage and Utilize Memories via Reinforcement Learning. CoRR abs/2508.19828 (2025). https://doi.org/ 10.48550/arXiv.2508.19828