Why Do Agents Lose Memory When Sessions Change? Introducing AMCP
These days, agents can do a lot.
They can connect to tools for search, generate answers based on given context, and even collaborate with other agents by dividing roles when needed.
But when you actually use them for a bit longer, you quickly run into a problem.
When the session changes, the memory is lost.
Even though it's the same user, you have to explain your preferences again. Decisions made yesterday don't carry over to today's tasks. If the client or runtime changes, the memory gets trapped inside the product.
We wanted to address this problem in a more structural way. That's why we released AMCP (Agent Memory Continuity Protocol).
In short, AMCP is an open protocol for long-term memory and continuity for agents.
What Is AMCP Trying to Do?
AMCP is not a protocol for changing the model itself. It's not about standardizing prompts, nor about defining inference methods.
What AMCP covers is much narrower, and therefore more practical.
- How to store memory
- How to retrieve it later
- Who created it, and what scope the memory covers
- How long it should be retained
- How to transfer it to other systems
In other words, you can think of it as a minimal contract for handling agent memory in a portable, product-agnostic way.
Why Do We Need This Protocol Now?
There are already many products with memory features. But most of them only work well within a specific product.
As a result, these issues keep repeating:
- Context is reset when a session ends
- It's hard to carry over previous memory when switching clients
- Users have to explain the same preferences and context multiple times
- When moving teams or systems, memory gets locked in
The problem isn't that agents aren't smart enough. It's because memory isn't portable or continuously maintained.
AMCP aims to standardize exactly that point.
MCP, A2A, and AMCP
When describing agent infrastructure these days, the different layers are becoming clearer:
- MCP is the standard for tool and data access
- A2A is the standard for agent-to-agent collaboration
- AMCP is the standard for memory and continuity
We don't see these three as competing. Rather, we think they each serve a different layer.
For example:
- Agents call tools via MCP
- They delegate tasks to other agents via A2A when needed
- They remember the process and results via AMCP
So, our summary sentence is:
MCP gives agents tools. A2A gives them collaboration. AMCP gives them memory.
What Did We Release This Time?
What we've released isn't just a simple idea memo. It's organized as a public repository that you can actually read and review.
Included are:
- Introduction and background of AMCP
- The current public spec
- Implementation status document
- OpenAPI documentation
- Adoption guide
- Examples
- Reference implementation info
GitHub repository:
You can check out the reference implementation on Nexus:
What AMCP Aims to Do
AMCP's goal is not to replace all memory systems at once.
Rather, it's closer to creating a common layer that allows memory to persist across different agents and runtimes.
In other words:
- Not just memory that works within a single product
- But memory that can be transferred across multiple clients and runtimes
- Export/import when needed
- Establishing a baseline for long-term memory and continuity
Challenges Ahead
There's still a lot to do.
- Better examples
- Stronger compliance tooling
- External implementations
- Community feedback
But at least now, when it comes to agent memory, we can present it not just as a "feature inside a product," but as a "protocol that can be discussed openly."
Conclusion
Agents are doing more and more. As that happens, not just short-term response quality, but memory that persists over time becomes important.
AMCP is a protocol released as a starting point for that continuity of memory.
If you're interested, please check out the repository.