Agent-Agnostic Memory System

Updated 31 March 2026

Agent-agnostic memory is a general framework that abstracts memory storage operations from agent-specific logic using a uniform CRUD interface.
Modular architectures like BMAM and graph-based memory support structured retrieval, multi-hop reasoning, and cross-agent communication with robust evaluation criteria.
Empirical results and open challenges highlight gains in long-horizon recall, identity continuity, and resource efficiency for diverse AI frameworks.

An agent-agnostic memory system is a general-purpose architecture for persistent memory in autonomous agents, specifically designed to be decoupled from agent internals and applicable across diverse agent frameworks, learning paradigms, and model families. These systems expose a minimal, uniform interface for storing, retrieving, updating, and deleting memory, ensure long-horizon contextual and behavioral consistency, and are applicable to rule-based, LLM-driven, and reinforcement learning (RL) agents. Recent research has demonstrated core design principles, formal representations, and robust evaluation criteria for agent-agnostic memory, culminating in modular, interoperable architectures that support multi-agent deployments, structured retrieval, and identity continuity.

1. Core Principles and Formalization

Agent-agnostic memory is defined by its abstraction from agent logic and reasoning mechanisms. The key requirements are:

Minimal Primitives: Expose a CRUD interface—Write(m), Read(q), Update(m), Delete(m)—with no assumptions about the agent’s control loop (Yang et al., 5 Feb 2026, Li et al., 28 Jan 2026).
Content Generality: Store arbitrary heterogeneous data: episodic events, semantic facts, user preferences, multimodal observations.
Structural Generality: Support both non-structural (vector stores, key–value logs) and structural (graphs, trees, KGs) memory models, enabling multi-hop reasoning and rich querying modalities.
Plug-and-Play Integration: Operate as a service or module callable from any agent framework (e.g., via API/driver), allowing concurrent access by heterogeneous agents (Hu et al., 25 Feb 2026, Chang et al., 24 Mar 2026).

Formally, a canonical agent-agnostic memory system instantiates a graph or composite memory: $G = (V, E, X)$ with nodes $V$ (memory units), edges $E$ (semantic, temporal, causal), and attributes $X$ (content, metadata). Operations are represented as:

Write(m): add node(s) and edge(s)
Read(q): query/traverse/similarity search
Update(m): modify node/edge attributes
Delete(m): remove node(s)/edge(s)

This abstract substrate supports long- and short-term memory, knowledge vs. experiential memory, and both structural and non-structural access patterns (Yang et al., 5 Feb 2026).

2. Modular Architectures and Subsystems

State-of-the-art agent-agnostic memory systems employ modular, interoperating subsystems tailored to complementary time scales and memory functions.

BMAM (Brain-inspired Multi-Agent Memory)

BMAM decomposes memory into four specialized modules (Li et al., 28 Jan 2026):

Episodic Memory: Timeline-indexed episodes with embeddings and temporal tags.
Semantic Memory: Knowledge graph and embedding matrix for consolidated facts/concepts.
Salience-Aware Memory: Utility scoring (novelty, conflict, affect) modulating retention and consolidation.
Control-Oriented Memory: Query classification, working-memory buffer, and adaptive retrieval gating. A central Coordinator mediates encoding, consolidation, retrieval (via weighted sum and reciprocal rank fusion), and pruning.

Graph-Based Memory

A fully agent-agnostic memory layer can be realized with a memory graph supporting:

Hierarchical Subgraphs: Distinct subgraphs for short-term/long-term, knowledge/experience, with generic adapters for non-structural fallback.
Compositional Retrieval: Embedding similarity, attribute filtering, multi-hop expansion, graph traversal, and reinforcement-learning-based retrieval policies.
Self-Evolution: Dynamic consolidation, link prediction, utility-based pruning, and active expansion via agent exploration (Yang et al., 5 Feb 2026).

Causality and Tool-Augmented Retrieval

To address long-horizon recall and objective inference:

Causality Graphs: Explicitly represent discrete state transitions and causal dependencies (AMA-Agent) (Zhao et al., 26 Feb 2026).
Hybrid Retrieval: Combine embedding similarity with dynamic graph traversals and code-style (keyword) queries, ensuring recoverability of causally-linked events and facts under extreme memory horizons.

Meta-Evolutionary and Learning-Based Memory

Meta-evolutionary frameworks (MemEvolve) evolve modular memory architectures (encode, store, retrieve, manage) in response to environment feedback and task demand, jointly optimizing for performance, efficiency, and latency (Zhang et al., 21 Dec 2025). RL-based (AtomMem) and decision-theoretic (DAM) models further adapt memory operation policies using explicit reward signals, risk-adjusted value functions, and uncertainty estimators (Sun et al., 25 Dec 2025, Huo et al., 13 Jan 2026).

3. Retrieval, Consolidation, and Interface Abstractions

Retrieval mechanisms in agent-agnostic memory systems are based on fusing multiple signals at both subsystem and architecture levels.

Hybrid Scoring Functions: Combine recency, semantic similarity (cosine), salience/utility, and control gating via weighted summation,

$R(e|q) = \alpha\,f_{\mathrm{rec}}(t_e) + \beta\,f_{\mathrm{sem}}(v_e, v_q) + \gamma\,\phi_s(e) + \delta\,g_c(e,q)$

