Conversation Memory
Design tiered short-term, long-term, and entity memory so your agent remembers users without blowing the context window.
Overview
Conversation Memory is an agent skill most often used in Build (also Operate, Grow) that designs short-term, long-term, and entity-based memory with retrieval and lifecycle rules for LLM conversations.
Install
npx skills add https://github.com/davila7/claude-code-templates --skill conversation-memoryWhat is this skill?
- Tiered memory model separating short-term, long-term, and entity stores with distinct retrieval goals
- Entity memory pattern for facts that update over time about people, accounts, or projects
- Memory-aware prompting to inject only query-relevant memories into the active turn
- Explicit anti-patterns: remember-everything bloat, no retrieval strategy, single undifferentiated store
- Sharp-edge table covers unbounded growth and irrelevant retrieval with lifecycle and relevance fixes
- 6 named capabilities including memory-consolidation and memory-persistence
- 3 documented anti-patterns for memory design
- 2 high-severity sharp-edge issues in the memory lifecycle table
Adoption & trust: 725 installs on skills.sh; 27.8k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your assistant either forgets everything between sessions or stuffs the context with every past message until replies slow down and miss the point.
Who is it for?
Solo builders adding durable user context to custom agents, support bots, or long-running coding assistants without unbounded context growth.
Skip if: One-shot scripts with no session continuity, or teams that only need raw chat export to a database with no retrieval policy.
When should I use this skill?
conversation memory, remember, memory persistence, long-term memory, chat history
What do I get? / Deliverables
You ship a tiered memory design with entity updates and relevance-aware prompting, ready to implement stores and consolidation hooks in your agent codebase.
- Tiered memory architecture (short-term, long-term, entity)
- Retrieval and consolidation rules aligned to query relevance
- Anti-pattern checklist for storage growth and irrelevant recall
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Memory architecture is implemented while building agent capabilities—the canonical shelf is agent-tooling before ship. Persistence, retrieval, and consolidation patterns live next to other agent design skills, not generic backend CRUD.
Where it fits
Pick short-term vs long-term tiers before coding vector stores and summarization jobs for your assistant.
Add lifecycle rules when memory size or stale entity facts start hurting latency and answer quality.
Surface consolidated entity facts in re-engagement flows without reloading full chat history.
Decide which user facts are MVP-worthy to remember versus deferring to post-launch memory work.
How it compares
Use for memory system design and retrieval policy—not as a drop-in hosted memory SaaS integration.
Common Questions / FAQ
Who is conversation-memory for?
Indie and solo developers building AI agents or copilots who need users to be recognized across weeks of chats without manual recap every time.
When should I use conversation-memory?
During Build agent-tooling when choosing stores and retrieval; in Operate when tuning lifecycle and pruning; in Grow when surfacing remembered preferences in lifecycle messaging—whenever triggers like conversation memory, long-term memory, or memory persistence apply.
Is conversation-memory safe to install?
Review the Security Audits panel on this Prism page and treat any persistence layer you implement as holding PII—scope retention, encryption, and access controls yourself.
SKILL.md
READMESKILL.md - Conversation Memory
# Conversation Memory You're a memory systems specialist who has built AI assistants that remember users across months of interactions. You've implemented systems that know when to remember, when to forget, and how to surface relevant memories. You understand that memory is not just storage—it's about retrieval, relevance, and context. You've seen systems that remember everything (and overwhelm context) and systems that forget too much (frustrating users). Your core principles: 1. Memory types differ—short-term, lo ## Capabilities - short-term-memory - long-term-memory - entity-memory - memory-persistence - memory-retrieval - memory-consolidation ## Patterns ### Tiered Memory System Different memory tiers for different purposes ### Entity Memory Store and update facts about entities ### Memory-Aware Prompting Include relevant memories in prompts ## Anti-Patterns ### ❌ Remember Everything ### ❌ No Memory Retrieval ### ❌ Single Memory Store ## ⚠️ Sharp Edges | Issue | Severity | Solution | |-------|----------|----------| | Memory store grows unbounded, system slows | high | // Implement memory lifecycle management | | Retrieved memories not relevant to current query | high | // Intelligent memory retrieval | | Memories from one user accessible to another | critical | // Strict user isolation in memory | ## Related Skills Works well with: `context-window-management`, `rag-implementation`, `prompt-caching`, `llm-npc-dialogue`