cognitive-core 0.0.2 → 0.1.2

package/docs/RESEARCH-semantic-memory-knowledge-structures.md

@@ -0,0 +1,517 @@
+# Research: Semantic Memory & Knowledge Structures for AI Agents
+
+> **Date**: 2026-02-18
+> **Purpose**: Survey of recent (2025+) research on semantic memory, knowledge graphs, and structured knowledge banks for AI agents. Compiled as inspiration for cognitive-core's knowledge bank design.
+
+## Table of Contents
+
+1. [Surveys & Taxonomies](#1-surveys--taxonomies)
+2. [Zettelkasten & Structured Note Systems](#2-zettelkasten--structured-note-systems)
+3. [Knowledge Graph Architectures](#3-knowledge-graph-architectures)
+4. [Event-Centric & Hierarchical Memory](#4-event-centric--hierarchical-memory)
+5. [Memory Consolidation & Organization](#5-memory-consolidation--organization)
+6. [Graph-Based Retrieval](#6-graph-based-retrieval)
+7. [Additional Notable Work](#7-additional-notable-work)
+8. [Synthesis: Key Themes Across Papers](#8-synthesis-key-themes-across-papers)
+
+---
+
+## 1. Surveys & Taxonomies
+
+### 1.1 Memory in the Age of AI Agents (Dec 2025)
+
+> Hu et al. (46 co-authors) — [arxiv.org/abs/2512.13564](https://arxiv.org/abs/2512.13564)
+
+The most comprehensive survey on agent memory to date. Proposes a unified functional taxonomy that maps closely to cognitive science categories.
+
+**Memory taxonomy:**
+
+| Memory Type | Function | What It Stores | Cognitive Analog |
+|---|---|---|---|
+| **Factual / Semantic** | Declarative knowledge | Facts, concepts, relationships | Semantic memory |
+| **Experiential / Episodic** | Event recall | Specific past experiences | Episodic memory |
+| **Procedural / Skill** | How-to knowledge | Reusable strategies, workflows | Procedural memory |
+| **Working** | Active processing | Current task context | Working memory |
+
+**Memory lifecycle** (applies to all types):
+1. **Formation** — How memories are created (extraction from experience, explicit encoding)
+2. **Evolution** — How memories change over time (consolidation, refinement, forgetting)
+3. **Retrieval** — How memories are accessed (similarity search, graph traversal, structured lookup)
+
+**Key insight for cognitive-core:** The survey emphasizes that real-world agent systems need all three long-term memory types working together. Most existing systems only implement one or two. The lifecycle model (formation → evolution → retrieval) is universal — cognitive-core already applies it to playbooks, and the same pattern should extend to semantic memory.
+
+**Identified gaps in current systems:**
+- Most systems store memories as flat text with vector search — no structural organization
+- Few systems handle contradiction detection or memory evolution
+- Cross-memory-type integration (e.g., linking facts to procedures) is largely unexplored
+- Scalability of memory systems beyond toy benchmarks is under-studied
+
+---
+
+### 1.2 Survey on Memory Mechanisms of LLM-based Agents (2025)
+
+> ACM Transactions on Intelligent Systems and Technology — [dl.acm.org/doi/10.1145/3748302](https://dl.acm.org/doi/10.1145/3748302)
+
+Complements the above survey with focus on implementation mechanisms. Categorizes memory systems by:
+
+- **Storage format**: Raw text, structured records, knowledge graphs, vector embeddings
+- **Access pattern**: Sequential scan, similarity search, graph traversal, structured query
+- **Update mechanism**: Append-only, overwrite, merge/consolidate, version
+
+**Relevance:** Validates the hybrid approach (file-based storage + graph overlay + semantic search) as the most flexible architecture. No single storage format or access pattern dominates — the best systems combine multiple.
+
+---
+
+## 2. Zettelkasten & Structured Note Systems
+
+### 2.1 A-MEM: Agentic Memory for LLM Agents (Feb 2025, NeurIPS 2025)
+
+> [arxiv.org/abs/2502.12110](https://arxiv.org/abs/2502.12110)
+
+**The most directly relevant architecture for cognitive-core's knowledge bank.** A-MEM organizes agent memory as interconnected "notes" inspired by the Zettelkasten slip-box method.
+
+**Note structure:**
+Each memory unit is a note containing:
+- Unique identifier
+- Content (the core information)
+- Creation timestamp
+- Contextual descriptions, keywords, and tags
+- Sentence-BERT embedding for semantic similarity
+- Bidirectional links to related notes (forward links + backlinks)
+
+**Memory creation process:**
+1. Agent encounters new information during interaction
+2. Extract key facts from observations
+3. Generate embeddings for semantic matching
+4. Create new notes when content is sufficiently novel (below similarity threshold)
+5. Route notes into existing hierarchy or establish new branches
+
+Critically, the LLM decides **what warrants storage** — not everything is stored. This agentic decision-making prevents memory bloat.
+
+**Linking algorithm:**
+- Similarity-based connections: new note embeddings compared against existing notes
+- Bidirectional relationships: forward links + backlinks for context preservation
+- Hierarchical organization: notes cluster into topic-based groups with parent-child relationships
+- Traversal-based reasoning: agents follow links during reasoning without sequential search
+
+**Historical memory updates (append-only with linking):**
+When new memories arrive:
+1. Identify semantically related historical notes via embedding similarity
+2. Flag conflicting or outdated information
+3. Create additional links rather than replacing existing notes
+4. Preserve temporal metadata for lineage tracking
+
+This append-only approach maintains information lineage while preventing catastrophic forgetting.
+
+**Agentic memory management:**
+The LLM is delegated decisions about:
+- **What to store**: Agent decides whether observations merit persistent memory
+- **How to organize**: System suggests linking patterns; agent validates
+- **When to consolidate**: Periodic review identifies redundant/contradictory notes for merging
+
+**Benchmark results across 6 foundation models:**
+- Tested on: DeepSeek, Claude 3, Claude 3.5, and three additional models
+- 15-35% improvement over baselines on multi-turn tasks
+- Smaller models (7B) benefited most (25-40% improvement)
+- Larger models showed diminishing but still significant returns (5-15%)
+- Benchmarks: DialSim (dialogue), web navigation, evolving-context QA
+
+**Comparison with baselines:**
+- vs. MemGPT: 12-18% higher scores; MemGPT's truncation causes information loss
+- vs. MemoryBank (standard RAG without linking): 8-22% gap
+- vs. Chain-of-Thought without persistence: 30-45% gap on multi-session tasks
+- Bidirectional linking reduced search time ~60% vs. linear retrieval
+- Agentic control reduced hallucinations from irrelevant context by 25%
+
+**What we take from this:**
+- The structured note format with frontmatter (id, tags, links, confidence) directly inspires our `KnowledgeNote` design
+- Bidirectional linking is essential — our graph overlay captures this
+- Append-only with linking (rather than overwrite) is the right evolution model
+- Agentic decision about what to store maps to our dual-path model (extraction pipeline + agent direct writes)
+- The periodic consolidation review maps to our defragmentation process
+
+---
+
+## 3. Knowledge Graph Architectures
+
+### 3.1 MAGMA: Multi-Graph Agentic Memory Architecture (Jan 2026)
+
+> [arxiv.org/abs/2601.03236](https://arxiv.org/abs/2601.03236)
+
+MAGMA argues that a single graph is insufficient — different query types need different graph structures. It decomposes memory into **four orthogonal graph layers**:
+
+| Graph Layer | What It Captures | Edge Semantics | Example Query |
+|---|---|---|---|
+| **Semantic** | Conceptual relationships | "is-a", "part-of", "uses" | "What technologies does React depend on?" |
+| **Temporal** | When things happened/changed | "before", "after", "during" | "What changed after upgrading to v5?" |
+| **Causal** | Cause-and-effect chains | "caused", "enabled", "broke" | "Why did the build fail after that PR?" |
+| **Entity** | Object/agent/component tracking | "owns", "created-by", "interacts-with" | "What components does this service touch?" |
+
+**Key innovation — policy-guided graph traversal:**
+Rather than embedding-based vector search, MAGMA uses learned traversal policies. The agent navigates relationships through the graph structure, deciding at each node which edges to follow based on the query context. This enables multi-hop reasoning that pure similarity search cannot achieve.
+
+**What we take from this:**
+- The multi-graph decomposition is powerful but complex. For v1, our single graph with typed edges (`relation: LinkRelation`) captures the same information without the overhead of maintaining four separate graphs.
+- The typed edges in our design (`related-to`, `caused-by`, `depends-on`, `supersedes`) are a lightweight version of MAGMA's multi-graph approach.
+- If we find that certain query patterns require dedicated graph structures, we can partition later (this is why our design doc mentions domain-split graphs as a scaling option).
+- Policy-guided traversal is interesting for Phase 4 (retrieval) — rather than just returning neighbors, the agent could traverse the graph with intent.
+
+---
+
+### 3.2 Zep / Graphiti: Temporal Knowledge Graph Engine (Feb 2025)
+
+> [arxiv.org/abs/2501.13956](https://arxiv.org/abs/2501.13956)
+
+Zep introduces **Graphiti**, a production-grade temporal knowledge graph engine for agent memory. Key differentiator: it treats time as a first-class citizen.
+
+**Architecture:**
+- **Entity extraction & resolution**: Identifies entities from unstructured conversational/business data, resolves mentions to canonical forms (e.g., "React", "ReactJS", "react" → single entity node)
+- **Dynamic knowledge integration**: Unlike static RAG, continuously incorporates new information from ongoing conversations
+- **Temporal relationship tracking**: Records when facts/relationships were first observed, last confirmed, and whether they've been superseded
+- **Community detection**: Clusters related entities into communities and generates summaries at different granularity levels
+- **Hierarchical retrieval**: Can answer at entity level, community level, or global level
+
+**Benchmark results:**
+- DMR Benchmark: 94.8% accuracy vs. MemGPT's 93.4%
+- LongMemEval: Up to 18.5% accuracy improvement with 90% latency reduction
+- Excels at cross-session information synthesis and long-term context maintenance
+
+**What we take from this:**
+- **Entity resolution** is important — when an agent writes about "TS", "TypeScript", and "typescript", these should resolve to the same entity note. Our entity-level files in `knowledge/entities/` serve this purpose, but we should consider an alias system.
+- **Community summaries** map directly to our domain summaries — periodically generated overviews of clustered knowledge.
+- **Temporal tracking** (when observed, last confirmed) maps to our `created`/`updated` timestamps and confidence decay model.
+- The production focus validates our file-based approach — Zep chose a similar "lightweight persistence + graph overlay" pattern, just with a different storage backend.
+
+---
+
+### 3.3 AriGraph: Learning Knowledge Graphs from Agent Interaction (IJCAI 2025)
+
+> [ijcai.org/proceedings/2025/0002.pdf](https://www.ijcai.org/proceedings/2025/0002.pdf)
+
+Demonstrates how knowledge graphs can be **incrementally built** during agent interaction, rather than constructed offline from a corpus.
+
+**Incremental construction process:**
+At each timestep:
+1. A new episodic vertex is added (recording the specific observation)
+2. An LLM parses the observation to extract relationship triplets (entity-relation-entity)
+3. Triplets update the semantic graph (consolidation from episodic → semantic)
+4. Existing semantic nodes may be updated if new information refines understanding
+
+This creates a dual-layer graph:
+- **Episodic layer**: Specific observations anchored in time (what happened)
+- **Semantic layer**: Generalized knowledge derived from episodes (what is true)
+
+**What we take from this:**
+- This is the **formation mechanism** for our knowledge bank. AriGraph's episodic→semantic consolidation directly parallels our trajectory→observation→entity pipeline.
+- The dual-layer approach validates having both observations (episodic-flavored, anchored to trajectories) and entity notes (semantic, generalized from observations).
+- Incremental construction (per-trajectory extraction, not just batch) is the right approach — our design already supports this.
+
+---
+
+### 3.4 Knowledge Graph Tuning (May 2024)
+
+> [arxiv.org/abs/2405.19686](https://arxiv.org/abs/2405.19686)
+
+Focuses on personalizing LLMs using knowledge graphs built from human feedback. The key idea: knowledge graphs serve as a "cognitive middle layer" between raw data and the LLM.
+
+**Relevance:** Reinforces the concept that knowledge graphs are not just storage — they're an active layer that shapes how information is presented to the model. Our graph overlay + knowledge surfacing serves this same role.
+
+---
+
+## 4. Event-Centric & Hierarchical Memory
+
+### 4.1 CompassMem: Event-Centric Memory as Logic Maps (Jan 2026)
+
+> [arxiv.org/abs/2601.04726](https://arxiv.org/abs/2601.04726)
+
+Based on **Event Segmentation Theory** from cognitive science. Rather than storing flat text chunks, CompassMem segments experiences into discrete events connected by explicit logical relationships.
+
+**Core architecture:**
+- Memory organized as an **Event Graph**
+- Experiences are segmented into meaningful event units (not arbitrary text chunks)
+- Events are connected by logical relationships (causal, temporal, thematic)
+- The graph functions as a "logic map" — agents navigate it strategically rather than relying on surface similarity
+
+**Key innovation — goal-directed navigation:**
+Rather than "find the most similar memory," agents can:
+- Follow causal chains backward to understand why something happened
+- Follow temporal chains forward to predict consequences
+- Navigate thematic connections to gather relevant context for a decision
+
+**Benchmark results:**
+- Tested on LoCoMo and NarrativeQA benchmarks
+- "Consistently improves both retrieval and reasoning performance across multiple backbone models"
+
+**What we take from this:**
+- The event segmentation concept applies to our trajectory processing — rather than treating trajectories as flat step sequences, we could segment them into meaningful "events" (setup → discovery → fix → verification) before extracting knowledge.
+- The goal-directed navigation concept is relevant for Phase 4 retrieval — when surfacing knowledge for a task, the agent could traverse causal chains ("what typically goes wrong when doing X?") rather than just finding similar facts.
+- The logical relationship types (causal, temporal, thematic) align with our `LinkRelation` types.
+
+---
+
+### 4.2 EverMemOS: Self-Organizing Memory Operating System (Jan 2026)
+
+> [arxiv.org/abs/2601.02163](https://arxiv.org/abs/2601.02163)
+
+Treats memory as a full operating system with hierarchical organization that emerges from usage patterns.
+
+**Key idea:** Memory should self-organize based on access patterns and relationships, not be manually curated. Frequently co-accessed memories cluster together; rarely accessed ones get compressed or archived.
+
+**Relevance:** Our defragmentation process serves a similar role — it's the "memory OS" that reorganizes knowledge based on usage and relationships. The self-organizing principle is important: we shouldn't over-engineer the initial taxonomy. Let the directory structure evolve as knowledge accumulates.
+
+---
+
+### 4.3 Dynamic Tree Memory Representation (Oct 2024)
+
+> [arxiv.org/abs/2410.14052](https://arxiv.org/abs/2410.14052)
+
+Moves from flat conversation history to hierarchical tree representations. Conversations are organized into schemas — recurring patterns get lifted into abstract nodes, with specific instances as leaves.
+
+**Relevance:** The observation → entity → domain hierarchy in our design is essentially a three-level tree. This paper validates the intuition that memories should be organized at multiple levels of abstraction.
+
+---
+
+### 4.4 G-Memory: Hierarchical Memory for Multi-Agent Systems (Jun 2025)
+
+> [arxiv.org/abs/2506.07398](https://arxiv.org/abs/2506.07398)
+
+Extends hierarchical memory to multi-agent settings. Each agent maintains local memory, but there's also a shared global memory layer with visibility controls.
+
+**Relevance:** For cognitive-core's team learning features, this suggests that the knowledge bank could have both per-agent knowledge and shared team knowledge. A team-level entity note about "our API conventions" could be distinct from individual-agent observations.
+
+---
+
+## 5. Memory Consolidation & Organization
+
+### 5.1 Nemori: Self-Organizing Agent Memory (Sep 2025)
+
+> [arxiv.org/abs/2508.03341](https://arxiv.org/abs/2508.03341)
+
+Draws from cognitive science models of memory consolidation. Key mechanism: memories undergo a consolidation process where recent episodic memories are gradually transformed into stable semantic knowledge.
+
+**Consolidation stages:**
+1. **Encoding**: Initial storage of raw experience
+2. **Short-term consolidation**: Extraction of key facts, initial linking
+3. **Long-term consolidation**: Integration with existing knowledge, abstraction, schema formation
+4. **Retrieval-induced reconsolidation**: Memories are updated when accessed (not just passively stored)
+
+**What we take from this:**
+- Our three-stage lifecycle (observation → entity → domain summary) mirrors the consolidation pathway.
+- The "retrieval-induced reconsolidation" concept is interesting — when an agent accesses a knowledge note during a task, and that task succeeds, the note's confidence should be reinforced. We capture this via the reinforcement mechanism.
+
+---
+
+### 5.2 Semantic Anchoring in Agentic Memory (Sep 2025)
+
+> [arxiv.org/abs/2508.12630](https://arxiv.org/abs/2508.12630)
+
+Uses linguistic structures (discourse units, semantic frames) as anchors for persistent memory. Rather than arbitrary text chunking, memories are segmented along meaningful linguistic boundaries.
+
+**Relevance:** Our knowledge notes are already structured around meaningful semantic units (one fact per observation, one entity per entity note). This paper validates the principle of meaning-based chunking over arbitrary splitting.
+
+---
+
+### 5.3 ComoRAG: Cognitive-Inspired Memory-Organized RAG (Sep 2025)
+
+> [arxiv.org/abs/2508.10419](https://arxiv.org/abs/2508.10419)
+
+Applies cognitive memory organization principles to RAG systems. Introduces "memory-organized" retrieval where the retrieval system mirrors how human memory works — clustering related information, maintaining hierarchical access, and supporting both specific recall and general recognition.
+
+**Relevance:** Validates the hybrid retrieval approach (semantic search + structured browse + graph traversal) that our design proposes. No single retrieval mechanism is sufficient.
+
+---
+
+### 5.4 MemEvolve: Meta-Evolution of Agent Memory Systems (Dec 2025)
+
+> [arxiv.org/abs/2512.18746](https://arxiv.org/abs/2512.18746)
+
+Takes a meta-learning approach: rather than designing a fixed memory system, let the memory architecture itself evolve based on task performance. The system discovers which memory organization patterns work best for which task types.
+
+**Relevance:** Our meta-learning layer (MetaMemory, MetaLearner) could eventually extend to the knowledge bank — learning which knowledge organization patterns are most effective. For now, this is aspirational, but the architecture should allow for it.
+
+---
+
+## 6. Graph-Based Retrieval
+
+### 6.1 GraphRAG: Graph-Based Retrieval-Augmented Generation (Apr 2024, Microsoft)
+
+> [arxiv.org/abs/2404.16130](https://arxiv.org/abs/2404.16130)
+
+Microsoft's influential work on using knowledge graphs to enhance RAG. Introduces the distinction between **local queries** (about specific entities) and **global queries** (about themes/patterns across a corpus).
+
+**How it works:**
+1. LLM extracts entities and relationships from source documents → knowledge graph
+2. Community detection groups closely related entities into clusters
+3. Pre-generated community summaries provide different granularity levels
+4. For queries: each relevant community summary generates a partial response → consolidated into final answer
+
+**Key insight — local vs. global:**
+- Standard RAG only handles local queries well ("What is X?")
+- GraphRAG enables global queries ("What are the main themes in this dataset?") by leveraging community summaries
+- Scales to 1M+ token datasets where standard RAG fails
+
+**What we take from this:**
+- The community detection → summary pattern directly maps to our domain summaries. Entity notes cluster within domains; domain summaries provide the "global view."
+- For knowledge bank queries like "What do I know about our database stack?", a domain summary is more useful than returning individual observations.
+- The graph construction approach (LLM extracts entities + relationships from text) could augment our knowledge extraction pipeline.
+
+---
+
+### 6.2 HippoRAG: Neurobiologically Inspired Long-Term Memory (May 2024)
+
+> [arxiv.org/abs/2405.14831](https://arxiv.org/abs/2405.14831)
+
+Inspired by the hippocampal indexing theory of human memory. The hippocampus doesn't store memories directly — it stores an index of pointers to memory traces distributed across the neocortex.
+
+**Architecture:**
+- **Neocortex analog**: LLM's parametric knowledge (base model weights)
+- **Hippocampal index**: Knowledge graph that indexes relationships between concepts
+- **Pattern completion**: Given a partial cue, the index activates related memories
+
+**Retrieval process:**
+1. Query triggers entity recognition
+2. Recognized entities activate related nodes in the knowledge graph
+3. Graph traversal expands to connected concepts (pattern completion)
+4. Activated memory traces are retrieved and assembled
+
+**What we take from this:**
+- The "index of pointers" metaphor is exactly what our graph overlay does — it doesn't store the knowledge itself (that's in the markdown files), it indexes relationships to accelerate retrieval.
+- Pattern completion (start from a cue, expand via graph) is a powerful retrieval strategy for our graph traversal operations.
+
+---
+
+### 6.3 Hierarchical Aggregate Tree for RAG (Jun 2024)
+
+> [arxiv.org/abs/2406.06124](https://arxiv.org/abs/2406.06124)
+
+Organizes memories in a tree structure where leaf nodes are specific memories and internal nodes are aggregated summaries. Retrieval starts at the root and navigates down to relevant branches.
+
+**Relevance:** Another validation of the multi-level hierarchy approach. Our `domain-summary → entity → observation` is a three-level aggregate tree.
+
+---
+
+## 7. Additional Notable Work
+
+### 7.1 SGMem: Sentence Graph Memory for Conversational Agents (Sep 2025)
+
+> [arxiv.org/abs/2509.21212](https://arxiv.org/abs/2509.21212)
+
+Fine-grained memory at the sentence level, with graph connections between sentences. Useful for conversational agents where individual statements carry independent significance.
+
+**Relevance:** Our observation-level notes are conceptually similar to sentence-level memory — atomic, independently linkable units of knowledge.
+
+---
+
+### 7.2 MIRIX: Multi-Agent Memory System (Jul 2025)
+
+> [arxiv.org/abs/2507.07957](https://arxiv.org/abs/2507.07957)
+
+Memory system designed for multi-agent collaboration. Addresses the challenge of multiple agents contributing to a shared knowledge base while maintaining coherence.
+
+**Relevance:** Relevant for cognitive-core's team learning features. When multiple agents operate on the same knowledge bank, conflict resolution and merge strategies become critical.
+
+---
+
+### 7.3 Editable Memory Graphs for Personalized Agents (Sep 2024)
+
+> [arxiv.org/abs/2409.19401](https://arxiv.org/abs/2409.19401)
+
+Focuses on making knowledge graphs editable — agents can propose changes, verify consistency, and update relationships. Includes rollback mechanisms for incorrect updates.
+
+**Relevance:** Our evolution model (reinforcement, contradiction, supersession) needs similar editability guarantees. The rollback concept is interesting — if a supersession was wrong, can we restore the previous knowledge?
+
+---
+
+### 7.4 Memory-augmented Query Reconstruction for KG Reasoning (Mar 2025)
+
+> [arxiv.org/abs/2503.05193](https://arxiv.org/abs/2503.05193)
+
+Uses memory to improve how queries are formulated against knowledge graphs. Past successful queries inform future query construction.
+
+**Relevance:** Meta-learning for retrieval — tracking which query patterns against the knowledge bank work best. Could inform our retrieval strategy selection in Phase 4.
+
+---
+
+### 7.5 LLM-empowered Knowledge Graph Construction Survey (Oct 2025)
+
+> [arxiv.org/abs/2510.20345](https://arxiv.org/abs/2510.20345)
+
+Comprehensive survey on using LLMs to build knowledge graphs. Describes KGs as "cognitive middle layer" and "living cognitive infrastructure." Covers entity extraction, relation identification, schema induction, and graph completion.
+
+**Relevance:** If we decide to enrich our graph overlay with LLM-extracted relationships (Phase 2 extraction pipeline), this survey provides the technical foundation for how to prompt LLMs for entity/relation extraction.
+
+---
+
+## 8. Synthesis: Key Themes Across Papers
+
+### Theme 1: Multi-Level Abstraction is Essential
+
+Nearly every paper organizes knowledge at multiple granularity levels:
+- AriGraph: episodic vertices → semantic graph
+- GraphRAG: entities → communities → global summaries
+- A-MEM: individual notes → topic clusters → hierarchical organization
+- Nemori: raw encoding → consolidated facts → abstract schemas
+
+**Our design:** observations → entity notes → domain summaries (three-level hierarchy).
+
+### Theme 2: Graphs Beat Flat Vector Search
+
+Papers consistently show that graph-structured memory outperforms flat embedding-based retrieval, especially for:
+- Multi-hop reasoning ("What caused X which led to Y?")
+- Global queries ("What do I know about this domain?")
+- Relationship discovery ("How are X and Y connected?")
+
+**Our design:** Graph overlay with typed edges, supporting traversal alongside semantic search.
+
+### Theme 3: Memory Should Evolve, Not Just Accumulate
+
+Static memory stores degrade over time. Effective systems need:
+- Consolidation (episodic → semantic)
+- Contradiction detection and resolution
+- Confidence tracking and staleness decay
+- Periodic reorganization
+
+**Our design:** Knowledge evolution with reinforcement, contradiction detection, confidence decay, and defragmentation.
+
+### Theme 4: The Agent Should Participate in Memory Management
+
+A-MEM, EverMemOS, and MemEvolve all show that letting the agent (or a meta-learning process) make decisions about memory organization outperforms fixed heuristics.
+
+**Our design:** Dual-path creation (extraction pipeline + agent direct writes), agentic defragmentation option, agent can browse and edit knowledge directly.
+
+### Theme 5: Cross-Reference Between Memory Types is Underexplored but Valuable
+
+The survey papers identify this as a gap. Few systems link factual knowledge to procedures, or episodes to concepts. Those that do (AriGraph's dual layer, MAGMA's multi-graph) show significant benefits.
+
+**Our design:** Explicit cross-system links between knowledge notes and playbooks via `source.playbooks` and graph edges with `crossSystem: 'playbook'`.
+
+### Theme 6: File/Text-Based Storage Remains Practical
+
+Despite the sophistication of graph-based approaches, several production systems (Zep, A-MEM) use lightweight persistence (JSON, text files) rather than full graph databases. The graph structure can be maintained as an overlay/index rather than requiring specialized infrastructure.
+
+**Our design:** Markdown files as source of truth, JSON graph overlay, SQLite only for search acceleration (via minimem).
+
+---
+
+## Reading Priority
+
+For anyone working on this feature, recommended reading order:
+
+| Priority | Paper | Why |
+|---|---|---|
+| 1 | [Memory Survey](https://arxiv.org/abs/2512.13564) | Comprehensive taxonomy and gap analysis |
+| 2 | [A-MEM](https://arxiv.org/abs/2502.12110) | Most directly applicable architecture |
+| 3 | [AriGraph](https://www.ijcai.org/proceedings/2025/0002.pdf) | Best model for episodic→semantic extraction |
+| 4 | [MAGMA](https://arxiv.org/abs/2601.03236) | Multi-graph design for future evolution |
+| 5 | [GraphRAG](https://arxiv.org/abs/2404.16130) | Community detection and global queries |
+| 6 | [Zep/Graphiti](https://arxiv.org/abs/2501.13956) | Production temporal KG reference |
+| 7 | [CompassMem](https://arxiv.org/abs/2601.04726) | Event segmentation and logic maps |
+| 8 | [Nemori](https://arxiv.org/abs/2508.03341) | Cognitive science-inspired consolidation |
+| 9 | [HippoRAG](https://arxiv.org/abs/2405.14831) | Graph-as-index retrieval model |
+| 10 | [Agent Memory Paper List](https://github.com/Shichun-Liu/Agent-Memory-Paper-List) | Ongoing curated list (100+ papers) |
+
+---
+
+## Source Repository
+
+The [Agent Memory Paper List](https://github.com/Shichun-Liu/Agent-Memory-Paper-List) on GitHub maintains a curated, categorized list of 100+ papers on agent memory, organized by memory form (token-level, embedding-level, text-level) and function (factual, experiential, procedural). It is actively maintained and a good resource for tracking new publications in this space.