Explicit Memory in Neuroscience and ML

• Explicit memory is a system that stores conscious facts and events via sparse, addressable representations, crucial for flexible retrieval in both the hippocampus and artificial models.
• Various forms—including slot-based, graph, hierarchical, and spatial memories—demonstrate tailored methodologies to optimize interpretability and task-specific performance.
• Design trade-offs in explicit memory involve balancing memory size, noise, and interface stability to ensure rapid writing, selective retrieval, and long-horizon utility.

Explicit memory denotes memory mechanisms that store facts, events, or structured state in an addressable representation rather than distributing them only across model parameters or opaque latent dynamics. In neuroscience, explicit memory is the hippocampus-mediated system for consciously accessible information about facts and events, split into episodic memory and semantic memory; in machine learning, the term now spans external memory matrices, key–value caches, relation triples, graph memories, hierarchical trees, human-readable memory banks, point clouds, and orthogonal-polynomial state representations (Park, 5 Jun 2026, Yang et al., 2024, Modarressi et al., 2024). Across these settings, the central design objective is similar: support rapid writing, selective retrieval, and post hoc inspection while preserving trainability and long-horizon utility.

1. Conceptual foundations and historical lineage

The classical distinction between explicit and implicit memory comes from cognitive neuroscience. Explicit memory is characterized by sparse coding in dentate gyrus, autoassociative recurrent storage in CA3, CA1-mediated cortical output, high plasticity, and flexible retrieval guided by contextual cues and top-down prefrontal modulation. Implicit memory, by contrast, is described as dense, distributed, slow to acquire, and oriented toward stimulus–response mappings rather than context reconstruction (Park, 5 Jun 2026).

In machine learning, explicit memory emerged as an attempt to provide neural systems with an external or structurally exposed store. Early families such as Memory Networks, Neural Turing Machines, and Differentiable Neural Computers promised unbounded or at least expandable memory, but they also exposed the difficulty of training read–write systems end to end. A recent summary of this line states that “for over a decade, explicit memory architectures like the Neural Turing Machine have remained theoretically appealing yet practically intractable for language modeling due to catastrophic gradient instability during Backpropagation Through Time” (Goo et al., 13 May 2026).

A distinct but related lineage is the memory-network work on reading and question answering. “The Goldilocks Principle” argued that the granularity of the memory slot is itself a decisive variable: lexical memories are too small, full-sentence memories are too coarse, and a “just-right” window size, around five words in the Children’s Book Test validation sweep, best supports prediction of semantic content words such as named entities and nouns (Hill et al., 2015). This result established an enduring theme in explicit-memory research: memory efficacy depends not only on capacity, but also on representational chunking.

2. Representational forms

Explicit memory is not a single architecture. Recent work uses markedly different storage substrates, each chosen to make a particular form of information addressable.

Memory form	Representative systems	Stored representation
Slot and cache memories	Window-memory MemNN (Hill et al., 2015), EWE (Chen et al., 2024)	Word windows, sentence slots, Transformer KV caches
Structured symbolic memories	MemLLM (Modarressi et al., 2024), ExplicitLM (Yu et al., 3 Nov 2025)	Relation triples, token-sequence facts
Graph memories	LatentGraphMem (Zhang et al., 6 Jan 2026), PsyMem (Cheng et al., 19 May 2025)	Directed triples, latent edge embeddings, character knowledge graphs
Hierarchical and recurrent memories	PMNet (Goo et al., 13 May 2026), EBmRNN (Chakraborty et al., 2019)	85-slot hierarchical phasor tree, explicit event bank
Spatial memories	Reasmory (He et al., 31 May 2026), Point3R (Wu et al., 3 Jul 2025)	Canonicalized point clouds, object instances, 3D spatial pointers
Interpretable state memories	HiPPO Zoo (Goffinet et al., 24 Feb 2026)	Orthogonal-polynomial coefficient states

Slot-based memories are the most direct descendants of early memory networks. In EWE, the working memory at generation step $t$ is $M_t = \{m_{t,1}, \dots, m_{t,k}\}$, and each memory unit is a Transformer key–value cache $(K_i, V_i)$ for a retrieved passage or fact-checking correction, with $K_i, V_i \in \mathbb{R}^{M \times d}$ (Chen et al., 2024). In PMNet, memory is instead a full $4$-ary tree of depth $H=4$, yielding $C_m = \sum_{h=1}^4 4^{h-1} = 85$ slots, with learnable anchors at each hierarchy level and phase-valued memory states (Goo et al., 13 May 2026).

