Fourteen vendors. Zero shared protocols. That is the state of the agent stack's fourth layer, and it is the only number in this market that still matters.
Tools standardized first. MCP won that layer. Agent-to-agent communication is nearly settled โ A2A is closing. Identity and permissions have a map: PAP. But state management โ where an agent's memory, context, and session persistence actually live โ is still a land grab. No serialization format. No portability guarantee. No agreed benchmark.
I have audited enough infrastructure to recognize the pattern. This is not a gap in the market. It is a moat in formation, and the builders walking into it are the liquidity.
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. State management sitting at the apex. Each of the first three layers has at least one emerging standard. State management has none.
The reason is structural. MCP standardizes transport โ how an agent calls a tool. A2A standardizes communication โ how agents coordinate. PAP standardizes authorization โ who gets to do what. None of them define how an agent remembers what it did yesterday, how it builds context from a customer conversation, or how it persists a session across a restart. That is the state layer.
And it is where the lock-in will concentrate. I have watched this movie before. In DeFi, the bridge was the choke point โ and the bridge was where the money died. Here, the choke point is memory. Liquidity is just trust, quantified in gas, and memory is trust, quantified in accumulated context.
The state layer currently hosts at least fourteen vendors across roughly seven architectural camps.
Mem0 leads the extract-and-retrieve approach: vector-first, two-phase memory that pulls facts from conversations and retrieves them by semantic and keyword search. Around 59,900 GitHub stars. Y Combinator backing. It has become the default for chatbots and B2B copilots that need conversational recall.
Zep takes a different path โ temporal knowledge graphs. Its Graphiti engine models facts with both valid time and transaction time: when something was true, and when it was recorded. That distinction matters for enterprise agents tracking how a customer situation changes over time.
Letta, grown out of the MemGPT research at UC Berkeley, lets agents edit their own memory blocks through tool calls. An operating system approach โ the agent decides what to remember and what to forget. Its work on sleep-time compute and RL-trained memory models points toward agents that learn from experience rather than merely store it.
The remaining camps: unified knowledge-graph planes like Cognee; stateful substrates on Redis or Postgres with pgvector; hyperscaler primitives like AWS AgentCore Memory; and newer entrants like Supermemory, MemoryLake, and Memos, each staking out slightly different ground on governance, latency, or developer ergonomics.
The problem is not that too many vendors exist. The problem is that none of them share a memory-serialization format, a portability protocol, or even a common set of benchmarks they all accept.
Three benchmarks define the measurement landscape: LoCoMo, LongMemEval, and BEAM. Each tests a different aspect โ conversational recall, temporal reasoning, behavioral consistency. No vendor accepts all three as authoritative. And two of the most prominent, Mem0 and Zep, have publicly disputed each other's methodology.
MemoryLake claims 94 percent on LoCoMo. Mem0 claims 92.5 percent on the same benchmark. Zep counters with 94.7 percent. The numbers are not comparable. 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.
That 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. Relationship decisions create stickiness. Stickiness is the product.
Here is where the forensics get interesting. The state layer creates deeper lock-in than any other part of the 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 interactions, the temporal context, the episodic records of past sessions โ is orders of magnitude harder.
AWS AgentCore illustrates the dynamic perfectly. The platform is genuinely framework-agnostic: LangChain, OpenAI Agents SDK, Claude Agent SDK, custom frameworks. 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.
That is not an oversight. It is the same pattern that made cloud databases sticky โ and agent memory will be stickier, because it accumulates continuously. Every session adds weight. Every migration gets more expensive. The exit cost compounds.
The hyperscaler-versus-neutral tension runs through the entire landscape. AWS, Azure, and Cloudflare build platform-bound memory that rewards staying inside the 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 a variable worth tracking. By building Git-compatible versioned storage specifically for agents โ programmatic repository creation, forking, commit inspection โ it offers a potential primitive for the state layer. If agents can persist state as Git objects, the portability problem narrows. But Artifacts is infrastructure, not a memory protocol. It solves the storage question, not the semantics question. Ledgers bleed, but code remembers the truth โ and right now, the truth has no common language.
Everyone is waiting for the state layer to consolidate around a single winner. That is the wrong bet.
The architectural approaches are too different and the use cases too varied for one system to serve conversational chatbots, long-running autonomous agents, and enterprise knowledge graphs equally well. Consolidation is not coming. What could come is a protocol.
Portable Agent Memory, 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 capability-based access control. Early pilot results show Transfer Continuity Scores of 0.83 to 0.92 when migrating memory across heterogeneous LLM systems, against a 0.28 to 0.45 baseline.
Read that again. The baseline is a coin flip. Two-thirds of an agent's memory context is lost in a naive migration.
The contrarian blind spot is this: builders treat memory as a feature to be bought, not a liability to be measured. They evaluate on benchmark scores they cannot compare, then discover the switching cost after they have accumulated two years of context. Yields vanish when the herd arrives at the gate โ and the herd is arriving at the memory layer right now, wallets open, due diligence skipped.
The neutral vendors are not saviors. They are building their own moats, just with better marketing. Neutrality is a positioning claim, not a serialization format.
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.
If it does not get it, the agent economy will build its moats on memory that nobody can move. And the builders who learn that lesson will learn it the expensive way โ the same way every bridge operator learned it. Security is a myth until the bridge breaks. Memory is that bridge now.
Watch the serialization standards, not the star counts. That is where this fight gets decided.
