Agent Memory
How AI agents store, recall, and share what they learned across sessions — persistence, A2A, and multi-agent memory.
32 articles
Agent Memory Consolidation Compared
How do memory layers handle automatic consolidation and forgetting? Six systems, six answers for the old record when a newer memory contradicts it.
Agent Memory Deletion: What Survives a Delete
Agent memory deletion reviewed across eleven systems at pinned commits: what a delete touches, whether it reaches derived records and caches, and who is recorded doing it.
Why AI Coding Assistants Repeat Fixed Mistakes: Who Takes an Outcome?
You fixed it, explained it, and it came back next session. Six agent memory systems put to one mechanical question: does anything change when the outcome was bad? Four of the five others publish an input that takes a negative verdict, fewer publish what it moves, and one word returns zero files in all five organisations.
Agent Memory Knowledge Graphs Compared: Does a Read Change the Graph?
Six agent memory systems and all six build a knowledge graph, so the useful question is a different one. The word graph names four different objects here, in all six the edges are made on the write path, and twenty searches for the vocabulary of read-driven association return zero files.
MCP Memory Servers for Claude Code and Cursor (2026): Which Client, and Whose Memory
Six memory systems checked against two named clients. In the terminal, five of five now ship a first-party plugin rather than a bare protocol server, the asymmetry between the two clients flips vendor by vendor, and the row that decides the choice is where the memory is keyed.
Python SDK for Agent Memory, Compared: Eleven Packages, Twelve Rows
Every one of these publishes a one line install command, and not one of them gives you working memory in one line. Three checks, all faster than reading a landing page, tell you what the install line will not: the runtime dependency list on PyPI, the class names the package exports, and the exception the constructor raises when you hand it nothing.
What Survives When AI Agents Restart (2026): Five Coding Tools, Checked Against Their Own Docs
My LLM agents forget conversation history when I restart them. All five coding tools checked here already ship a working resume, so the real gap is narrower: a brand new session, and what compaction drops even when you do resume.
Anthropic's Memory API Has No Ranked Retrieval
Anthropic's memory surfaces ship storage, versioning, consolidation and forgetting. Retrieval is regex over a mounted filesystem, with no relevance model anywhere.
MCP Memory Servers and npx (2026): One Command, Six Different Answers
Type npx into six memory-server MCP vendors' setup docs and get six different answers. Only one actually launches its own server locally with it. Checked live against every vendor's own documentation.
MCP Servers That Share State Across IDEs (2026): One Mechanism, Six Ways It Quietly Stops
Every persistent memory MCP server that claims cross-IDE sharing reduces to the same mechanism: one account, several clients, one backend. Six vendors checked for the concrete, silent way sharing can fail while every client still says connected.
AI Memory APIs That Prune Low-Value Context (2026): Two Mechanisms, Six Systems
Persistent memory APIs compared on two mechanisms people call by one word, clean: outcome-based feedback that reranks a memory after it fails, and consolidation that reorganizes the memory graph itself. Six systems, including our own.
Best Persistent Memory APIs for AI Agents (2026): Six Questions, Six Systems
Six persistent memory APIs for AI agents compared on the six questions that actually decide fit: memory model, cross-client sharing, outcome feedback, multi-agent sharing, cost, and each vendor's own admitted gap.
Hindsight vs Graphiti: Two Answers to the Same Question About Agent Memory
Hindsight and Graphiti answer the same question at different moments: Graphiti at write time with a bi-temporal graph, Hindsight at read time with standing answers. How to choose, and what neither settles.
Memory API Response Shape: Nowhere to Put a Disagreement
A ranked list cannot express supersession, retraction, or authority. Why retrieval flattens conflicts the store holds, and what a response with relations needs.
RAG vs Agent Memory: What the Source Code Actually Shows
At query time a memory layer runs the same hybrid retrieval a RAG stack does, and the shipping source proves it. The difference is on the write path, and it is narrower than the category claims.
Knowledge Graph vs Retrieval for AI Agent Memory
Knowledge graph vs retrieval for AI agent memory: the split that matters is learned vs asserted structure, connected by provenance. Evidence-first guide.
Agent memory: evidence versus policy
Agent memory splits into evidence and policy, not short versus long term: three scopes, the fields each entry needs, and why closing a fact beats replacing it.
Agent memory feedback: the missing signal
Agent memory learns most from explicit feedback, but production agents rarely send it. Measurements show what changes and how to prescribe feedback.
What Is an Agent OS? Six Things the Term Means
Agent OS means six things: a metaphor, academic kernels, a memory pager, a platform, an OS feature, and an inversion. One test tells them apart.
The Missing Layer: No Protocol Says What Agents Know
Agent memory interoperability needs rules for identity, schema, provenance, consistency, and permissions. A2A and MCP do not define them.
AI Introspection: Why a Voice Is Not an Audit
AI introspection is real but unreliable. Chain-of-thought and self-reports cannot replace durable audit records outside the model.
Claude's Global Workspace: Why AI Memory Lives Outside
Anthropic's global workspace research reveals Claude's transient working memory, and why AI agent memory must persist outside the model.
Knowledge-Graph Memory for AI Agents
Knowledge-graph memory reframes agent memory from transcript to navigable substrate — GraphRAG, temporal graphs, PPR, and why it shouldn't rewrite itself.
AI Agent Memory: What It Is
AI agent memory explained: what it is, how it works, the approach families, how it is evaluated, and how to choose a real memory layer.
The A2A Agent Card: How Agents Discover Each Other
What an A2A Agent Card is: JSON at a well-known URL describing an agent's skills, endpoint, and auth — fetched to discover and call it.
A2A Integration How-To (Python)
A2A tutorial for Python: install the SDK, publish an Agent Card, run a server, delegate a task, stream artifacts, and add domain-scoped memory.
A2A Protocol (Agent2Agent), Explained
A2A protocol explained: Agent2Agent primitives, transports, how it complements MCP, and why shared agent memory stays a separate layer.
A2A vs MCP: How They Differ (and Compose)
A2A vs MCP compared: MCP connects agents to tools; A2A connects agents to agents. They compose as complementary layers, not rivals — and leave memory open.
Hebbian memory for AI agents
Hebbian memory for AI agents: how learned associations, automatic query expansion, and outcome feedback differ from static vector database similarity retrieval.
Is Mnemoverse a vector database?
Is Mnemoverse a vector database? No. A vector DB does static similarity retrieval; Mnemoverse adds learning, recency, and consolidation on top.
Rescorla-Wagner for agent memory
Rescorla-Wagner for agent memory: how prediction-error outcome feedback updates valence and improves recall in Mnemoverse.
Shared Memory for Multi-Agent Systems
Shared memory for AI agents needs explicit domains, isolation, and hierarchical reads. Protocols coordinate work; memory preserves context.