Structured symbolic memories make different trade-offs. MemLLM stores relation triples $r^i = \langle e_s^i, t^i, e_o^i \rangle$ as raw text and as vectors, indexed with HNSW for approximate nearest-neighbor retrieval (Modarressi et al., 2024). ExplicitLM uses a million-scale external memory bank in which each entry is a human-readable token sequence, with a differentiable two-stage retrieval mechanism based on product-key decomposition and Gumbel-Softmax matching (Yu et al., 3 Nov 2025). Graph memories generalize this idea by storing relations among entities rather than isolated facts. LatentGraphMem keeps the full graph latent in a matrix $U \in \mathbb{R}^{|E| \times d}$ of edge embeddings but externalizes only a budgeted symbolic subgraph at inference time (Zhang et al., 6 Jan 2026). PsyMem represents a character’s episodic knowledge as a GraphRAG-style knowledge graph, then retrieves a small subset of relevant memories conditioned on role identity, a 26-dimensional psychological profile, dialogue context, and the current query (Cheng et al., 19 May 2025).

Spatial and state-space memories widen the scope of the term beyond text. Reasmory stores a global point-cloud memory $\mathbf{X}$ together with camera extrinsics $M_t = \{m_{t,1}, \dots, m_{t,k}\}$0 and semantically grounded 3D object instances $M_t = \{m_{t,1}, \dots, m_{t,k}\}$1 (He et al., 31 May 2026). Point3R defines an explicit spatial pointer memory $M_t = \{m_{t,1}, \dots, m_{t,k}\}$2, where each pointer has a fixed 3D position $M_t = \{m_{t,1}, \dots, m_{t,k}\}$3 and a learnable feature vector $M_t = \{m_{t,1}, \dots, m_{t,k}\}$4 (Wu et al., 3 Jul 2025). HiPPO Zoo, finally, treats explicit memory as an interpretable coefficient vector in an orthogonal-polynomial basis, making time warping, associative read–write structure, multiscale compression, and forecasting objectives explicit in state-space form (Goffinet et al., 24 Feb 2026). This diversity suggests that explicitness is better understood as an access property than as a particular data structure.

3. Read, write, refresh, and interface mechanisms

Most explicit-memory systems separate four operations: encoding, addressing, update, and exposure to the downstream model. In the canonical Memory Network formulation, a query embedding $M_t = \{m_{t,1}, \dots, m_{t,k}\}$5 produces attention weights

$M_t = \{m_{t,1}, \dots, m_{t,k}\}$6

and a readout

$M_t = \{m_{t,1}, \dots, m_{t,k}\}$7

followed by the residual update $M_t = \{m_{t,1}, \dots, m_{t,k}\}$8 (Hill et al., 2015). This basic pattern—query, score, aggregate—remains visible in many later systems.

LatentGraphMem instantiates the same pattern with bilinear graph-edge scoring. Given a question $M_t = \{m_{t,1}, \dots, m_{t,k}\}$9, the retriever computes $(K_i, V_i)$0, scores each latent edge embedding $(K_i, V_i)$1 by $(K_i, V_i)$2, applies budgeted top-$(K_i, V_i)$3 selection $(K_i, V_i)$4, and externalizes only $(K_i, V_i)$5 as a compact symbolic subgraph appended to the frozen reasoner’s prompt (Zhang et al., 6 Jan 2026). In ExplicitLM, the coarse stage reduces retrieval from $(K_i, V_i)$6 to $(K_i, V_i)$7 via product-key decomposition, while the fine stage performs straight-through Gumbel-Softmax selection over cosine similarities (Yu et al., 3 Nov 2025).

Update rules are equally varied. EWE uses explicit working-memory refresh based on retrieved passages $(K_i, V_i)$8 and fact-checking feedback $(K_i, V_i)$9:

$K_i, V_i \in \mathbb{R}^{M \times d}$0

with $K_i, V_i \in \mathbb{R}^{M \times d}$1 defined as “FIFO-append-oldest-drop” (Chen et al., 2024). MemLLM exposes writing directly through generated API tokens: when the model emits a MEM_WRITE command, extracted triples are parsed and inserted into the memory store; when it emits MEM_READ, decoding pauses, the memory is queried, and the returned entities are inserted into the context before generation resumes (Modarressi et al., 2024). Point3R writes by fusing new spatial pointers into existing ones through nearest-neighbor thresholding and averaging, abstracted as $K_i, V_i \in \mathbb{R}^{M \times d}$2 (Wu et al., 3 Jul 2025).

