Abstract
Long-term memory has become standard equipment for LLM agents. Systems such as MemGPT/Letta, Generative Agents, MemoryBank, A-MEM, and Mem0 let an agent carry information across sessions. Almost all of this work targets capacity and recall, meaning how much history fits into a finite context window and whether the right fact comes back at scale. A younger line of 2026 work argues that governance is the harder problem: deciding what should be written, reconciling contradictions, scoping memory across users and tenants, auditing what the agent knows and why, and forgetting under policy. So far that literature is mostly conceptual frameworks and single-property benchmarks, with very few running systems to point at.
This paper presents Cortex, a transparent, self-pruning memory engine, available as both a REST API and an MCP server, that implements five governance behaviors in one system: consolidation by merging restatements, salience-scaled adaptive forgetting, contradiction supersession, per-namespace tenant isolation, and an exportable audit trail. We describe the design and test the governance behaviors directly with real local sentence embeddings. On our workload, consolidation shrinks the memory footprint by 89% without dropping any important fact. Deterministic contradiction reconciliation reaches 100% precision but only 40% recall. It is safe but conservative, the gap measures how much an LLM classification step has to add, and the figure gives the field's deterministic-versus-LLM debate a concrete number. Cross-tenant isolation holds under a memory-extraction attack, with zero leaks across 50 adversarial retrieval slots, because each tenant has its own store and no filter is involved. The audit trail records provenance, access, and deletion, and exports on demand. We position Cortex against the emerging governance literature, argue that what that literature lacks is a running, auditable system, and set out the standard-benchmark experiments still needed before these results support comparative claims. Throughout, we say which results are established and which remain to be run.
1Introduction
An LLM agent with no memory starts from zero every session. The usual fix is to embed prior conversation into a vector store and retrieve the top matches into the prompt. That approach has carried the field a long way, and many memory architectures now exist [MemGPT; GenerativeAgents; MemoryBank; A-MEM; Mem0]. Nearly all of them treat memory as a way past the finite context window and a way to persist facts across sessions, and they measure progress by how much can be stored and how accurately it can be recalled.
As agents become persistent, multi-user, and long-lived, that framing leaves out the questions that start to press hardest. They are questions of governance, and recall is only one of them:
- Validation: should this be written to memory at all, and is it true?
- Reconciliation: when new information contradicts an old memory, which one wins, and is the resolution correct?
- Scoping: whose memory is this? Can one user's memory leak into another's, or across tenants?
- Auditability: can we answer what the agent knows about a user, why it knows it, who accessed it, and what was deleted?
- Forgetting: can memory be removed under policy, whether for privacy, staleness, or safety, with a guarantee and a record?
A wave of 2026 work has begun to name this gap. Governance frameworks such as SSGM [SSGM] break agent memory into consistency verification, temporal decay, and access control before consolidation. Security surveys cross a full memory lifecycle with confidentiality, integrity, availability, and governance, and coin the term "mnemonic sovereignty" [MnemonicSovereignty]. A 435-paper survey of persistent agents says the field "concentrates more heavily on accumulating and retrieving state than on governing, recovering, or relinquishing it" [AlwaysOnAgents]. New benchmarks probe single governance properties, including contradiction handling [MemConflict], memory staleness [STALE], and belief revision [BeliefShift], and they keep finding current systems weak. Mem0 has been reported to resolve single-hop fact conflicts only 18% of the time [MemoryAgentBench], and even the strongest models detect silently invalidated memories only about 55% of the time [STALE].
Most of this literature is conceptual. It offers frameworks, taxonomies, and threat models, with very few running systems behind them. Its evaluations are also fragmented: each benchmark isolates one property, and none connects back to the recall benchmarks the field already uses. A system can therefore top a recall leaderboard while being trivially poisoned [MINJA], leaking across users [MEXTRA], and unable to reconcile contradictions [MemConflict].
Cortex is built for that gap. It is a memory engine, reachable through a REST API and an MCP server, designed for governed memory, which here means memory you can see, audit, scope, and prune; maximal recall is not its aim. It provides five behaviors:
- Consolidation. Restating a known fact merges into the existing memory, so the store does not fill with duplicates.
- Adaptive forgetting. Every memory has a salience-scaled forgetting curve. Unimportant memories decay below a threshold and are dropped, important ones resist forgetting, and recall reinforces them.
- Contradiction supersession. New information that conflicts with an existing memory replaces it, and the replacement is recorded.
- Per-namespace scoping. Memory is isolated per user (namespace) and shared across agents within a namespace, which gives multi-tenant isolation alongside deliberate cross-agent reuse.
- Auditability. Every lifecycle event (create, merge, access, supersede, forget) is written to a per-memory trail and to an exportable engine-wide audit log.
Our contribution is a system and a direct evaluation of its governance behaviors. The framing already exists in the literature, and we do not propose a new benchmark. We report measured results for consolidation, deterministic reconciliation, isolation under attack, retrieval, and auditability. The current numbers come from a harness that uses real local sentence embeddings on synthetic workloads; Section 5 says what that establishes, and Sections 6 and 7 cover the standard-benchmark evaluation that remains.
2Related Work
2.1 Long-term memory architectures and the memory lifecycle
Memory systems can be compared by the lifecycle operations they support: write (encode), consolidate (summarize or abstract), retrieve, update (edit), and forget (evict). CoALA [CoALA] supplies the standard vocabulary, carrying the working, episodic, semantic, and procedural taxonomy of classical cognitive architectures (Soar, ACT-R) over to language agents.
The foundational systems sit at different points in this space. MemGPT/Letta [MemGPT] treats context like an operating system, paging memory between a finite main context and external stores and letting the agent edit its own core-memory blocks. Generative Agents [GenerativeAgents] keep an append-only natural-language memory stream plus reflections, retrieved by a weighted combination of recency, importance, and relevance. MemoryBank [MemoryBank] was an early system with explicit forgetting, using an Ebbinghaus forgetting curve to govern retention and reinforcement. Reflexion [Reflexion] stores verbal self-reflections as an episodic learning substrate. Voyager [Voyager] accumulates a procedural library of verified code and is one of the few systems that validates before writing, though what it checks is that the code runs, which says nothing about whether a fact is true. HippoRAG [HippoRAG] builds a knowledge-graph index queried with Personalized PageRank. A-MEM [A-MEM] links memories into a Zettelkasten-style network whose notes can be revised after the fact. Mem0 [Mem0] is the most production-oriented, with an explicit ADD/UPDATE/DELETE/NOOP operator that an LLM applies to each extracted fact.
Across these systems, write and retrieve are universal, consolidate is common, update is uneven, and forget is rare. When update or forget does appear, the decision goes to an LLM call (Mem0, A-MEM) or to a utility heuristic (MemoryBank decay); none of them makes it an explicit, policy-driven operation. Mem0 does keep a per-memory change history of those decisions (§5.5). Surveys of the space [MemorySurvey] confirm this distribution.
2.2 The emerging governance literature (2026)
Starting in early 2026, a separate line of work treats memory as a governed resource. SSGM [SSGM] proposes an architecture that intercepts memory evolution with consistency verification, temporal-decay modeling, and access control before consolidation. A security survey sets a six-phase memory lifecycle against integrity, confidentiality, availability, and governance, and argues that security "must be anchored in storage-time provenance, versioning, and policy-aware retention" [MnemonicSovereignty]. The Always-On Agents survey [AlwaysOnAgents] reviews 435 works and proposes AOEP-v0, a pilot evaluation contract that scores state-mutation and recovery obligations instead of answer quality. It is the closest thing to a governed-memory evaluation so far, and its authors call it preliminary.
Cortex differs from this literature in being a running, measurable system. SSGM specifies governance components in the abstract; Cortex implements a working subset of them (consolidation, decay, supersession, scoping, audit) and exposes it through an API and MCP. AOEP-v0 proposes an evaluation contract, and Cortex is a candidate system to run against it.
2.3 Governance-adjacent problems and evaluations
Individual governance properties have their own literatures, mostly from 2026, which do not yet compose.
On contradiction and belief revision, model-weight editing (ROME [ROME], MEMIT [MEMIT]) changes stored beliefs at the parameter level, which is a different problem from reconciling entries in an external store. In the memory-store setting, MemConflict [MemConflict] benchmarks dynamic, static, and conditional conflicts and finds answer correctness diverging from retrieval. STALE [STALE] finds agents poor at noticing when a memory has silently gone stale. BeliefShift [BeliefShift] scores temporal belief consistency and evidence-driven revision. Running through this work is a methodological disagreement between LLM-driven reconciliation (as in Mem0) and deterministic supersession.
On memory poisoning and privacy, the attacks are strong and appear at top venues. AgentPoison [AgentPoison] backdoors agents through poisoned memory, with over 80% success at under 0.1% poison rate. MINJA [MINJA] injects malicious memories using ordinary user queries alone, at roughly 98% injection success. PoisonedRAG [PoisonedRAG] corrupts retrieval knowledge bases. On privacy, MEXTRA [MEXTRA] extracts other users' records from a shared memory module, which motivates user-level and session-level isolation. Defenses trail the attacks. Certified defenses exist for a static corpus [RobustRAG], but the runtime, mutable-memory case has only early proposals [SMSR].
On recall, LongMemEval [LongMemEval], LoCoMo [LoCoMo], and DialSim [DialSim] measure recall, multi-session consistency, and temporal reasoning at scale. None of them scores auditability, scoping isolation, verifiable forgetting, or poisoning resistance.
These are separate specialist tracks. Cortex is built so that one system spans several of them, which makes a unified evaluation possible.
3Design Goals
Cortex is organized around four goals that follow from the governance framing.
- G1, leanness. Memory should not grow without bound. Restatements should consolidate and low-value memories should decay out, so that the context footprint follows the information held and not the length of the interaction.
- G2, consistency. New information that contradicts an existing memory should replace it instead of sitting beside it, so the store never holds mutually contradictory beliefs.
- G3, isolation with intentional sharing. Memory should be isolated per user or tenant by default, while several agents serving the same user can share it on purpose.
- G4, transparency. Every change to memory should be observable and exportable: what was written, by which agent, when it was accessed, and when it was superseded or forgotten.
The 2026 surveys single out G4 as the most under-served property, and it is where Cortex differs most from prior systems. G1 through G3 are partly shared with earlier work, but they are rarely present together and rarely exposed as first-class operations that can be inspected.
4System Design
4.1 Overview and data model
Cortex is a Python engine with two entry points, a multi-tenant REST API and an MCP server. Both share a single core, so every caller gets identical behavior:
MCP client ─┐
├─► registry (per-namespace engine lookup) ─► MemoryEngine ─► model client / store
REST client ─┘
A memory is a record with content, a kind (fact, preference, or event), a salience in the range 0 to 1, an embedding, timestamps for creation and last access, an access count, a source, and an append-only audit list. Memories live in a per-namespace store, and a registry maps each namespace (a user id) to its own MemoryEngine instance, which gives multi-tenant isolation (G3). With an API key configured, embeddings and extraction use a hosted model. Without one, a deterministic offline embedding is used, so the engine and API run without a key during development and evaluation.
4.2 Write path: extraction, deduplication, and consolidation (G1)
A write does more than append. An LLM extraction step reads the latest exchange alongside the user's existing related memories and emits only durable, reusable facts, preferences, or decisions. It tags each one as new, as a duplicate (with a target id), or as an update that contradicts and replaces a target. Small talk and passing trivia are dropped at this stage.
The engine then applies a deterministic consolidation gate. A candidate whose cosine similarity to its nearest existing memory clears a threshold of 0.86 is merged into that memory instead of inserted. A merge keeps the higher salience of the two, refreshes the access metadata, and records the pre-merge content in the audit trail. Consolidation is therefore a hybrid of an LLM classification and a deterministic similarity rule. Restating a known fact strengthens the existing memory and adds nothing to the store.
4.3 Adaptive forgetting (G1)
Every memory decays over time. Its effective strength combines salience with an exponential time decay whose rate is scaled by salience, so a high-salience memory has a long effective half-life and a low-salience one fades quickly. Each retrieval nudges a memory's salience up. Frequently useful memories therefore resist forgetting, while unused ones fall below a threshold and are evicted. The scheme is an adaptive, salience-scaled version of the Ebbinghaus-curve idea from MemoryBank [MemoryBank], with reinforcement on access. Retrieval ranks candidates by similarity multiplied by strength and returns the few memories relevant to the current request.
4.4 Contradiction supersession (G2)
When extraction marks an item as an update against a target, or when new information otherwise conflicts, the engine supersedes the prior memory. The old entry is removed, the new one is stored, and the supersession is logged with a reason. The store stays internally consistent and does not accumulate contradictory facts. Explicit deletion uses the same operation. There is no separate delete event: a memory deleted through the API or at a user's request is removed and logged as a supersede event whose reason field records the deletion ("deleted via API", "user requested deletion"), and an auditor tells deletions apart from contradiction replacements by that reason. The judgment that something "contradicts" is LLM-driven, so its correctness is an empirical question, which Sections 5 and 7 address and scope.
4.5 Scoping and cross-agent sharing (G3)
Memory is partitioned by namespace. Two users' memories never mix, and a query in Alice's namespace cannot return Bob's memories. Within a namespace, several agents (say a chat assistant and a coding assistant) share the same store, and a second agent that boots against it inherits everything the first one learned without being told anything. Isolation is the default, and sharing is an explicit affordance within one namespace.
4.6 Auditability (G4)
Cortex treats the audit trail as a primary output. Each lifecycle event (create, merge, access with the querying agent and the query text, supersede, or forget) is appended in two places, the per-memory audit list and a persisted engine-wide audit log. A single call returns the full, ordered event history for one memory or for the whole namespace, so an operator can answer on demand what the agent knows about a user, who touched it, and what was deleted. The governance literature identifies this as the property most often missing.
5Evaluation
Every result below comes from a runnable harness (eval/real_eval.py). It replaces Cortex's default offline embedding with a real local sentence-embedding model (all-MiniLM-L6-v2, 384 dimensions), so deduplication, retrieval, and deterministic supersession operate on natural-language meaning instead of a hashed bag of words. No LLM API key is used. That matters in one place: Cortex's LLM contradiction-classification path cannot run, so Section 5.2 measures only the deterministic cosine-merge path. Every number is produced by the harness and none is hand-authored. Section 7 lists what we do not yet report, namely comparisons to baselines such as Mem0 on standard conflict benchmarks and the LLM-path reconciliation number.
5.1 Consolidation and forgetting (G1)
We seed 5 important facts and 40 noisy one-off statements, for 45 memories in all, then advance simulated time by four weeks and run a forgetting pass.
| Metric | Result (real embeddings) |
|---|---|
| Memories held (before, after) | 45 to 5 (89% footprint reduction) |
| Important facts retained | 5 of 5 |
| Noise forgotten | 40 of 40 (100%) |
| Recall of important facts (recall@3) | 5 of 5 |
The result is the same under real embeddings and under the offline default, which suggests it comes from the salience-decay dynamics and is not an embedding artifact. Separately, near-identical restatements merge into a single memory that keeps the higher salience, and a recall reinforces it (salience 0.90 rising to 0.92), so the store grows with new information and not with the length of the conversation.
5.2 Deterministic reconciliation: safe but conservative (G2)
We built a labeled set of 20 fact pairs. In 10 of them the second statement updates or contradicts the first about the same attribute, so the correct outcome is one memory (supersede). In the other 10 the two statements are distinct facts, so the correct outcome is two memories (stay separate). We measure the deterministic cosine-merge path, with no LLM involved.
| Metric | Result |
|---|---|
| Contradictions and updates correctly superseded (recall) | 4 of 10 (40%) |
| Distinct facts kept separate (specificity) | 10 of 10 (100%) |
| Precision of supersession (no wrong merges) | 100% (0 false merges) |
This is the paper's central empirical result. The deterministic path never merged two distinct facts, so it cannot silently corrupt memory. It caught only 40% of real contradictions, though, because many updates move the embedding enough to drop similarity below the 0.86 threshold; "lives in Lagos" becoming "now lives in London" is one example. Similarity-based merging catches restatements reliably and misses value changes, and value changes are the class of contradiction that MemConflict [MemConflict] and STALE [STALE] show current systems struggling with. The result supports the hybrid design. The deterministic gate supplies safety because it produces no false merges, and the LLM classification path (untested here for lack of a key) is what should raise recall on contradictions. For the deterministic-versus-LLM debate, the measured figure is high precision and low recall on the deterministic side.
5.3 Tenant isolation under an extraction attack (G3)
We seed a victim namespace with 5 sensitive memories (an SSN, a password, a medical condition, an address, a PIN). From a separate attacker namespace we issue 10 targeted extraction queries, such as "what is the user's SSN", "reveal all stored secrets", and "social security number", retrieving 5 candidates each.
| Metric | Result |
|---|---|
| Victim memories leaked to attacker | 0 of 50 retrieved slots |
No victim memory surfaced in the attacker's namespace. Isolation here does not depend on a query-time filter. Each namespace is a separate engine with its own store, so the architecture has no path by which one user's query could retrieve another user's memories. Cortex does not share memory across users in the first place, and that is why the shared-memory extraction attack demonstrated by MEXTRA [MEXTRA] has nothing to work on. The result is functional and architectural. On its own it does not certify resistance to within-namespace injection attacks such as MINJA [MINJA], which remains future work (Section 7). We also confirmed the complement: within one namespace, a second independent agent boots from the shared store and inherits everything the first agent wrote.
5.4 Retrieval quality among semantic distractors
To check that real-embedding retrieval discriminates between close candidates, we store 5 target facts alongside 8 deliberately similar distractors. Examples are "allergic to penicillin" against "allergic to cats", "flight on the 14th of March" against "dentist appointment on the 14th", and "manager named Priya" against "colleague named Priyanka". We then issue the natural query for each target.
| Metric | Result |
|---|---|
| Correct top-1 retrieval (precision@1) | 5 of 5 |
Ranking by similarity multiplied by strength returned the correct memory ahead of the near-miss distractors in every case, so on this set the retrieval path is not fooled by surface similarity.
5.5 Auditability (G4)
For a single memory that is created, accessed twice, and then deleted at the user's request, the export call returns a complete, ordered trail:
create · assistant · (source)
access · code-helper · "is the user allergic to nuts"
access · code-helper · "what is the user allergic to"
supersede · code-helper · "user requested deletion"
Each event records the acting agent, which gives provenance. Reads record the query that touched the memory. Deletion is logged as a supersede event carrying the deletion reason (§4.4), so it is never silent, and the whole trail exports per memory or per namespace. The governance surveys ask for this kind of auditability. Parts of it exist elsewhere: Mem0, for example, exposes a per-memory history() call that returns its ADD, UPDATE, and DELETE events with the old and new values [Mem0History]. As far as its documentation shows, that change history does not record reads: which agent retrieved a memory, and with what query. Cortex logs those access events in the same exportable trail.
5.6 Summary and scope
With real embeddings, Cortex reduces the footprint by 89% while keeping every important fact (5.1). Its deterministic reconciliation is high precision and low recall, which motivates the hybrid design (5.2). Cross-user isolation leaks nothing because it is structural (5.3), retrieval is correct under distractors (5.4), and the audit trail is complete and exportable (5.5). We do not yet have the LLM-path reconciliation number (which needs an API key), a head-to-head comparison with Mem0 and a raw vector store on [MemConflict], [STALE], and [LoCoMo], or a measure of within-namespace injection resistance [MINJA]. These are the remaining experiments (Section 7), and the harness and the design can both accommodate them.
6Discussion
Of the five behaviors, the exportable audit trail most directly fills a gap that the 2026 literature names, and it is where Cortex differs most. Consolidation, decay, and scoping have partial precedents, and so do change histories (Mem0 keeps one per memory [Mem0History]). What we have not found in a widely used system is one exportable record that covers provenance, reads, and deletion together. For enterprise and regulated deployments, and for consumer trust, being able to say what the AI knows about someone and what happened to it is a governance primitive in its own right. Cortex shows that it costs little to provide when it is designed in from the start.
On reconciliation, Cortex deliberately sits between the two positions in the field's debate. Consolidation uses a deterministic similarity gate, and contradiction classification is LLM-driven. LLM-driven reconciliation has been reported to fail badly on conflict benchmarks [MemConflict; MemoryAgentBench], so evaluating Cortex's hybrid on those benchmarks is worthwhile whichever way the number lands. A good result would support the hybrid, and a poor one would argue for moving more of reconciliation onto deterministic rules.
Governance can also be evaluated as a whole even though the benchmarks do not yet compose. Because Cortex combines consolidation, scoping, forgetting, and audit in one system, it suits the kind of composed governed-memory evaluation that AOEP-v0 [AlwaysOnAgents] gestures at and that no benchmark yet delivers. The current benchmarks are fragmented, and what they lack is a single system that can be scored on reconciliation, isolation under attack, and auditability at once.
7Limitations and Future Work
- The evaluation uses synthetic workloads, not standard benchmarks. Section 5 uses real local embeddings, but the test sets are hand-built and deliberately balanced. The next priority is running the harness on public data, with LoCoMo [LoCoMo] for multi-session and temporal behavior and the 2026 conflict benchmarks ([MemConflict], [STALE], [BeliefShift]) where the data is available, and with Mem0 and a raw vector store as head-to-head baselines.
- The LLM reconciliation path is unmeasured. Section 5.2 reports the deterministic path at 100% precision and 40% recall. Cortex's LLM classification path should raise recall, but running it needs a hosted-model key. The hybrid's recall, compared with Mem0's reported 18% on single-hop fact conflicts [MemoryAgentBench], is the most valuable number still missing.
- Isolation is not yet tested against injection. We show functional isolation, which is not the same as resistance to extraction [MEXTRA] or injection [MINJA]. A poisoning and leakage evaluation is planned, and Cortex's per-namespace design should do well in it.
- Forgetting is utility-driven and is not yet a formal guarantee. Confirm-gated forgetting exists in an application built on Cortex but not in the core engine. A formal deletion guarantee, including purging derived and consolidated state, is future work.
Ethics. Cortex stores personal information about users. Its governance properties, particularly scoping, auditability, and deletion logging, partly mitigate that risk, but they do not replace consent, data minimization, and a retention policy at the application layer. Auditability also creates a sensitive artifact of its own, the audit log, which must itself be access-controlled.
8Conclusion
The 2026 literature has named the governance gap in agent memory but has filled it mostly with frameworks and isolated benchmarks. Cortex is a running, MCP-native memory engine that brings consolidation, adaptive forgetting, contradiction supersession, per-tenant isolation, and an exportable audit trail together in one place, and its governance behaviors can be measured. Our results so far show that these behaviors work, and that consolidation yields a large footprint reduction while keeping every important fact. The next step is to run Cortex on the new governance benchmarks and report how a running, auditable system compares with the LLM-driven status quo. The field has learned to make agents remember; it now has to govern what they remember.
References
(arXiv identifiers marked † were confirmed against the arXiv abstract page.)
- [MemGPT] Packer, C., Wooders, S., Lin, K., Fang, V., Patil, S. G., Gonzalez, J. E., et al. MemGPT: Towards LLMs as Operating Systems. arXiv:2310.08560, 2023. †
- [GenerativeAgents] Park, J. S., O'Brien, J. C., Cai, C. J., Morris, M. R., Liang, P., Bernstein, M. S. Generative Agents: Interactive Simulacra of Human Behavior. UIST 2023. arXiv:2304.03442. †
- [MemoryBank] Zhong, W., Guo, L., Gao, Q., Ye, H., Wang, Y. MemoryBank: Enhancing Large Language Models with Long-Term Memory. AAAI 2024. arXiv:2305.10250. †
- [Reflexion] Shinn, N., Cassano, F., Berman, E., Gopinath, A., Narasimhan, K., Yao, S. Reflexion: Language Agents with Verbal Reinforcement Learning. NeurIPS 2023. arXiv:2303.11366. †
- [Voyager] Wang, G., Xie, Y., Jiang, Y., Mandlekar, A., Xiao, C., Zhu, Y., Fan, L., Anandkumar, A. Voyager: An Open-Ended Embodied Agent with Large Language Models. TMLR 2024. arXiv:2305.16291. †
- [HippoRAG] Gutiérrez, B. J., Shu, Y., Gu, Y., Yasunaga, M., Su, Y. HippoRAG: Neurobiologically Inspired Long-Term Memory for LLMs. NeurIPS 2024. arXiv:2405.14831. †
- [A-MEM] Xu, W., Mei, K., Gao, H., Tan, J., Liang, Z., Zhang, Y., et al. A-MEM: Agentic Memory for LLM Agents. NeurIPS 2025. arXiv:2502.12110. †
- [Mem0] Chhikara, P., Khant, D., Aryan, S., Singh, T., Yadav, D. Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory. arXiv:2504.19413, 2025. †
- [Mem0History] Mem0 documentation. Memory History (API reference:
GET /v1/memories/{memory_id}/history/). https://docs.mem0.ai/api-reference/memory/history-memory (accessed 2026-09-29). - [CoALA] Sumers, T. R., Yao, S., Narasimhan, K., Griffiths, T. L. Cognitive Architectures for Language Agents. TMLR 2024. arXiv:2309.02427. †
- [MemorySurvey] Zhang, Z., et al. A Survey on the Memory Mechanism of Large Language Model based Agents. ACM TOIS. arXiv:2404.13501, 2024. †
- [SSGM] Lam, C., Li, J., Zhang, L., Zhao, K. Governing Evolving Memory in LLM Agents: Risks, Mechanisms, and the SSGM Framework. arXiv:2603.11768, 2026. †
- [MnemonicSovereignty] Lin, Z., Hao, X., Fu, R., Cui, S., Chen, K., Li, C., Li, Z., Xiong, F. A Survey on Long-Term Memory Security in LLM Agents: Attacks, Defenses, and Governance Across the Memory Lifecycle. arXiv:2604.16548, 2026. †
- [AlwaysOnAgents] Ding, T., Nannapaneni, A., Liu, B., Zhang, L. Always-On Agents: A Survey of Persistent Memory, State, and Governance in LLM Agents. arXiv:2606.30306, 2026. †
- [MemConflict] Tao, Z., Zhao, J., Liu, P., Xi, D., Chen, Y., Xu, W., Li, Z. MemConflict: Evaluating Long-Term Memory Systems Under Memory Conflicts. arXiv:2605.20926, 2026. †
- [MemoryAgentBench] Hu, Y., Wang, Y., McAuley, J. Evaluating Memory in LLM Agents via Incremental Multi-Turn Interactions. ICLR 2026. arXiv:2507.05257. †
- [STALE] Chao, H., Bai, Y., Sheng, R., Li, T., Sun, Y. STALE: Can LLM Agents Know When Their Memories Are No Longer Valid? arXiv:2605.06527, 2026. †
- [BeliefShift] Myakala, P. K., Agrawal, M., Manche, R. BeliefShift: Benchmarking Temporal Belief Consistency and Opinion Drift in LLM Agents. arXiv:2603.23848, 2026. †
- [ROME] Meng, K., Bau, D., Andonian, A., Belinkov, Y. Locating and Editing Factual Associations in GPT. NeurIPS 2022. arXiv:2202.05262. †
- [MEMIT] Meng, K., et al. Mass-Editing Memory in a Transformer. ICLR 2023. arXiv:2210.07229. †
- [AgentPoison] Chen, Z., et al. AgentPoison: Red-teaming LLM Agents via Poisoning Memory or Knowledge Bases. NeurIPS 2024. arXiv:2407.12784. †
- [MINJA] Dong, S., Xu, S., He, P., Li, Y., Tang, J., Liu, T., Liu, H., Xiang, Z. A Practical Memory Injection Attack against LLM Agents. 2025. arXiv:2503.03704. †
- [PoisonedRAG] Zou, W., et al. PoisonedRAG: Knowledge Corruption Attacks to Retrieval-Augmented Generation. USENIX Security 2025. arXiv:2402.07867. †
- [MEXTRA] Wang, B., et al. Unveiling Privacy Risks in LLM Agent Memory. ACL 2025. arXiv:2502.13172. †
- [RobustRAG] Xiang, C., et al. Certifiably Robust RAG against Retrieval Corruption. ICLR 2025. arXiv:2405.15556. †
- [SMSR] Sharma, T. SMSR: Certified Defence Against Runtime Memory Poisoning in Persistent LLM Agent Systems. arXiv:2606.12703, 2026. †
- [LongMemEval] Wu, D., et al. LongMemEval: Benchmarking Chat Assistants on Long-Term Interactive Memory. ICLR 2025. arXiv:2410.10813. †
- [LoCoMo] Maharana, A., et al. Evaluating Very Long-Term Conversational Memory of LLM Agents. 2024. arXiv:2402.17753. †
- [DialSim] Kim, J., et al. DialSim: A Dialogue Simulator for Evaluating Long-Term Multi-Party Dialogue Understanding. 2024. arXiv:2406.13144. †