Using memory portably, same memory in Claude, Codex and Cursor

The biggest annoyance with AI tools is memory. ChatGPT remembers you, but only in ChatGPT. Claude can have projects, but only in Claude. Codex forgets after every session. Cursor knows your code but not your personal preferences. When you switch between tools, you start from zero every time.

This playbook shows how to solve that in an hour. The result: you write "remember this" once in Claude, and next time Codex knows it too. And Cursor. And every other MCP-capable client.

1. Why external storage is the right approach

Each tool has its own built-in memory. None of them can talk to each other. Not even by design. They're proprietary and controlled by the vendors.

The way out: a storage system that lives independent of the tools and is addressed via a common protocol. The protocol is MCP (Model Context Protocol). Whoever speaks MCP can use all these stores. Claude speaks MCP. Codex speaks MCP. Cursor speaks MCP.

A tip: this isn't tech for the future, this is now. The tools all support MCP stable in April 2026. This is the moment it pays off.

2. Which memory server to take

There are a few. The one I use myself is StudioMeyer Memory (memory.studiomeyer.io), hosted, with 30-second setup via OAuth. Alternatives are self-hosted variants like mcp-nex from the same shop, or other memory servers from the MCP community. For this guide we take the hosted StudioMeyer Memory because it needs the least setup.

A tip: if you're paranoid with data, take self-hosted. For starting, hosted is the faster intro drug. You can export and migrate later anytime.

3. Wire up Claude Desktop

Open Claude Desktop, Settings, Developer, Edit Config. The claude_desktop_config.json opens. If mcpServers is already there, extend; if not, paste in full:

{
  "mcpServers": {
    "studiomeyer-memory": {
      "url": "https://memory.studiomeyer.io/mcp",
      "type": "http"
    }
  }
}

Save, fully quit Claude Desktop, restart. On the first tool call your browser opens, asks for email, sends a magic link. Click the link. Done. Claude now has memory.

A tip: no API key, no bearer token needed. OAuth 2.1 does it automatically. If the browser doesn't open, look in the Claude Desktop log (~/Library/Logs/Claude/mcp-*.log on Mac) for what happened.

4. Wire up Codex

Codex has its own config file at ~/.codex/config.toml. Open, extend:

[mcp_servers.studiomeyer-memory]
url = "https://memory.studiomeyer.io/mcp"
type = "http"

Restart Codex (VS Code Extension or Desktop App). On first tool call, same magic-link flow. Important: use the same email as in Claude. Then Codex accesses the same store. That's the trick.

A tip: if you install Codex Desktop and the VS Code extension in parallel, you can hit a port conflict on OAuth (port 1455). Fix: fully quit VS Code, log in with the Desktop app, then start VS Code again. The extension picks up the login.

5. Wire up Cursor (optional)

Cursor has Settings → Features → Model Context Protocol. Paste the same block as in Claude. Magic-link flow. Done. Now Claude, Codex and Cursor all have the same memory.

A tip: Cursor users spend their day in Cursor. Memory entries created while coding (architecture decisions, bug causes) are often the most valuable. Without memory they're forgotten in 24 hours. With memory they're visible in Claude on the desktop too.

6. First test, save in Claude

Open Claude Desktop, say: "Save in my memory: I'm a freelance marketer, self-employed since 2019, write tersely and without phrases." Claude calls nex_learn, you see the tool-call icon, brief "saved".

A tip: don't say "save everything about me", that becomes a coarse blob. Say specific things that won't change. Role, how you work, what you don't want. Details about ongoing projects can come later, they change anyway.

7. Test, read in Codex

Open Codex, new chat, say: "Search my memory for who I am." Codex calls nex_search, shows you exactly the entry you saved in Claude. That's the proof memory is portable.

A tip: with Codex this is the aha moment. Before, it had zero memory between sessions. Now it knows what you told it yesterday in Claude. That's the step where you understand why external storage matters.

8. What else you can put in

Memory isn't only "who am I". You can store: decisions ("Why did I reject design firm X"), learning progress ("Today I noticed my meta descriptions are too long"), contact notes ("Max Müller from the PR network is loud but competent"), project facts ("The test customer still uses Outlook instead of Gmail"). All searchable.

A tip: be disciplined the first two weeks and consciously save. After two weeks it goes by itself, because you notice you find things you'd otherwise have lost.

9. What memory is NOT

No replacement for project management. No CRM. No Notion. Memory is for knowledge your AI tool needs to help you better. If it should be a to-do list or a calendar, take a to-do app. Memory is the memory of your AI assistant, nothing else.

A tip: don't pump your whole Notion database in. That dilutes the relevance hit rate. Memory is short, precise, and focused on you and your work.

10. Self-built MCP server alongside

If you've already built your own MCP server (see Playbook "Your first MCP server in 90 minutes"), it runs alongside the memory server. Claude and Codex both call their respective tools. Memory for knowledge, your server for your specific actions.

The next step would be to self-host your memory server. That works with mcp-nex on your own machine or a server. Level 6 of the academy goes through that structurally.

A tip: the combination of hosted memory + self-built action servers is in my experience the best setup. Memory you let someone host who knows what they're doing, action servers you build for yourself.

The big picture

What you have now is called "Cross-LLM Memory" in the industry. One source of truth, many clients. You just installed that. Anthropic doesn't do that natively. OpenAI doesn't. No one else. MCP is the protocol that makes it possible, and the memory servers are your choice.

A consequence of this install: from now on you're not bound to a vendor. If OpenAI doubles prices tomorrow, you switch to Claude, and your memory comes along. If Anthropic changes a feature you hate in a year, you switch to Gemini once they speak MCP. Your memory stays.

That's not a tech gimmick. That's a strategic decision.

What's next

Level 4 explains the mechanics behind memory in detail. Level 6 shows how to build and distribute your own MCP servers. And if you want to know how memory concretely helps in everyday use: look at the blog posts under /blog. Real examples from running projects.

For now: all three connected, same store, try it, see what happens.