A distinct class of systems constrains the interface to memory rather than the stored object. AgentSys isolates memory hierarchically: the main agent appends only schema-validated return objects $K_i, V_i \in \mathbb{R}^{M \times d}$3 to its trusted context, while raw tool outputs $K_i, V_i \in \mathbb{R}^{M \times d}$4 remain confined to ephemeral worker-agent contexts. Formally, $K_i, V_i \in \mathbb{R}^{M \times d}$5 with $K_i, V_i \in \mathbb{R}^{M \times d}$6, and only if $K_i, V_i \in \mathbb{R}^{M \times d}$7, meaning valid JSON satisfying the declared schema $K_i, V_i \in \mathbb{R}^{M \times d}$8 (Wen et al., 7 Feb 2026). Reasmory uses a statically checkable DSL whose permitted operations include query_camera_pose, query_3d_object_location, set_viewpoint, turn_camera, step_camera, render_egocentric, and render_semantic_bev; generated programs are parsed, validated, and only then executed against the 3D memory (He et al., 31 May 2026). These systems treat memory safety and usability as interface-design problems rather than as purely representational ones.

4. Stability, interpretability, and structural alignment

The historical obstacle for explicit memory has been stability. In NTM-style systems, unconstrained recurrent write matrices, addressing drift, and unbounded gradient flow through long invocation chains made BPTT intractable beyond a few hundred steps. PMNet addresses this by enforcing unitary phasor dynamics:

$K_i, V_i \in \mathbb{R}^{M \times d}$9

where $4$0 is unitary, so the Jacobian of each time step has unit spectral norm and the backpropagated gradient preserves its $4$1 norm across time. PMNet supplements this with Segment-Aware Gradient Normalization, scaling backward gradients by $4$2 when $4$3 writes collide in the same slot (Goo et al., 13 May 2026). Its ablations argue that the historical failure of explicit memory was a structural alignment problem rather than a mere scaling failure.

A second line of work stabilizes explicit memory by hybridization. EBmRNN partitions memory into an explicit block $4$4 that stores exact event representations and a blurred block $4$5 that accumulates salient abstractions. Reads from $4$6 use one-hot Gumbel-Softmax addressing, but a scalar gate $4$7 combines explicit and blurred reads before output. Empirically, the pure-explicit variant EmRNN suffers training instability and under-utilizes long-term context, whereas the explicit-plus-blurred design preserves interpretability while stabilizing training (Chakraborty et al., 2019). HiPPO Zoo takes a different route: it keeps the state evolution linear and interpretable in an orthogonal-polynomial basis, then exposes capabilities usually hidden in nonlinear SSMs—salience, associative recall, multiscale coverage, forecasting geometry—through explicit modifications of measure, readout, or objective (Goffinet et al., 24 Feb 2026).

Interpretability is not uniform across systems. Some architectures store inspectable facts directly: MemLLM’s relation triples are human-readable and editable; ExplicitLM’s memory slots are token sequences; AgentSys’s main context contains only schema-validated objects (Modarressi et al., 2024, Yu et al., 3 Nov 2025, Wen et al., 7 Feb 2026). Others expose only a task-relevant slice. LatentGraphMem deliberately keeps the full graph latent to avoid symbolic overload, but externalizes a compact human-readable subgraph $4$8 for downstream reasoning and inspection (Zhang et al., 6 Jan 2026). Reasmory shows that unrestricted access can be counterproductive: “+Primitives, no verifier” degrades vanilla VLM performance on MindCube, whereas “+Primitives + DSL verifier” recovers and surpasses the baseline (He et al., 31 May 2026). A common misconception is therefore that interpretability follows automatically from adding an external store. The literature instead suggests that explicit memory becomes useful when representational exposure, access constraints, and optimization dynamics are aligned.

5. Empirical profile across domains

Explicit memory has been evaluated in language modeling, factual generation, multi-hop reasoning, secure agency, clinical modeling, role-playing, and spatial reasoning. The empirical pattern is not uniform, but several domains now report large gains when the memory mechanism is structurally integrated rather than added as unconstrained retrieval.

