Explicit memory, also known as declarative memory, refers to the conscious, intentional recall of facts, events, and concepts that an agent can directly access and articulate. In AI agent architectures, explicit memory encompasses both semantic memory (general world knowledge and learned facts) and episodic memory (records of specific past experiences and interactions). This distinction, borrowed from cognitive neuroscience, provides a useful framework for designing agent memory systems that can store retrievable knowledge about the world and the agent's own history.

Semantic Memory stores context-independent facts, definitions, rules, taxonomies, and relationships between concepts. It represents what an agent “knows” about the world, abstracted from any specific interaction. Examples include “Python is a programming language,” “the user prefers dark mode,” or “API rate limits are 100 requests per minute.” Semantic memory is timeless: facts are stored without reference to when or how they were learned.

Episodic Memory stores records of specific events and interactions, preserving temporal context. Examples include “On January 15, the user asked about database migration” or “The last deployment failed due to a timeout error.” Episodic memory preserves the when, where, and what of experiences, enabling agents to reference their own history.

The paper “Memory in the Age of AI Agents” (arXiv:2512.13564) proposes a refined taxonomy that classifies factual memory into token-level, parametric, and latent forms, emphasizing that the explicit/implicit divide maps to different storage mechanisms in LLM-based agents. Token-level memory is explicitly present in the context window, parametric memory is baked into model weights, and latent memory exists in intermediate representations like KV caches.¹⁾

Agents store and retrieve explicit knowledge through several complementary approaches:

Vector Databases store embeddings of facts, documents, or conversation snippets for semantic similarity retrieval. When an agent needs to recall relevant knowledge, it encodes the query as a vector and retrieves the nearest neighbors from the store. Systems like Pinecone, Weaviate, Chroma, and Milvus serve as the retrieval backend, using ANN algorithms like HNSW or FAISS indexes.

Knowledge Graphs explicitly model entities and their relationships as nodes and edges. Neo4j is the most widely used graph database for agent knowledge management, supporting Cypher queries for complex relational reasoning. Mem0 Pro integrates knowledge graphs for entity tracking and structured fact traversal. Knowledge graphs excel at answering relational queries (“Who reports to the CTO?”) that vector similarity alone cannot handle.

Hybrid Retrieval combines vector similarity with structured metadata filtering, keyword search (BM25), and graph traversal. This approach, used by Weaviate and Zep, provides both the flexibility of semantic search and the precision of structured queries. Zep's Graphiti engine builds temporal knowledge graphs that track when facts were established, enabling the agent to resolve contradictions by preferring newer information.

Retrieval Timing matters for agent efficiency. Best practices from Azilen (2025) recommend querying semantic memory during the planning phase (before tool selection), not after action execution, to avoid redundant computation and ground decisions in available knowledge.

Explicit knowledge in agent systems takes several forms:

Atomic Facts are the fundamental unit in systems like Mem0, which extracts discrete factual statements from conversations (e.g., “User's preferred language is Python,” “Project deadline is March 30”). These are scoped by user, session, or agent for personalized retrieval.

Document Chunks are segments of longer documents stored with metadata (source, page, timestamp). RAG systems retrieve relevant chunks and inject them into the agent's context for grounded generation.

Structured Records use schemas (JSON, SQL rows, RDF triples) for precise, queryable storage. Enterprise agent systems often maintain structured knowledge bases alongside unstructured vector stores.

Entity-Relationship Models in knowledge graphs represent facts as subject-predicate-object triples, enabling reasoning over multi-hop relationships and supporting explanation generation.

Explicit memory enables several critical agent capabilities:

Personalization. By storing user preferences, past interactions, and stated goals as explicit memories, agents can tailor responses across sessions. Mem0 and LangMem specialize in this, extracting and maintaining user-specific facts.

Domain Expertise. Agents loaded with domain-specific knowledge bases (medical guidelines, legal regulations, technical documentation) can provide expert-level assistance grounded in authoritative sources.

Consistency. Explicit memory prevents agents from contradicting themselves across interactions. When an agent has previously stated a fact, it can retrieve that statement and maintain consistency.

Explainability. Because explicit memories are directly queryable, agents can cite the source of their knowledge, supporting transparency and trust. Knowledge graph-backed systems can trace reasoning paths through entity relationships.

Best practices for enterprise agent knowledge management (Azilen, 2025) emphasize separating semantic from episodic memory, implementing access controls and versioning, aligning with internal taxonomies, and balancing depth versus breadth of knowledge ingestion.

from collections import defaultdict
 
 
class KnowledgeGraph:
    """Simple in-memory knowledge graph storing (subject, predicate, object) triples."""
 
    def __init__(self):
        self.triples: list[tuple[str, str, str]] = []
        self.index_by_subject: dict[str, list[int]] = defaultdict(list)
        self.index_by_object: dict[str, list[int]] = defaultdict(list)
 
    def add(self, subject: str, predicate: str, obj: str):
        """Store a triple and update indexes."""
        idx = len(self.triples)
        self.triples.append
        self.index_by_subject[subject.lower()].append(idx)
        self.index_by_object[obj.lower()].append(idx)
 
    def query(self, subject: str = None, predicate: str = None, obj: str = None) -> list[tuple]:
        """Retrieve triples matching any combination of subject, predicate, object."""
        results = []
        for s, p, o in self.triples:
            if subject and s.lower() != subject.lower():
                continue
            if predicate and p.lower() != predicate.lower():
                continue
            if obj and o.lower() != obj.lower():
                continue
            results.append
        return results
 
    def get_related(self, entity: str) -> list[tuple]:
        """Find all triples where entity appears as subject or object."""
        indices = set(self.index_by_subject.get(entity.lower(), []))
        indices.update(self.index_by_object.get(entity.lower(), []))
        return [self.triples[i] for i in sorted(indices)]
 
 
kg = KnowledgeGraph()
kg.add("Python", "is_a", "Programming Language")
kg.add("Python", "created_by", "Guido van Rossum")
kg.add("[[pytorch|PyTorch]]", "written_in", "Python")
kg.add("[[pytorch|PyTorch]]", "developed_by", "[[meta|Meta]] AI")
kg.add("Transformers", "built_on", "[[pytorch|PyTorch]]")
kg.add("GPT-4", "uses", "Transformers")
 
print("All about Python:", kg.query(subject="Python"))
print("What uses Transformers:", kg.query(predicate="uses"))
print("Related to [[pytorch|PyTorch]]:", kg.get_related("PyTorch"))

• Implicit Memory
• How to Add Memory to an Agent
• Short-Term Memory
• Memory Augmentation Strategies
• Memory Retention