This report examines the theoretical foundations of AI memory systems, moving beyond implementation details to explore the cognitive models, philosophical assumptions, and design principles that underpin different approaches. We'll classify memory architectures by their theoretical commitments, evaluate the LLM + knowledge graph paradigm, and explore deep questions about compressibility, consolidation, and the nature of machine learning itself.
Rather than organizing by technical implementation (vector DBs vs. graphs vs. files), I propose classifying memory systems along five theoretical axes that reveal their underlying cognitive commitments:
| Axis | Pole A | Pole B | What It Reveals |
|---|---|---|---|
| Representation Transparency | Human-readable (explicit) | Opaque/compressed (implicit) | Whether knowledge is stored in forms humans can directly inspect and edit |
| Memory Agency | Agent-managed (active) | System-managed (passive) | Who decides what to store, update, or forget |
| Temporal Modeling | Atemporal (static) | Time-aware (dynamic) | Whether the system tracks when facts were learned and how they evolve |
| Structural Commitment | Unstructured (flat) | Structured (hierarchical/relational) | Whether relationships between memories are explicitly modeled |
| Forgetting Philosophy | Retentionist (store all) | Decay-based (forget actively) | Whether forgetting is treated as a bug or a feature |
- Representation: Opaque (vectors) with human-readable source documents
- Agency: System-managed (retrieval is automatic, no agent decision-making)
- Temporality: Largely atemporal (documents don't inherently track when they were created/updated in the system)
- Structure: Unstructured (flat chunks with optional metadata)
- Forgetting: Retentionist (everything indexed stays indexed)
Cognitive Model: RAG mirrors external reference memory—like looking up facts in an encyclopedia. It assumes knowledge exists "out there" and the agent's job is retrieval, not learning. The analogy is justified but limited: humans don't just retrieve memories; we reconstruct them, and the reconstruction process itself changes the memory.
Key Assumption: Relevance = similarity. This works for factual lookup but fails when relevance depends on user context, recency, or importance weighting.
- Representation: Fully human-readable (markdown/text)
- Agency: Hybrid (agents can write, but humans can directly edit)
- Temporality: Implicit (via file modification timestamps or manual versioning)
- Structure: Semi-structured (markdown headers, directories provide hierarchy)
- Forgetting: Manual (humans or agents must explicitly delete/trim)
Cognitive Model: This mirrors externalized procedural memory—like a craftsman's notebook or a team's runbook. The analogy is strong: it treats memory as something that should be inspectable, editable, and versioned, much like how humans externalize knowledge in writing.
Key Insight: The explosive adoption of AGENTS.md (60,000+ projects) suggests that for coding agents, transparency trumps compression. Developers want to see and edit what the agent "knows."
Limitation: Doesn't scale well to millions of facts; best for project-specific institutional knowledge rather than user personalization at scale.
- Representation: Human-readable (git-backed issue tracking)
- Agency: Agent-managed (agents file, resolve, and link beads autonomously)
- Temporality: Explicit (git history + issue timestamps)
- Structure: Highly structured (graph of dependencies between beads)
- Forgetting: Resolution-based (beads are closed/resolved, not deleted)
Cognitive Model: Beads mirrors prospective memory + working memory externalized. Each "bead" is a unit of work or observation that can be linked to others, creating a dependency graph. This is closer to how humans track tasks and commitments than to episodic memory.
Key Innovation: Beads treats memory as actionable—not just "what happened" but "what needs to happen because of what happened." The git-backing provides auditability and branchability, enabling "what-if" reasoning about alternative histories.
Justification of Analogy: Strong for task-oriented cognition; less applicable to semantic or episodic memory.
- Representation: Hybrid (vectors + human-readable summaries)
- Agency: System-managed with agent overrides
- Temporality: Explicit (temporal metadata on all memories)
- Structure: Semi-structured (memory relationships: extends, derives, updates)
- Forgetting: Decay-based (stale information expires)
Cognitive Model: Supermemory explicitly models semantic memory with temporal awareness. It distinguishes between:
- Documents (raw input)
- Memories (processed knowledge units with relationships)
The relationship types (updates, extends, derives) mirror how human semantic networks evolve: new information can contradict (update), elaborate (extend), or infer (derive from) existing knowledge.
Key Assumption: Memory is not retrieval alone—it's processing. Raw input must be transformed into structured memories before it's useful.
- Representation: Hybrid (KV store for facts + vectors for semantics + graph for relationships)
- Agency: System-managed with extraction pipeline
- Temporality: Implicit (recency scoring, but no explicit validity windows)
- Structure: Multi-store (deliberately heterogeneous)
- Forgetting: Conflict-resolution based (new facts can update/delete old ones)
Cognitive Model: Mem0 embodies a multi-store memory theory akin to Atkinson-Shiffrin's modal model:
- KV store ≈ explicit declarative memory (facts, preferences)
- Vector store ≈ semantic/associative memory
- Graph layer ≈ relational knowledge
Key Innovation: The scoring function combines similarity + recency + importance, acknowledging that relevance is multi-dimensional. This is more cognitively plausible than pure similarity search.
Limitation: The graph features are paywalled, suggesting a tension between theoretical sophistication and business model.
- Representation: Structured (temporal knowledge graph)
- Agency: System-managed (automatic entity extraction)
- Temporality: Explicit validity windows (facts have start/end times)
- Structure: Highly structured (entities, relationships, temporal attributes)
- Forgetting: Supersession-based (old facts are marked invalid, not deleted)
Cognitive Model: Zep models episodic memory with temporal reasoning. The key insight: facts aren't just true or false; they're true during specific intervals. This mirrors how humans remember "Alice was the project lead until January, then Bob took over."
Justification: This is the most temporally sophisticated model in the space. The analogy to human episodic memory is strong—we remember events in time, and we can reason about what was true when.
Unique Capability: Can answer "Who was the lead in March?" differently from "Who is the lead now?"—a capability most systems lack.
- Representation: Hybrid (structured facts + synthesized beliefs)
- Agency: Agent-managed with reflection (
reflectoperation) - Temporality: Explicit (temporal filtering in retrieval)
- Structure: Four logical networks (world facts, agent experiences, entity summaries, evolving beliefs)
- Forgetting: Multi-strategy retrieval with reranking (less about forgetting, more about surfacing)
Cognitive Model: Hindsight is built on belief revision theory. It distinguishes between:
- Facts (objective observations)
- Beliefs (synthesized conclusions that can evolve)
The reflect operation is key: it doesn't just retrieve memories; it reasons across them to produce synthesized answers. This mirrors how humans don't just recall facts—we construct narratives and explanations.
Key Innovation: Treating memory as a "first-class substrate for reasoning" rather than a retrieval layer. The four-network architecture separates different types of knowledge, each with different update and retrieval dynamics.
Cognitive Justification: Strong. The separation of facts from beliefs mirrors the philosophical distinction between knowledge (justified true belief) and opinion (belief without full justification).
- Representation: Human-readable (memory blocks)
- Agency: Agent-managed (agents self-edit their memory blocks)
- Temporality: Implicit (conversation history is timestamped)
- Structure: Tiered (core memory, recall memory, archival memory)
- Forgetting: Agent-decided (agents choose what to archive vs. keep in core)
Cognitive Model: Letta is explicitly modeled on operating system memory hierarchies:
- Core memory ≈ RAM (always in context)
- Recall memory ≈ disk cache (recent conversation)
- Archival memory ≈ cold storage (long-term, queryable)
But the deeper analogy is to metacognition: agents have tools to inspect and modify their own memory, enabling self-aware memory management.
Key Innovation: Agents aren't passive recipients of memory—they manage it. This mirrors human metacognitive control: we decide what to rehearse, what to write down, what to let fade.
Philosophical Commitment: Memory is a skill, not just a storage problem. Agents that can manage their own memory are more autonomous and adaptable.
Based on available literature, these appear to explore:
- Emergent memory structures: Memories that arise from interaction patterns rather than explicit storage
- Observational memory: Learning from watching rather than direct experience
Cognitive Model: These mirror implicit/procedural memory and social learning theory. The idea is that not all memory needs to be explicit—some knowledge emerges from patterns of interaction.
Research Status: Early-stage; more theoretical than implemented.
Based on the analysis above, I propose classifying AI memory systems into five paradigms:
| Paradigm | Core Metaphor | Key Systems | Strengths | Weaknesses |
|---|---|---|---|---|
| External Reference | Encyclopedia/library | RAG, basic vector search | Simple, scalable, auditable | No learning, no personalization |
| Externalized Cognition | Notebook/journal | File-based (MEMORY.md), Beads | Transparent, editable, versioned | Doesn't scale, manual curation |
| Multi-Store Architecture | Brain regions | Mem0, Supermemory, Letta | Flexible, cognitively plausible | Complex, potential integration challenges |
| Temporal Knowledge | Timeline/history book | Zep/Graphiti, Hindsight | Handles change over time, episodic reasoning | Computationally expensive, complex schema |
| Emergent/Implicit | Muscle memory/habit | Early research (EmergenceMem) | Potentially efficient, captures patterns | Hard to inspect, debug, or control |
Short answer: Partially, but often overstated.
Where analogies hold:
- Multi-store models (Mem0, Letta) genuinely mirror the Atkinson-Shiffrin distinction between short-term, long-term, and working memory.
- Temporal knowledge graphs (Zep) capture the time-bound nature of episodic memory better than atemporal systems.
- Agent-managed memory (Letta, Beads) reflects metacognitive control—humans do decide what to rehearse and what to externalize.
- Decay-based forgetting (ACT-R-inspired systems) mirrors the Ebbinghaus forgetting curve and the adaptive value of forgetting.
Where analogies break down:
- Vector embeddings are often called "semantic memory," but they lack the structure of human semantic networks. Human semantic memory has explicit relationships (a dog is a mammal); vectors have implicit similarity.
- Retrieval by similarity doesn't mirror human recall, which is often reconstructive and cue-dependent. Humans don't do cosine similarity; we follow associative chains.
- "Learning" in memory systems is really just storage + retrieval. Humans consolidate memories through replay and reorganization; most AI systems don't.
Key Insight: The best systems (Hindsight, Zep, Letta) don't just metaphorically borrow from cognitive science—they operationalize specific mechanisms (temporal validity, metacognitive control, belief revision).
Denny Vrandečić (founder of Wikidata, lead of Abstract Wikipedia) argues that:
- LLMs shouldn't memorize facts—they should focus on natural language understanding (NLU) and generation (NLG).
- Knowledge graphs (KGs) like Wikidata should be the authoritative source of factual knowledge.
- LLMs should query KGs at inference time, similar to how humans look up facts.
Theoretical Model: This is a separation of concerns architecture:
- LLM: Procedural knowledge (how to parse, reason, generate language)
- KG: Declarative knowledge (facts about the world)
Cognitive Analogy: This mirrors the philosophical distinction between:
- Competence (knowing how) → LLM
- Performance (knowing that) → KG
Strengths of this model:
- Facts can be updated without retraining the LLM.
- Provenance is clear—you can trace which KG triple informed a response.
- Hallucinations are reduced—the LLM isn't generating facts from its weights.
- Smaller models suffice—if you don't need to memorize facts, you can train on language structure alone.
Vrandečić's Vision: Abstract Wikipedia would allow LLMs to generate language in any native tongue while querying a language-independent knowledge base. The LLM becomes a "Rosetta Stone" for expression, not a repository of facts.
Andrej Karpathy and others argue:
- Some factual knowledge must be embedded for fluent language understanding.
- Constant KG queries are impractical for latency and cost reasons.
- World knowledge enables inference—you can't reason about facts you don't have access to.
Theoretical Model: This is a hybrid architecture:
- Embedded knowledge: High-frequency, foundational facts (e.g., "Paris is the capital of France")
- External KG: Long-tail, rapidly changing, or highly specific facts
Cognitive Analogy: This mirrors human memory:
- Semantic memory (embedded general knowledge) → LLM weights
- Episodic/reference memory (specific facts) → KG queries
Karpathy's Argument: Humans don't look up every fact—we have a baseline of internalized knowledge that enables fluent conversation. LLMs need the same.
Using our five-axis framework:
| Axis | Pure LLM | Pure KG Query | Hybrid (LLM + KG) |
|---|---|---|---|
| Representation | Opaque (weights) | Structured (triples) | Hybrid |
| Agency | Model-determined | System-determined | Negotiated |
| Temporality | Static (until retrained) | Dynamic (KG updates) | Dynamic for KG facts |
| Structure | Implicit (latent) | Explicit (graph) | Hybrid |
| Forgetting | Catastrophic (retraining) | None (explicit updates) | Selective |
Theoretical Position: LLM + KG systems occupy a unique niche—they're neither pure memory systems nor pure reasoning engines. They're hybrid cognitive architectures that separate:
- Procedural/linguistic knowledge (LLM weights)
- Declarative/factual knowledge (KG)
Where This Fits:
- This is closest to the External Reference paradigm for the KG portion.
- The LLM itself functions as implicit procedural memory.
Key Insight: The LLM + KG model is orthogonal to the memory systems discussed in Part 1. Those systems are about agent memory (what the agent learns from interaction); LLM + KG is about world knowledge (facts independent of the agent's experience).
Practical Implication: You could build an agent memory system (e.g., Hindsight) on top of an LLM + KG architecture. The agent memory tracks what the agent has learned from users; the KG provides world facts.
Question: What's the minimum knowledge an LLM must have embedded to function as a natural language interface?
Current Consensus (from literature and practitioner reports):
- Lexical semantics: Word meanings, synonyms, antonyms.
- Syntactic knowledge: Grammar, sentence structure.
- Pragmatic knowledge: How language is used in context (implicature, speech acts).
- Commonsense reasoning: Basic physical and social intuitions (objects fall, people have intentions).
- High-frequency facts: Common knowledge that would be tedious to look up (capitals, basic history).
What Can Be Outsourced:
- Long-tail facts (specific dates, obscure entities)
- Rapidly changing information (stock prices, current events)
- Domain-specific knowledge (medical diagnoses, legal precedents)
Theoretical Implication: This suggests a continuum of embeddedness:
Pure Syntax ←→ Commonsense ←→ World Facts ←→ Domain Expertise
│ │ │ │
Must be Should be Can be Should be
embedded embedded hybrid external
Open Question: Can an LLM trained only on syntax and pragmatics (no factual knowledge) learn to query KGs effectively? Early experiments suggest no—the LLM needs some world knowledge to formulate meaningful queries.
Question: Can AI long-term memory be human-readable? Does transparency limit capability?
Arguments for Human-Readable:
- Debuggability: You can inspect and fix errors.
- Trust: Users can verify what the agent "knows."
- Editability: Humans can correct or augment agent knowledge.
- Compliance: Auditable for regulated industries.
Arguments for Opaque/Compressed:
- Efficiency: Vector embeddings are more compact than text.
- Associative retrieval: Similarity search captures relationships text can't express.
- Capacity: You can store more in the same space.
The Compression Analogy (JPG/JXL vs. text):
- JPG: Lossy compression optimized for human perception, not human editing. You can't easily modify a JPG to change one detail.
- Vector embeddings: Lossy compression optimized for similarity search, not human understanding.
Is This What Vector Databases Are?: Yes, essentially. They store semantic features extracted by the embedding model, not the original content. The "meaning" is distributed across dimensions, not localized.
Progressive Disclosure as a Middle Ground:
- Store memories at multiple levels of abstraction:
- Raw text (human-readable)
- Summaries (condensed but readable)
- Embeddings (opaque, for retrieval)
- Retrieve at the appropriate level based on task.
Theoretical Conclusion: Transparency does limit raw capacity and retrieval speed, but it enables metacognitive oversight—the ability to inspect, critique, and revise what the system knows. For high-stakes applications, this trade-off is worthwhile.
Question: Has REM sleep-style consolidation been explored for AI? Should it be?
Current Research:
-
Generative Replay (continual learning literature):
- Systems "replay" past experiences during offline periods.
- Prevents catastrophic forgetting in neural networks.
- Analogous to slow-wave sleep consolidation.
-
Dream-Like Simulation (reinforcement learning):
- Agents generate synthetic experiences to practice skills.
- Similar to REM sleep hypothesis (threat simulation, skill rehearsal).
-
NeuroDream (2024):
- Explicitly models sleep-inspired consolidation.
- Replays and restructures experiences acquired during "wakefulness."
Should It Be Explored?: Yes, for several reasons:
- Catastrophic forgetting is a major problem in continual learning.
- Memory integration (connecting new memories to old) is underdeveloped in AI.
- Creative insight often emerges from sleep in humans—could AI benefit similarly?
Implementation Challenges:
- Computational cost: Replay requires additional compute cycles.
- Hallucination risk: Generative replay could create false memories.
- Evaluation: How do you measure whether consolidation "worked"?
Theoretical Insight: Human sleep serves multiple functions (consolidation, emotional processing, creative recombination). AI systems might need different consolidation mechanisms for different memory types:
- Episodic memories: Replay for integration.
- Procedural memories: Simulation for skill refinement.
- Semantic memories: Abstraction for generalization.
Question: Can external memory alone enable true learning, or must weights change?
The Analogy:
- External memory ≈ Human explicit knowledge (facts you can state)
- Weight modification ≈ Human implicit knowledge (skills, habits, intuitions)
- Epigenetics analogy: Selective activation of weight clusters ≈ gene expression regulation
Arguments for External Memory Only:
- Safety: Weights are hard to audit; external memory is inspectable.
- Reversibility: You can delete a memory; you can't easily "unlearn" weights.
- Modularity: Separate learning (memory) from capability (weights).
Arguments for Weight Modification:
- True skill acquisition: Some knowledge is procedural, not declarative.
- Efficiency: Retrieving from weights is faster than external lookup.
- Integration: Weights encode relationships between concepts, not just facts.
The Epigenetics Middle Ground:
- Parameter-Efficient Fine-Tuning (PEFT): Modify small subsets of weights (adapters, LoRA).
- Mixture of Experts: Activate different weight clusters for different tasks.
- Conditional computation: Route inputs through different network paths based on context.
Theoretical Position: External memory is necessary but not sufficient for human-like learning. Some knowledge must become "muscle memory" (encoded in weights) for fluent performance. The epigenetics analogy is promising: rather than rewriting all weights, selectively activate or modestly adjust specific circuits.
Open Question: What's the minimum weight modification needed for genuine skill acquisition? Current PEFT methods suggest <1% of parameters can enable significant adaptation.
Question: How should older memories evolve? Is forgetting beneficial?
Cognitive Science Insights:
- Ebbinghaus Forgetting Curve: Memory decays exponentially without reinforcement.
- ACT-R Theory: Memories have base-level activation that decays, but is boosted by retrieval.
- Adaptive Forgetting: Forgetting irrelevant information improves decision-making by reducing interference.
AI Implementations:
- Decay functions:
activation = base * exp(-λ * time) - Frecency weighting: Combine frequency + recency (like browser history).
- Spaced repetition: Reinforce memories at increasing intervals.
Should Older Memories Decay, Crystallize, or Transform?:
| Memory Type | Recommended Dynamics | Rationale |
|---|---|---|
| Episodic (specific events) | Decay + occasional crystallization | Most events aren't important; some become defining memories |
| Semantic (facts) | Crystallize (stable) | Facts don't change; confidence should increase with verification |
| Procedural (skills) | Transform (refine) | Skills improve with practice; old versions are replaced |
| Beliefs (synthesized conclusions) | Transform (revise) | Beliefs should update with new evidence |
Is Selective Forgetting Beneficial?: Yes, for three reasons:
- Reduced interference: Irrelevant memories compete with relevant ones during retrieval.
- Computational efficiency: Smaller memory stores are faster to search.
- Adaptive relevance: What mattered last year may not matter now.
Techniques for Reinforcing Low-Saliency Memories:
- Spaced repetition: Schedule reviews at optimal intervals.
- Dream-like replay: Reactivate memories during offline periods.
- Cross-referencing: Link low-saliency memories to high-saliency ones (elaborative encoding).
Theoretical Conclusion: Forgetting is a feature, not a bug. The goal isn't perfect retention—it's optimal retention for current and future tasks.
Question: Should memory retrieval be deterministic? Can it be?
The Tension:
- Determinism: Same query → same result. Desirable for debugging and compliance.
- Flexibility: Context-dependent retrieval. Desirable for adaptability.
Current Reality: Most systems are non-deterministic due to:
- Approximate nearest neighbor (ANN) search in vector DBs.
- LLM-based extraction/reranking (stochastic).
- Temporal decay (results change over time even for same query).
Should Retrieval Be Deterministic?:
| Use Case | Determinism Needed? | Rationale |
|---|---|---|
| Medical/Legal | Yes | Auditable, reproducible decisions |
| Creative/Exploratory | No | Variety and surprise are features |
| Personal Assistants | Hybrid | Core facts should be stable; suggestions can vary |
Maximizing Consistency:
- Deterministic retrieval: Use exact search (not ANN) for critical facts.
- Versioned memories: Track which version of a memory was retrieved.
- Consolidation logs: Record how memories changed during each consolidation loop.
Theoretical Insight: Perfect determinism is incompatible with adaptive memory. As memories evolve (decay, consolidate, integrate), retrieval should change. The goal is traceable non-determinism—you can reconstruct why the result changed.
Under-Explored Parallels:
-
Information Theory:
- Rate-distortion theory: What's the minimum information needed to preserve utility?
- Application: Optimize compression vs. fidelity trade-offs in memory representation.
-
Database Theory:
- ACID properties: Should AI memory have atomicity, consistency, isolation, durability?
- Application: Transactional memory updates for multi-agent systems.
-
Evolutionary Biology:
- Memetics: Memories as replicators that compete for retention.
- Application: Model memory survival as evolutionary fitness (useful memories persist).
-
Economics:
- Attention economy: Memories compete for limited retrieval "attention."
- Application: Market-based models where memories "bid" for retrieval priority.
-
Developmental Psychology:
- Scaffolding: Early memories support later learning.
- Application: Bootstrap memory systems with curated "developmental" experiences.
-
Anthropology:
- Oral tradition: How cultures preserve knowledge without writing.
- Application: Narrative-based memory structures (stories are more memorable than facts).
Promising Research Directions:
-
Narrative Memory: Store experiences as stories with plot structure, not just facts. Humans remember narratives better than isolated events.
-
Emotional Tagging: Attach affective valence to memories. Emotion enhances retention in humans; could it do the same for AI?
-
Social Memory: Multi-agent shared memory with provenance and trust metrics. Who told the agent this? How reliable is the source?
-
Embodied Memory: Link memories to sensorimotor contexts. Humans remember better when context matches; AI could benefit similarly.
-
Metacognitive Monitoring: Agents that track their own memory confidence and request clarification when uncertain.
Key Takeaways:
- Memory systems vary along five theoretical axes: transparency, agency, temporality, structure, and forgetting philosophy.
- Five paradigms emerge: External Reference, Externalized Cognition, Multi-Store, Temporal Knowledge, and Emergent.
- Cognitive analogies are partially justified—the best systems operationalize specific mechanisms (temporal validity, metacognitive control), not just metaphors.
- Hindsight, Zep, and Letta represent the most cognitively sophisticated approaches, each embodying different theoretical commitments.
Key Takeaways:
- The Vrandečić position (LLMs as NL interfaces to KGs) and Karpathy counterpoint (embedded knowledge is necessary) are both partially correct.
- LLM + KG systems are orthogonal to agent memory systems—they address world knowledge, not agent learning.
- A minimal baseline of embedded knowledge is required for effective language understanding (syntax, pragmatics, commonsense, high-frequency facts).
- The optimal architecture is hybrid: embed foundational knowledge, externalize long-tail and rapidly changing facts.
Key Takeaways:
- Human-readable memory trades capacity for debuggability and trust. Progressive disclosure (multiple abstraction levels) offers a middle ground.
- Sleep-inspired consolidation is underexplored but promising for preventing catastrophic forgetting and enabling creative insight.
- External memory alone is insufficient for human-like learning; some weight modification (perhaps epigenetics-style) is necessary for procedural knowledge.
- Forgetting is adaptive, not a bug. Decay, crystallization, and transformation should apply to different memory types differently.
- Determinism is desirable for compliance but incompatible with adaptive memory. Aim for traceable non-determinism.
- Cross-pollination from information theory, economics, and developmental psychology offers promising research directions.
The field is moving from storage-centric models (how do we store more?) to cognitive-centric models (how do we learn, adapt, and reason over time?). The most promising systems:
- Treat memory as active, not passive—agents manage their own memories.
- Embrace temporality—facts change, and memory systems should track this.
- Balance transparency and efficiency—some memories should be inspectable, others compressed.
- Operationalize forgetting—decay and consolidation are features, not bugs.
- Integrate multiple memory types—episodic, semantic, procedural, and belief-based memories require different handling.
The Grand Challenge: Build memory systems that don't just store the past but learn from it—transforming raw experience into wisdom through consolidation, abstraction, and integration.
The next breakthrough won't come from bigger vector databases; it'll come from better theories of what memory is for.