UMP Protocol Released: Equip AI Agents' Memory with a Universal Plug

A USB-C Protocol for the AI Agent Era

A few days ago, an open-source project called Universal Memory Protocol (UMP for short) quietly went live, with a one-sentence goal:
Enable all AI Agents to share the same memory format.

This might not sound exciting, but any developer present would immediately see its significance—this is aimed at tackling the hardest problem in the Agent ecosystem. Over the past year, Agent products have exploded, but each company’s memory system is an isolated island: ChatGPT’s Memory is locked inside OpenAI’s backend, Claude’s Projects context is in Anthropic’s private format, Cursor remembers your coding style, Notion AI remembers your writing preferences—but none of these data connect. Switching tools means dealing with a new amnesiac re-learning everything about you.

UMP’s mission is clear—define a cross-vendor, cross-Agent standard memory schema so that the memories you accumulate in Tool A can be instantly migrated to Tool B.

What exactly does it define

After reviewing the documentation, UMP’s design is more restrained than expected. It doesn’t invent a brand-new memory storage engine; rather, it focuses purely on the data exchange format—similar to the thinking behind MCP (Model Context Protocol): protocol first, with individual implementations handled separately.

The core definitions have three tiers:

• Atomic Memory: The smallest unit of memory, similar to a structured factual statement. For example: “User prefers TypeScript over JavaScript” or “User’s time zone is UTC+8”. Each memory includes a timestamp, confidence level, source Agent ID, and expiration policy.
• Episodic Memory: A summary of a complete interaction, retaining the timeline and causal relationships. Example: “On June 2, the user debugged a React hydration error, ultimately resolving it via suppressHydrationWarning.”
• Semantic Memory: Stable preferences and knowledge graph nodes abstracted from numerous atomic memories—like a user profile, but structured and interpretable.

This layered model may seem familiar—those who know a bit of cognitive science will recognize it as directly borrowing from Tulving’s classic human memory classification. But more interesting is its handling of memory ownership.

UMP stipulates that all memory data belongs to the user, stored wherever the user specifies (locally, self-hosted S3, or any compatible object storage). Agents may only read the data upon receiving explicit authorization. The permission model is somewhat like OAuth: when the user logs into a new Agent, the Agent requests scopes for certain memories (e.g., “programming preferences”, “calendar preferences”), and can only read them once granted.

This is UMP’s biggest product bet—it’s gambling that both developers and users have had enough of being locked into a specific Agent vendor’s data silo.

An example of the standard format

The protocol itself is defined using JSON Schema. A single atomic memory entry might look like this:

{
  "id": "mem_01HXYZ...",
  "type": "atomic",
  "subject": "user",
  "predicate": "prefers_language",
  "object": "TypeScript",
  "context": {
    "domain": "programming",
    "tags": ["frontend", "language_preference"]
  },
  "provenance": {
    "source_agent": "cursor-ide",
    "created_at": "2026-06-04T10:23:11Z",
    "confidence": 0.92
  },
  "access": {
    "scope": "programming.preferences",
    "ttl": null
  }
}

Using an SPO (Subject-Predicate-Object) triplet to convey facts is a standard approach in knowledge graphs—its advantage is being inherently queryable and suitable for reasoning, while its disadvantage is limited expressiveness. UMP uses a context field to patch the triplet, allowing unstructured metadata to be attached. This compromise is pragmatic—preserving structured query capabilities without rigidly constraining the Agent during schema-compliant writes.

Why now

If this had happened two years ago, nobody would have cared. But the context in 2026 is completely different.

First, Agents have evolved from “single-interaction tools” into “persistent digital assistants.” GPT, Claude, Gemini—all are building long-term memory capabilities, joined closely by domestic vendors—for instance, in April, Tencent Cloud released its “Lobster” TencentDB Agent Memory, turning memory into a database plugin and claiming to raise accuracy on the PersonaMem benchmark from 48% to 76%. Everyone’s competing on memory, but the competition is in performance, not interoperability.

Second, MCP’s success in 2025 proved something—the AI ecosystem does need a protocol layer, and developers are willing to adopt it. When Anthropic launched MCP, few believed in it; yet within a year, nearly all mainstream Agent frameworks had adopted it. UMP is clearly copying this path: publish the specification first, let early adopters enjoy the benefits, and once the ecosystem grows, it becomes a de facto standard.