Domain	Representative finding	System
Long-context byte-level modeling	Near 100% exact recall on Copy-Paste up to $4$9; 119M PMNet matches the zero-shot long-context robustness of a 353M Mamba model on PG-19 up to 512K	PMNet (Goo et al., 13 May 2026)
Long-form factual generation	LongFact $H=4$0, Fava $H=4$1, Biography $H=4$2, with helpfulness near 50% vs. the base model	EWE (Chen et al., 2024)
Knowledge-intensive generation	OVERALL PPL $H=4$3 and TARGET PPL $H=4$4 on DOCRED validation	MemLLM (Modarressi et al., 2024)
Pretraining with externalized knowledge	Memory³-SFT (2.4B) reaches 63.31 average vs. 60.80 without memory; 733 tk/s with retrieval on A800	Memory³ (Yang et al., 2024)
Secure tool-using agents	AgentDojo ASR $H=4$5 and benign utility $H=4$6	AgentSys (Wen et al., 7 Feb 2026)
Spatial reasoning with VLMs	MindCube-Tiny: GPT-5-mini $H=4$7; VSI-Bench-Tiny: Gemini-3-flash $H=4$8	Reasmory (He et al., 31 May 2026)
Personalized multi-hop reasoning	DenseRAG 32.4% short / 21.6% long; HybridMem 66.3% short / 51.8% long under Multi-path Reasoning	MPR / HybridMem (Zhang et al., 18 Aug 2025)

Related results reinforce the same pattern. On long-horizon QA, LatentGraphMem reaches 56.08% average exact match with frozen Qwen-2.5B, versus 44.03% for MemGen and 24.78% for A-Mem, while preserving a human-readable subgraph interface and parameter-efficient LoRA adaptation (Zhang et al., 6 Jan 2026). In role-playing, PsyMem reports Memory score improvement from 85.6 to 91.8, overall character-fidelity improvement from 79.14 to 82.64, and human-likeness improvement from 64.4 to 87.6 on a Qwen2.5-7B-Instruct backbone (Cheng et al., 19 May 2025). In EHR modeling, EBmRNN attains in-hospital mortality AUC–ROC 0.8612, decompensation AUC–ROC 0.8989, and phenotype micro AUC–ROC 0.8191, outperforming its pure-explicit variant and matching or surpassing standard GRU baselines while retaining inspectable explicit slots (Chakraborty et al., 2019).

These results suggest that explicit memory is not a single performance intervention. In some settings it chiefly improves factuality; in others it extends context length, hardens agent security, or organizes geometry for spatial reasoning. The strongest gains tend to appear when the memory representation, retrieval budget, and execution interface are co-designed.

6. Trade-offs, misconceptions, and future directions

A persistent trade-off concerns memory size, shape, and noise. EWE shows that too many working-memory units allow stale information to linger and reduce VeriScore F1, while under a fixed $H=4$9 budget the 128×20 configuration outperforms 256×10 and 512×4 (Chen et al., 2024). LatentGraphMem similarly reports that larger graph capacity $C_m = \sum_{h=1}^4 4^{h-1} = 85$0 can improve coverage on WikiHop but risks noise on narrative tasks, and that small $C_m = \sum_{h=1}^4 4^{h-1} = 85$1 values reduce prompt size but may miss rare edges (Zhang et al., 6 Jan 2026). In personalized multi-hop reasoning, retrieval size depends on hop count: $C_m = \sum_{h=1}^4 4^{h-1} = 85$2 is optimal for 2–4 hops, whereas $C_m = \sum_{h=1}^4 4^{h-1} = 85$3 is better for 8–10 hops because of the recall–noise trade-off (Zhang et al., 18 Aug 2025). A common misconception is that more explicit memory is always better; these results indicate that allocation and budgeting are central design variables.

A second trade-off is systems overhead. Memory³ reports about 35% latency overhead from memory loading and chunkwise attention loops, and notes update fragility because model parameter changes may require re-encoding or re-quantizing memories (Yang et al., 2024). Point3R shows that disabling memory fusion causes unrestricted pointer growth, doubling runtime per frame, even if some metrics improve slightly (Wu et al., 3 Jul 2025). PMNet identifies a 1.5× throughput gap and lists optimized CUDA kernels for segmented scan, scaling laws for 1B+ parameter PMNets, alternative tree topologies, adaptive branching factors, and richer local attention as future work (Goo et al., 13 May 2026). Reasmory adds that reconstruction and rendering incur nontrivial inference cost, and that answer quality depends on reconstruction fidelity, semantic-mask alignment, and resistance to occlusion or fast motion (He et al., 31 May 2026).

At the conceptual level, the strongest claim in the literature is a position statement rather than an established consensus: hippocampal explicit memory is argued to be the cornerstone for AGI because long-term strategic planning, metacognition, and symbolic reasoning “heavily rely on hippocampal explicit memory and cannot arise solely from implicit statistical learning” (Park, 5 Jun 2026). A plausible implication is that future architectures will continue to combine sparse indexing, rapid writing, associative retrieval, and constrained external interfaces rather than relying on either pure parametric storage or unconstrained retrieval alone. Recent systems already point in that direction: explicit memory is becoming less a single module and more an architectural principle for making long-range state stable, inspectable, and task-conditioned.