The agent infrastructure stack has spent the last eighteen months standardizing three of its four layers. MCP won tools. A2A is closing in on agent-to-agent communication. PAP is mapping identity and permissions. But the fourth layer – state management, where an agent’s memory, context, and session persistence actually live – remains a land grab with fourteen-plus vendors, zero shared protocols, and no portability guarantee.
This is not a gap. It is a moat in formation.
Four layers, three protocols, one problem
The agent stack now reads like a clean diagram: tools at the bottom (MCP), agents talking to each other above that (A2A), identity and permissions layered on top (PAP), and state management sitting at the apex. Each of the first three layers has at least one emerging standard. State management has none.
The reason matters. MCP standardizes transport – how an agent calls a tool. A2A standardizes communication – how agents coordinate. PAP standardizes authorization – who gets to do what. But none of these protocols define how an agent remembers what it did yesterday, how it builds context from a customer conversation, or how it persists a session across restarts. That is the state layer. And it is where the agent economy’s lock-in will concentrate.
The vendor landscape: fourteen approaches, zero interop
The state management layer currently hosts at least 14 vendors operating across roughly seven distinct architectural camps.
Mem0 leads the extract-and-retrieve approach: vector-first, two-phase memory that extracts facts from conversations and retrieves them by semantic and keyword search. With approximately 59,900 GitHub stars and Y Combinator backing, it has become the default choice for teams building chatbots and B2B copilots that need conversational recall.
Zep takes a different path with temporal knowledge graphs. Its Graphiti engine models facts with both valid time and transaction time, tracking when something was true and when it was recorded. This makes it particularly useful for enterprise agents that need to understand how customer situations change over time.
Letta, the company that grew out of the MemGPT research at UC Berkeley, lets agents edit their own memory blocks through tool calls – an operating system approach where the agent itself decides what to remember and what to forget. Its research on sleep-time compute and memory models trained with reinforcement learning points toward a future where agents learn from experience rather than just storing it.
The remaining camps include unified knowledge-graph planes like Cognee, stateful substrates built on Redis or Postgres with pgvector, hyperscaler primitives like AWS AgentCore Memory, and newer entrants like Supermemory, MemoryLake, and Memos that each stake out slightly different positions on governance, latency, or developer ergonomics.
The problem is not that too many vendors exist. It is that none of them share a memory-serialization format, a portability protocol, or even a common set of benchmarks they all agree on.
The benchmark wars
Three benchmarks currently define the measurement landscape: LoCoMo, LongMemEval, and BEAM. Each tests different aspects of agent memory – conversational recall, temporal reasoning, and behavioral consistency. But no vendor accepts all three as authoritative, and two of the most prominent vendors, Mem0 and Zep, have publicly disputed each other’s methodology.
MemoryLake claims 94 percent accuracy on LoCoMo. Mem0 claims 92.5 percent on the same benchmark. Zep counters with 94.7 percent. The numbers are not comparable because each vendor tunes its configuration differently, uses different embedding models, and optimizes for different retrieval patterns. There is no single number that tells a builder which memory system will work best for their use case.
This is not a measurement problem. It is a market-structure problem. When buyers cannot compare products on shared metrics, vendor selection becomes a relationship decision rather than a technical one. And relationship decisions create stickiness.
Lock-in is structural, not accidental
The state management layer creates deeper lock-in than any other part of the agent stack because memory is the most persistent component. An agent can switch tools by reconfiguring its MCP connections. It can switch identity providers by updating its PAP configuration. But migrating accumulated memory – the facts learned from thousands of customer interactions, the temporal context that tells an agent what changed and when, the episodic records of past sessions – is orders of magnitude harder.
AWS AgentCore illustrates the dynamic. The platform is genuinely framework-agnostic: it works with LangChain, OpenAI Agents SDK, Claude Agent SDK, and custom frameworks. It is model-agnostic: switch models without rewriting infrastructure. But it has no documented standardized export or migration tools for memory records. The data lives in AWS-managed infrastructure with no equivalent external service to migrate to. This is not an oversight. It is the same pattern that made cloud databases sticky – and agent memory will be stickier because it accumulates continuously.
The hyperscaler-versus-neutral tension runs through the entire landscape. AWS, Azure, and Cloudflare build platform-bound memory that rewards staying in their ecosystem. Zep, Cognee, and Mem0 market themselves as neutral, multi-cloud alternatives. Both strategies are rational. But they produce incompatible memory formats, which means builders who bet on one camp face real switching costs if their needs change.
Cloudflare Artifacts introduces an interesting variable. By building Git-compatible versioned storage specifically for agents – with support for programmatic repository creation, forking, and commit inspection – it offers a potential primitive for the state management layer. If agents can persist their state as Git objects, the portability problem might narrow. But Artifacts is infrastructure, not a memory protocol. It solves the storage question, not the semantics question.
What builders should watch
The state management layer will not consolidate around a single vendor. The architectural approaches are too different, and the use cases are too varied, for one system to serve conversational chatbots, long-running autonomous agents, and enterprise knowledge graphs equally well.
But a protocol could emerge. Portable Agent Memory (PAM), published as a research preprint in May 2026, proposes a five-component memory model – episodic, semantic, procedural, working, and identity – with cryptographically verified serialization and a capability-based access control system. Early pilot results show Transfer Continuity Scores of 0.83 to 0.92 when migrating agent memory across heterogeneous LLM systems, compared to 0.28 to 0.45 baseline. The research is promising but not yet ratified.
The open question is whether the industry can agree on a memory-serialization standard before hyperscaler lock-in hardens. MCP won the tools layer by being open and framework-agnostic. A2A is following the same path. The state layer needs the same treatment – or the agent economy will build its moats on memory that nobody can move.
A note on verification
Vendor claims about benchmark accuracy, GitHub star counts, and pricing are drawn from official vendor websites and product documentation as of October 2026. The Portable Agent Memory research findings are from a preprint and have not been independently replicated at the time of reporting. AWS AgentCore Memory capabilities are verified against the AWS product page and documentation; the absence of documented export tools is noted, not confirmed as a permanent design choice.