One memory for Claude, ChatGPT, Cursor, and Codex

Cross-agent memory is one external store that several authorized AI tools can read and write. A decision saved from Claude can be recalled in ChatGPT, Cursor, or Codex because the memory belongs to the user rather than the interface. MCP provides the common connection; identity and permissions keep the shared context private.

Why built-in memory does not travel#

Each AI product can remember within its own boundary. That improves repeat use, but the learned context usually stays with that product, account, or project.

Switch tools and the familiar reset returns:

• a coding agent does not know the decision made in a research chat;
• a general assistant does not know what changed in the repository;
• a second model asks for preferences already given to the first;
• team context fragments across individual accounts.

Copying a profile between tools moves a snapshot. It does not create a living shared memory.

The shared-memory model#

Claude ─┐
ChatGPT ├── MCP ── one private memory
Cursor ─┤              ├── raw log
Codex ──┘              ├── maintained wiki
                       └── projects and workspaces

Each client connects to the same MCP server and authorizes as the same person. The server enforces access. The agents use a small common surface to remember and recall.

The shared store becomes the continuity layer. Models can change without taking the memory with them.

What should be shared#

Good cross-agent memory favors durable context:

• preferences that should hold across tools;
• project decisions and their rationale;
• recurring constraints;
• people, systems, and relationships;
• lessons from failed approaches;
• open questions that another agent may continue.

It should not save every transient sentence. The goal is continuity, not surveillance or an infinite transcript.

Personal and team boundaries#

One memory does not mean one undifferentiated pool.

OceanDB separates the visibility boundary—a workspace—from the subject boundary—a project. Personal memory defaults to a private workspace of one. Shared workspaces hold context meant for a team. An agent can read across spaces the user belongs to while routing writes deliberately.

That distinction matters. A personal preference can inform your agent without becoming company knowledge. A team decision can remain visible to members without copying itself into private memory.

How it connects#

OceanDB exposes one remote MCP endpoint:

https://app.oceandb.ai/api/mcp

MCP-capable clients connect directly. The browser handles authorization once. There is no API key to paste into a project file.

For Claude Code:

claude mcp add --transport http oceandb https://app.oceandb.ai/api/mcp

ChatGPT and Claude Desktop can add the same endpoint through their connector settings. Cursor and Codex use their MCP configuration. Use the verified guides for Claude Code, Codex, Cursor, and ChatGPT, or see the common endpoint in Connect your agent.

How the memory stays coherent#

Shared write access creates a second problem: more agents can create more noise.

OceanDB keeps capture cheap and maintenance separate. Agents append entries during work. The Dreamer runs later from the user’s own agent. It consolidates entries into cited pages, connects related subjects, and asks for review when a contradiction or merge is ambiguous.

The raw observations remain available. The maintained layer becomes easier to recall. A person can inspect both.

What portability should mean#

Portable memory should survive more than a model change. It should also survive a product decision.

OceanDB exports Markdown and SQL. The export includes the readable memory and the underlying structure. The store is Postgres, and SQL remains available through a de-fanged role. Portability is a property of the system, not a promise that depends on a future migration tool.

The practical result#

Start a decision in Claude. Continue the implementation in Cursor. Ask Codex what constraint was agreed. Use ChatGPT to explain the outcome. The agents can differ in model and interface while the memory remains the same.

The first step is one connection. Point an agent at OceanDB, then give it the standing memory instruction.