E J Ziyad launches UML, a shared memory graph for Claude and ChatGPT

Why it matters

UML tests whether MCP can support a user-owned memory layer independent of any model provider, giving small builders a place between dominant AI clients and their users.

E J Ziyad launched UML, or Universal Memory Layer, on July 31 as a shared memory system for Claude, ChatGPT, coding agents, and custom apps. The pitch is straightforward: tell one AI something once, then let every connected tool retrieve the same durable context.

Public materials connect Ziyad to UML through the project's support address and the 12ziyad GitHub account, which maintains its open-source engine. That account shows a builder who has been working through the same memory problem across several projects. Its public repositories include agent infrastructure, a text-to-Cypher system, and GPMai, a multi-model workspace with a server-side memory graph.

GPMai treated memory as one component inside a broad AI workspace. UML extracts that architecture into a focused product that can sit between users and several AI clients. The split gives Ziyad a clearer distribution bet: instead of persuading people to adopt another assistant, UML can connect to the assistants and editors they already use.

Turning conversations into a graph

UML does not present chat transcripts to each connected model. According to the Apache 2.0 repository, UML processes conversations and other inputs into nodes, events, relationships, pages, and receipts. A node might represent a person, project, skill, preference, or life event. Updates can supersede earlier facts while retaining the old information on a timeline.

Ziyad's design separates language-model extraction from the stored record. An LLM proposes a memory, while UML's backend decides what gets written. The repository describes a Cloudflare-native architecture built with Workers, D1, Vectorize, Workers AI, and a Durable Object assigned to each user. Recall combines structured graph data with semantic search when Vectorize is enabled.

The visible graph is central to the product. Users are meant to inspect clusters, search saved information, and review receipts showing what a write created, updated, or refused. That interface addresses a persistent problem with personal AI memory: users often cannot see the profile an assistant has assembled or trace an incorrect response back to a specific saved fact.

UML also says memories can come from documents, tool outputs, meeting notes, support tickets, app events, and workflow state. That makes the graph potentially useful as operational context for agents, rather than a profile limited to personal preferences collected in chat.

MCP gives UML its opening and its main constraint

UML reaches AI clients through the Model Context Protocol, or MCP. A user creates a private connector URL and adds it to a supported client. Claude Code receives three tools: save_memory, save_conversation, and recall_memory. Custom apps can use HTTP endpoints for saving, recalling, inspecting the graph, applying collection rules, and exporting data.

The architecture lets Ziyad offer one memory store without controlling the interface where users work. It also means UML cannot guarantee that every client will use the memory correctly. UML's own documentation states that an MCP host decides when to call its tools. Developers who require capture and retrieval on every turn must integrate UML's API or SDK into their agent runtime.

That limitation matters because a shared database does not produce shared behavior by itself. One assistant may call the recall tool at the start of a task, while another may ignore it unless the user asks directly. UML can standardize access to context, but the host retains control over when that context enters the model's prompt.

Ziyad is entering an active market. Mem0 markets production memory infrastructure for agents and says more than 100,000 developers use its technology. Zep simplified its enterprise Memory MCP Server to three tools in June, including graph search and memory writes. Letta Code carries agent memory and identity between model providers, while Supermemory has expanded from a personal knowledge product into memory and context infrastructure.

In a same-day launch post, UML's builder contrasted the project with app-specific memory layers such as Mem0 and Zep. He framed UML around a different unit of ownership: one person's editable memory shared across the AI products that person chooses.

That distinction is Ziyad's wedge. UML is designed around the user's graph, rather than an application developer's customer record or a single agent's internal state. If users regularly move between Claude, ChatGPT, Cursor, and custom tools, the independent memory layer becomes a form of portability.

The trust layer remains unfinished

UML says it does not sell user data, run ads, track users, or train models on their memories. Ziyad's repository says browser sessions and per-tool connection tokens are stored as hashes, with tokens displayed once when created. The terms warn users to protect private connector links and avoid sensitive or regulated information when UML is unsuitable for it.

The codebase also shows how early the release remains. Its roadmap lists key rotation, memory editing, deletion and merging, password resets, account deletion, improved relationship discovery, export and import, and richer review workflows as future work. Some of those items overlap with controls already emphasized on UML's landing page, including editing, exporting, and deleting memory. The difference between the marketed experience and the repository roadmap is the clearest reason to treat UML as an early-access system.

UML is currently free. Ziyad says founding users will retain access to a future Pro tier without charge after paid plans arrive. The immediate objective appears to be usage and product feedback around the graph, connector setup, and memory rules.

Ziyad's bet rests on a simple product boundary: models can change, clients can multiply, and the user's durable context should remain portable. MCP has made that boundary technically plausible. UML now has to prove that people will entrust an independent service with the facts they want every AI to remember, and that its graph can keep those facts accurate as users and agents continuously revise them.