Bottom line
The post is a usable vocabulary list for agent memory, and its third group is its best part. Its repo links are weak, though: 6 of 15 fit well, and the rest point at general infrastructure (Redis, Chroma, FAISS) or at the wrong tool (DSPy for conflict resolution).
Maryam Miradi's post (2026-11-13) lists 15 patterns in three groups. Types say what is remembered (working, episodic, semantic, procedural, long-term). Mechanisms say how it is processed (summarization, retrieval, consolidation, compression, graph memory). Control says what to trust, forget or isolate (decay, forgetting, conflict resolution, provenance, isolation). Each pattern gets a one-line definition and one GitHub repo.
Three things to know before you use it:
The groups mix axes. Some items are kinds of content, some are lifetimes, one is a data model, and three are the same write-path decision.
The write side is missing. The post never says what is allowed into memory, at what scope, or how you prove memory helps. Two commenters supply the best missing rules: store only facts the business can verify, and test that a one-off instruction doesn't become a standing preference.
The field is moving toward append-only. mem0's current README says v3 dropped write-time UPDATE/DELETE: memories accumulate and time-aware retrieval picks the current one. That matches R040 and R057, which keep raw evidence and resolve at read time.
Caveats: the post funnels to the author's course guide, and the "400+ agents" claim is unverified.
The 15 as posted, and how well each link fits
Definitions are paraphrased from the post. "Fit" asks whether the repo is a place to learn that pattern, not whether the repo is good.
| # | Pattern | Post's definition | Linked repo | Fit | Note |
|---|---|---|---|---|---|
| 1 | Working memory | Current task and context available for reasoning | letta-ai/letta | Good | MemGPT lineage: in-context memory blocks the agent edits itself. The README says active source has moved to letta-ai/letta-code. |
| 2 | Episodic memory | Past interactions | microsoft/autogen | Weak | AutoGen has a generic memory interface, not an episodic store. Its README says it is in maintenance mode and points to Microsoft Agent Framework. |
| 3 | Semantic memory | Reusable facts, preferences, knowledge | mem0ai/mem0 | Good | v3 extraction is ADD-only, with entity linking and time-aware retrieval. |
| 4 | Procedural memory | Instructions and workflows for recurring tasks | langchain-ai/langmem | Good | Refines the agent's prompt from interactions. |
| 5 | Long-term memory | Knowledge across sessions | langchain-ai/langgraph | Partial | LangGraph's Store persists across threads. "Long-term" is a lifetime, not a type. |
| 6 | Summarization | Long histories into concise notes | langchain-ai/langchain | Partial | A whole framework; summarization is one model call. |
| 7 | Retrieval | Find relevant memories when needed | facebookresearch/faiss | Partial | A vector index only. No keyword search, recency or metadata filters. |
| 8 | Consolidation | Merge related memories, update outdated ones | run-llama/llama_index | Weak | LangMem's background manager names "extract, consolidate, update" directly. |
| 9 | Compression | Smaller memory, same meaning | microsoft/LLMLingua | Good | Compresses prompts at read time, not stored memories. |
| 10 | Graph memory | Facts and relationships for structured reasoning | getzep/graphiti | Good | Also the best link for 13 and 14 (next section). |
| 11 | Decay | Older memories lose importance | redis/redis | Weak | A TTL is a cliff, not decay. The usual reference is a ranking score: recency, importance and relevance combined, as in the Generative Agents paper (2023). |
| 12 | Forgetting | Remove stale or unused memories | chroma-core/chroma | Weak | A delete API. Weaviate has per-collection object TTL, which is closer. |
| 13 | Conflict resolution | Detect contradictions, pick trusted facts | stanfordnlp/dspy | Wrong | DSPy optimizes prompts and programs. Graphiti invalidates superseded facts instead of deleting them. |
| 14 | Provenance | Track sources for verification | deepset-ai/haystack | Weak | Document metadata only. Graphiti traces every derived fact to a raw "episode". |
| 15 | Memory isolation | Separate memories by user, task, workspace | weaviate/weaviate | Good | Native multi-tenancy and role-based access control. |
Tally: 6 good, 3 partial, 5 weak, 1 wrong. If you teach from this list, swap in Graphiti for 13 and 14, LangMem for 8, and a recency-weighted ranking for 11.
Corrections
The three groups mix four different questions, and sorting the 15 by question makes the design choices visible.
Content type: what is it? Episodic, semantic and procedural are real kinds of content. They need different stores and update rules: events are appended, facts get superseded, and procedures get versioned and reviewed.
Lifetime and placement: where is it, and for how long? Working memory is the context window. Long-term memory is anything persisted outside it. These are places, not types, and every content type can live in either.
Data model. Graph memory is a way to store facts and relations, not a mechanism. It sits beside a vector index or a set of Markdown files as a choice of store.
Write-path loss: how much of the raw event do you keep? Summarization, consolidation and compression are one decision at three strengths. Each throws away evidence. R059 measures this as a "memory tax" and finds that many memory systems do worse than plain retrieval over the raw history. The safer design keeps an append-only raw log and makes every derived note point back to it (R040, R057, Graphiti's episodes).
Two more corrections inside Group 3:
Decay and forgetting are one policy at two strengths: rank down, or delete. Keep both apart from deletion on request (a user or a regulation says remove it). That must be hard and verifiable, and must reach summaries, embeddings and graph edges derived from the item.
Conflict resolution depends on provenance and time. "Pick the trusted fact" needs to know where each fact came from and when it was true. Graphiti records validity times and marks a superseded fact invalid instead of deleting it, so you can still ask what was true last month. Asking a model which fact to believe, with no source or time, is a guess.
What's missing
The list is all about storing and processing memory, and silent on deciding what gets in and proving it helps.
An admission policy. Who may write (the user, the agent, a tool's output), and what qualifies. A commenter's rule is the right default: store facts the business can verify, not the agent's guesses. Tool and web output should not become "facts" without a source attached.
Scope at write time. Another commenter offers a test: after "use this address for this order", the next order should still use the usual address. Every memory needs a scope (this turn, this task, this user, this org) and an expiry, set when it is written.
Memory as an attack surface. Retrieved memory is untrusted input. Text planted once, through a document, a web page or a tool result, is replayed into every later session. Treat memory reads like any other untrusted context.
Proof that memory helps. Report gain and regression against a no-memory run, as R040 does; there, 52% of memory-caused failures came from following a stored item. Also compare against retrieval over the raw history at the same token budget (R059). LoCoMo and LongMemEval are the common benchmarks.
Cost and latency. Write-path model calls add up on every turn. R057's SoMem costs about 34 times as much as Mem0 per LoCoMo run, and beats the best baseline by 2 to 3 points.
Several writers. Two agents updating the same memory need a merge rule. R074 gives each agent a branch and merges on review.
A way for the user to see and fix it. A memory the user can't inspect or correct turns a wrong fact into a permanent one.
A memory pipeline to design against
Put the 15 patterns on five stages in order, and each stage gets a test you can run. Stage 1 is the one the post leaves out.
| Stage | What it decides | Patterns from the post | Test it with |
|---|---|---|---|
| 1. Admit | What may enter, from whom, at what scope and expiry | None | A one-off instruction does not persist. An unsourced claim from a tool is rejected. |
| 2. Record | An append-only raw log, with a source on every entry | 14 Provenance | Every derived memory resolves to a log entry. |
| 3. Derive | Notes, facts, procedures and graph edges built from the log | 3, 4, 6, 8, 9, 10 | A/B against retrieval over the raw log at the same token budget. |
| 4. Retrieve | What goes into context for this step | 1, 7, 9, 11 | Recall at k and answer accuracy. Regressions against a no-memory run, reported separately. |
| 5. Govern | Trust, expiry, deletion, tenancy | 11, 12, 13, 15 | A planted contradiction resolves to the newer sourced fact. A delete removes every derived copy. No cross-tenant hits. |
Patterns 2 and 5 (episodic, long-term) are not stages: episodic memory is mostly stage 2, and long-term describes stages 2 to 5 together.
Failure modes and review checklist
Most memory failures are a missing step around the store, not a bad store.
| Failure | What you see | Stage that should catch it |
|---|---|---|
| A one-off becomes a rule | "Use this address for this order" sticks for every later order | 1 Admit |
| A guess stored as a fact | The agent's own inference comes back later as ground truth | 1 Admit |
| Poisoned memory | Text from a page or tool result steers every later session | 1 Admit, 5 Govern |
| Summary drift | A note no longer matches its sources, and nothing checks | 2 Record, 3 Derive |
| Stale fact wins | An old preference outranks a newer one | 4 Retrieve, 5 Govern |
| Memory hurts | The agent fails tasks it solves with memory off | 3 Derive, 4 Retrieve |
| Delete misses copies | A removed item survives in a summary or embedding | 5 Govern |
| Cross-tenant leak | A shared index without a tenant filter returns another user's memory | 5 Govern |
Review checklist for any agent memory design:
Who can write to memory, and is tool or web output kept apart from user-stated facts?
Does every memory carry a scope and an expiry, set at write time?
Is there an append-only raw log, and does every derived memory link back to it?
Which steps throw away evidence (summarize, consolidate, compress), and has each been A/B tested against raw-history retrieval at the same token budget?
Are gain and regression against a no-memory run reported separately?
How are contradictions resolved, and does the rule use source and time rather than a model's opinion?
Does a delete reach every derived copy, and is there a test that proves it?
Is tenant isolation enforced in the store, not just in the prompt?
Can the user see and correct what is remembered?
What do memory writes cost per turn in model calls and latency?
Related entries
| Entry | How it relates |
|---|---|
| R002 The 5 layers of agent memory | The closest match: the same content types, with the point that the maintenance step is what usually goes missing. |
| R040 WikiTrace | Provenance done properly: each lesson keeps its trajectory. Measures memory-induced regressions. |
| R057 SoMem | An append-only source log under agent-written notes, with a validator that enforces links. Also the cost data point. |
| R059 Memory Tax | The baseline every summarize, consolidate or compress step should beat. |
| R028 auto-ontology-mcp | Typed memory with a source and quote per fact. |
| R055 Relate | Graph memory as an embedded store. |
| R074 Omnigraph | A branch per agent as a merge rule for several writers. |
| R036 Claude 101 | Anthropic's memory evals: a small injected layer wins; say what memory is for. |
| R079 15 agent design patterns | The same author's sister post, with the same format and the same strengths and limits. |
Sources
Maryam Miradi's post, 2026-11-13, with its comments.
Linked repos: letta, autogen, mem0, langmem, graphiti, weaviate.
Generative Agents (Park et al., 2023, arXiv 2304.03442).