Third, regulation is changing. The EU AI Act already requires high-risk AI systems to provide data portability, and memory data will inevitably be classified as personal data. UMP’s “user-owned, Agent-borrowed” model sits comfortably in this compliance sweet spot.

Compared to existing solutions—UMP’s strengths and weaknesses

To be fair, a lot of people are already working on memory—UMP is not the first.

LangMem, Mem0, and Zep all offer Agent memory features, but they are implementations rather than protocols—if you use Mem0, your memory is locked in Mem0 storage; if you use Zep, you are tied to Zep’s API. Switching frameworks means losing history.

Tencent Cloud’s Agent Memory takes this even further, making it a database service—strong performance and good enterprise support, but maximum lock-in; once outside Tencent Cloud’s ecosystem, it’s unusable.

UMP takes a harder but higher-ceiling approach: no storage, no retrieval, no embeddings—just define what the data should look like. In theory, Mem0 could internally change its storage format to UMP, and Zep could add UMP import/export—no conflict.

But the “protocol-only” route has clear weaknesses:

• Adoption threshold depends on early champions: If giants like OpenAI and Anthropic don’t adopt, the protocol will only circulate in the open-source community.
• Non-unified retrieval semantics: The protocol defines how memory is stored, but not how Agents query, rank, or decide to forget. Two Agents both supporting UMP could behave completely differently.
• Privacy boundaries are blurry: If the user grants the “programming preference” scope, how does the Agent decide whether a newly written memory should be tagged with that scope? The protocol leaves this to implementations—a potential risk.

How should developers view it

If you’re building an Agent, at this stage UMP is worth reading the documentation, running the examples, but holding off on integration. The reason: it’s still at v0.1, and the schema will likely change—betting on it now carries nontrivial costs.

However, a few signals are worth monitoring:

1. Whether top-tier Agents adopt it: If within six months, tools like Cursor, Cline, Claude Code—frequently used by developers—begin supporting it, UMP has a real shot.
2. Whether compliance adapters appear: For example, can ChatGPT’s Memory be exported and converted into UMP format? This is the user’s most pressing pain point.
3. Whether a retrieval-layer standard emerges: Data format alone is not enough; query semantics need to follow. The documentation mentions an RFC draft, but it hasn’t landed yet.

For application-layer developers, a more practical suggestion is:
Design your internal memory structures using UMP’s schema in your own Agent. Even if the protocol itself doesn’t take off, this structured methodology is still beneficial—at least during debugging, you can clearly see what the Agent remembers and why it made mistakes.

As a side note, domestic developers wanting to test the performance differences between GPT, Claude, and Gemini in memory tasks can now use OpenAI Hub to call all these mainstream models with a single key—saving the hassle of registering multiple accounts and setting up proxies.

Whether the protocol succeeds depends on the ecosystem

UMP’s situation is a lot like MCP’s in early 2024—a good protocol design, open-source, restrained, hitting a real pain point—but whether it takes off depends entirely on ecosystem momentum.

Optimistically, Agent interoperability is already an unavoidable issue, and sooner or later a protocol will solve it; UMP has the advantage of an early start and clean design. Pessimistically, big players have incentives to push their own closed memory formats—after all, user memory data is their moat; opening it up would be strategic self-sabotage.

The ultimate outcome will likely hinge on a simple question:
Do users really care about being able to take their memory with them?
If they do, UMP has a chance; if most users don’t bother switching tools, then the protocol will remain just a protocol.

The developer community has already started discussing it—on GitHub’s Issues page, proposals appeared on day one to add vector embedding fields, memory conflict resolution strategies, cross-language bindings, and more. Judging by the discussion volume, at least this group cares deeply.

References

• Hacker News - Universal Memory Protocol discussion thread (reddit mirror) - Early developer community reactions and technical detail discussions about UMP
• LangMem and Agent Memory framework comparison (Zhihu column) - Domestic developers’ perspective on horizontal comparisons of Agent memory solutions
• MCP and next-generation Agent protocol layer overview (Juejin) - Analysis of why the protocol layer became key AI infrastructure in 2025–2026