Agent Memory: Short-Term, Long-Term, and Episodic (2026)

When to Use

• ✓Conversational agents that need to remember user preferences and past interactions across sessions
• ✓Research agents that accumulate findings over multiple tool calls and need to not repeat work
• ✓Personal assistants that should remember names, preferences, and context about the user
• ✓Multi-session workflows where the agent must pick up where it left off after interruption
• ✓Customer support agents that need access to full conversation history and past ticket resolutions

How It Works

1. 1In-context memory: the current conversation messages. Limited by context window. For long conversations, implement sliding window (keep last N turns) or summary compression (LLM summarizes old turns into a brief).
2. 2External semantic memory: store facts as text chunks in a vector database. Retrieve relevant memories at the start of each turn. Key operations: SAVE (after each turn, extract memorable facts), RETRIEVE (before each turn, search for relevant memories), and FORGET (TTL or explicit deletion).
3. 3Episodic memory: a structured log of events with timestamps. 'On 2026-04-10, the agent searched for X, found Y, and decided Z.' Used by the agent to avoid repeating work and to audit its own decisions.
4. 4Procedural memory: learned user preferences and agent rules stored as key-value pairs or structured documents. 'User prefers Python over JavaScript', 'Always verify price quotes before including in output'. These are loaded into the system prompt.
5. 5Memory management: implement explicit save/load operations. After a conversation ends, run a memory extraction pass to identify facts worth preserving. Use an LLM to score memories by long-term value and discard low-value items.

Examples

from anthropic import Anthropic
from your_vector_db import VectorDB

client = Anthropic()
db = VectorDB()

def chat_with_memory(user_id: str, user_message: str, conversation_history: list):
    # Retrieve relevant memories
    relevant_memories = db.search(
        query=user_message,
        filter={'user_id': user_id},
        top_k=5
    )
    
    memory_context = '\n'.join([m.text for m in relevant_memories])
    system = f'You are a helpful assistant.\n\nRelevant memories about this user:\n{memory_context}'
    
    response = client.messages.create(
        model='claude-3-5-sonnet-20241022',
        system=system,
        messages=conversation_history + [{'role': 'user', 'content': user_message}],
        max_tokens=1024
    )
    
    # Extract and save new memories
    new_facts = extract_memorable_facts(user_message, response.content[0].text)
    for fact in new_facts:
        db.insert(text=fact, metadata={'user_id': user_id, 'date': today()})
    
    return response.content[0].text

def compress_conversation(messages: list, keep_last_n: int = 10) -> list:
    if len(messages) <= keep_last_n:
        return messages
    
    # Summarize older messages
    old_messages = messages[:-keep_last_n]
    recent_messages = messages[-keep_last_n:]
    
    summary_response = client.messages.create(
        model='claude-3-5-haiku-20241022',
        max_tokens=500,
        messages=[{
            'role': 'user',
            'content': f'Summarize this conversation history in 3-5 sentences, preserving key decisions, facts learned, and current task state:\n\n{format_messages(old_messages)}'
        }]
    )
    
    summary = summary_response.content[0].text
    return [
        {'role': 'user', 'content': f'[Conversation summary: {summary}]'},
        {'role': 'assistant', 'content': 'Understood. Continuing from where we left off.'},
        *recent_messages
    ]

Common Mistakes

• ✗Saving too many memories — storing every sentence from every conversation creates a noisy memory store where relevant memories are buried. Save only: user preferences stated explicitly, important decisions made, key facts about the user/domain.
• ✗Retrieving memories without recency weighting — a memory from 6 months ago about the user's project may be outdated. Add recency weighting to memory retrieval: boost memories from the last 7 days, discount memories older than 90 days.
• ✗Blindly trusting retrieved memories — memories can be stale or incorrect. When using a memory, the agent should verify it's still relevant: 'Based on our conversation from last week, you were working on X — is that still the case?'
• ✗No memory deletion — without explicit memory management, the memory store grows forever. Implement TTL (delete after 90 days), explicit user commands ('forget X'), and periodic cleanup of contradicted memories.

FAQ