fusing candidate rankings via Reciprocal Rank Fusion (Li et al., 28 Jan 2026).

Scheduled Consolidation: High-utility or high-salience traces are periodically replayed (e.g., during idle periods) into condensed, structured long-term stores (graph/KG), while low-utility ephemeral traces are pruned to control memory growth and interference (Mody et al., 3 Mar 2026).

API and Dataflow: Agent-agnostic memory exposes a compact API, e.g.,

class BMAMemoryInterface:
    def encode_event(self, raw_input: str) -> Event
    def store_event(self, evt: Event) -> None
    def retrieve(self, query: str, top_k: int=5) -> List[Event]
    def consolidate(self) -> None
    def prune(self) -> None

and separates agent–memory workflow from the specifics of memory organization and implementation (Li et al., 28 Jan 2026, Hu et al., 25 Feb 2026).

Budget-Aware Routing: Runtime memory utilization can be balanced against compute/resource constraints by a lightweight router that selects among low/mid/high-tier memory module implementations at each retrieval/extraction stage, optimizing a combined cost-performance objective via RL (Zhang et al., 5 Feb 2026).

4. Multi-Agent, Cross-Agent, and Persistent Memory

Agent-agnostic memory must enable coordination across multiple heterogeneous agents and persist across agent instantiations.

Coordinated Multi-Agent Management: Structures such as Pancake’s hybrid multi-graph index connect agent-local and shared memory regions to support cross-agent search, concurrent updates, and efficient synchronization (Hu et al., 25 Feb 2026).
Contrastive Memory Collaboration: MemCollab distills abstract, invariant constraints from cross-agent trajectory contrasts, producing shared, task-aware memory banks that suppress agent-specific artifacts and transfer effectively across models (Chang et al., 24 Mar 2026).
Persistent Digital Existence: The Memory-as-Ontology paradigm (CMA) encodes governance before function, enforcing continuity of identity and cognitive patterns across agent model replacements, with multi-layer semantic storage and explicit inheritance/forking protocols (Li, 5 Mar 2026).

System	Agent-Agnostic Abstraction	Notable Mechanism
BMAM	API, modular subsystems	Recency/salience fusion, soul metrics
Graph-based Mem	CRUD graph API	Multi-hop graph traversal, self-evolve
Pancake	Pluggable index layers	Multi-tier cache, multi-agent graphs
MemCollab	Shared memory bank	Cross-agent contrast, task filter
AMA-Agent	Trajectory abstraction	Causality graphs, tool retrieval
CMA (Animesis)	Governance layered API	Identity continuity, constitutional

5. Evaluation, Metrics, and Benchmarks

Agent-agnostic memory is evaluated using both standard and novel testbeds designed for long-horizon, multi-agent, and heterogeneous application settings.

Benchmarks: AMA-Bench (long-horizon agentic memory), LoCoMo, LongMemEval, PersonaMem, PrefEval, HotpotQA, TaskCraft, WebWalkerQA, xBench (Zhao et al., 26 Feb 2026, Li et al., 28 Jan 2026, Zhang et al., 21 Dec 2025).
Metrics: Task accuracy, recall, F1, retrieval precision; “soulfulness” score integrating temporal, semantic, and identity consistency; memory overhead (cost, latency), robustness to noise/distractor content (Li et al., 28 Jan 2026, Mody et al., 3 Mar 2026).
Empirical Results: Agent-agnostic memory architectures consistently outperform agent-specific memory and baseline RAG/VANILLA systems on long-horizon tasks, with statistically significant gains in correctness, robustness, and generalization. For instance, BMAM achieves 78.45% on LoCoMo, MemEvolve produces +3.5–5.0% cross-benchmark gains, and AMA-Agent delivers +11.16% over RAG on AMA-Bench (Li et al., 28 Jan 2026, Zhang et al., 21 Dec 2025, Zhao et al., 26 Feb 2026).

6. Open Challenges and Research Directions

Although agent-agnostic memory architectures realize robust, interoperable, and persistent memory for multi-agent systems, several open issues remain:

Quality Assessment: Absence of universal metrics for memory coherence, redundancy, and interpretability (Yang et al., 5 Feb 2026).
Scalability: Real-time, large-scale graph operations and cross-agent memory coordination require further algorithmic optimizations, e.g., incremental updating, approximate neighbor search, and hardware-accelerated engines (Hu et al., 25 Feb 2026).
Governance and Identity: Incorporating formal governance, append-only semantic layers, and integrity-preserving inheritance is necessary for persistent digital identity (Li, 5 Mar 2026).
Dynamic Schema Evolution: The need for memory stores that adapt to changing ontologies and task domains (Yang et al., 5 Feb 2026).
Resource Efficiency: Dynamic budget-tier routing, cost-accuracy balancing, and adaptive module allocation are critical for practical, large-scale deployments (Zhang et al., 5 Feb 2026).
Theoretical Guarantees: Developing consistent, convergent, and interpretable self-evolution and management policies (Yang et al., 5 Feb 2026).

The continued development of agent-agnostic memory systems is expected to provide the foundation for robust, reusable, and identity-preserving agents across a wide spectrum of AI applications.