Memory Layer for Agents

What's in this pack

This pack collects the seven memory-layer assets that show up in every agent that needs to remember things between sessions without re-pasting them into the prompt every time. Three are the canonical libraries. Four are pattern templates that wrap them — patterns Anthropic and OpenAI both surface in their long-running-agent guides.

Why this matters

The default Claude / GPT-4 / Gemini setup has zero memory. Every conversation starts fresh. Most apps fake memory by stuffing previous turns into the system prompt — that works for a while, then your context window blows up, your bill triples, and the model loses the plot. Memory layers solve this by storing facts outside the prompt and only injecting the relevant ones per turn.

The three libraries each pick a different bet:

• Mem0 is the easiest. One mem0.add(messages, user_id=...) call and the library extracts what's worth remembering. Best for chatbot-style apps with a clear user identity.
• Zep is the production option. Runs as a service, gives you a temporal knowledge graph (memories with timestamps and relationships), and supports multi-tenant. Best when you need audit trails or memory shared across an org.
• Cognee is the graph-native bet. It models memory as a knowledge graph from day one — useful if your domain is research, code, or anything with strong entity relationships.

The four patterns aren't libraries — they're prompt templates and small adapters that work with any of the three. They're the difference between "I installed Mem0" and "memory actually works in my app."

Install in one command

# Install the entire pack
tokrepo install pack/agent-memory-layer

# Or install one library at a time
tokrepo install mem0
tokrepo install zep
tokrepo install cognee

The TokRepo CLI normalizes file placement: Claude Code subagents into .claude/agents/, Cursor rules into .cursor/rules/, AGENTS.md entries for Codex CLI. The library installs are pip/npm — TokRepo just wires them into your AI tool's config so the agent knows the memory layer exists.

Common pitfalls

• Don't store everything. Memory cost scales with what you write, not what you retrieve. Use a fact extractor (pattern #6) to filter — only durable facts about the user/project belong in long-term memory.
• Don't skip the recency bias. Pure vector recall pulls semantically-similar but stale memories. Zep's temporal graph and Mem0's update-in-place both fix this; if you roll your own, weight by recency or you'll keep retrieving 6-month-old context.
• Don't share user IDs across tenants. All three libraries support per-user namespaces. Use them. Memory leakage between users is a much worse incident than no memory at all.
• Token budget the recall step. Even with a memory layer, you can blow your context window if you set top_k=50 for retrieval. Start at top_k=5 and tune up only if recall is missing.
• Reconcile on conflict. If the user says "I'm vegetarian" in March and "I'm vegan" in May, you need an update strategy. Mem0 handles this automatically; Zep gives you the conflict surface; Cognee leaves it to you.

Common misconceptions

"RAG and memory are the same thing." They're not. RAG retrieves from a static corpus (docs, codebase). Memory writes new entries based on what the user/agent said and retrieves them later. RAG is read-only; memory is read-write. The patterns in pack/rag-pipelines are different from this pack on purpose.

"I can just use the conversation history." For a 5-turn session, sure. For an app where the same user comes back next week, no — you'd have to feed every prior turn into the prompt forever. Memory extracts the facts and discards the chat.

"Mem0 vs Zep is a hard choice." Most teams use Mem0 first because it's a 5-minute setup, then graduate to Zep when they need multi-tenant or audit. The two are similar enough that migration is a weekend, not a quarter.