Your CLAUDE.md is not your agent's memory

Thomas Jumper — Tue, 14 Jul 2026 14:30:00 +0000

I like CLAUDE.md. I also think people are asking it to do a job it cannot do.

CLAUDE.md, AGENTS.md, and .cursor/rules are where you put the rules you want an agent to follow: how to run tests, which folders are sensitive, what style the team uses, and when to ask before deploying. That is written context. It belongs in git.

But a coding agent also learns things while it works.

It discovers that a particular test is flaky under one flag. It learns why an apparently odd abstraction exists. It finds the deployment step that is not in the runbook yet. Those are not stable enough to hard-code into an instruction file, and they are too useful to lose when the session ends.

That is the distinction I use:

Instructions are what your team writes down before the work.
Memory is what your connected agents learn during the work.

The practical move is not to replace instruction files. Keep them. Add a small memory protocol beside them:

How to give Claude Code, Cursor, and Codex shared memory over MCP

Thomas Jumper — Tue, 31 Mar 2026 12:44:08 +0000

I use more than one coding agent in a normal week: Claude Code for most work, Cursor when I'm living in the editor, Codex CLI for scripted runs. They're all good. They also share nothing.

A lesson learned in one session ("staging DB resets Sunday nights", "that test is flaky, ignore it", "we chose pgvector on purpose, stop suggesting alternatives") is gone in the next session, and was never visible to the other tools at all.

The built-in memory options don't cross that gap, and their docs say so: Claude Code's auto memory is per-repository and machine-local; Codex's memories are stored locally and off by default; Cursor's documented persistence layer is Rules, which are files you write yourself.

Instruction files like CLAUDE.md, AGENTS.md, and .cursor/rules are genuinely useful for the context you write. Keep them. What they don't hold is the context your agents learn while working.

The fix is a shared memory layer over MCP: one server that any MCP client can connect to, so a memory stored by one connected agent can be recalled by another.

Here's the full setup with StremAI. Full disclosure: I'm the founder. There are also open-source options like OpenMemory, agentmemory, Memorix, and others if you'd rather self-host, and the verification steps below work with any shared-memory MCP server.

1. Claude Code

claude mcp add --transport http stremai https://stremai.com/api/mcp --scope user

Run it, then approve the browser sign-in. No API key to paste. --scope user makes the connection available in every project, not just the current directory.

2. Cursor

Add one server entry to ~/.cursor/mcp.json for global use, or .cursor/mcp.json for one project:

{
  "mcpServers": {
    "stremai": {
      "url": "https://stremai.com/api/mcp"
    }
  }
}

Cursor should prompt a browser sign-in. Honest note: OAuth verification for Cursor is still in progress on our side. If the prompt doesn't appear in your build, use an API key fallback:

{
  "mcpServers": {
    "stremai": {
      "url": "https://stremai.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ab_live_YOUR_KEY"
      }
    }
  }
}

Existing "agentbay" entries keep working; use "stremai" for new installs so docs and troubleshooting match.

3. Codex CLI

curl -sSL https://stremai.com/install-codex.sh | bash

Or manually in ~/.codex/config.toml:

[mcp_servers.stremai]
url = "https://stremai.com/api/mcp"

4. Verify it actually works

Most setup guides skip the proof step. Don't.

In any connected agent:

store a test memory titled "setup check" with content "shared memory is wired up"

Then open a different tool, or a fresh session, and ask:

recall the test memory called "setup check"

If the second agent returns it without you repeating anything, you have working shared memory. That's the whole product in one round trip: what one connected agent learns, another connected agent can recall.

5. Make it useful

First, tell your agents when to use memory. Put a few lines in your existing CLAUDE.md or AGENTS.md:

- Before answering questions about this codebase, recall relevant project memory.
- After completing a real change, store durable lessons: decisions, pitfalls, gotchas.
- Don't store secrets or raw code; those belong in git.

Second, seed it. Store the five things you're most tired of re-explaining: deploy quirks, flaky tests, architecture decisions, setup gotchas, or the rule everyone keeps rediscovering.

Recall quality is ranked, so the relevant entry surfaces when it matters instead of everything flooding the context window.

What to expect

Memory is user-controlled. Entries are human-readable, attributed to the agent that stored them, and you can export, archive, or erase them from the dashboard.

On teams, one engineer's agent's lesson can be recalled by teammates' connected agents, which is the part that changes onboarding. The point is not that agents magically know everything. The point is that useful working context stops dying inside one tool's session.

StremAI is free to start with no credit card. It is verified with Claude Code and Claude Desktop today, with Cursor, Codex, Windsurf, and OpenClaw supported or in active verification.

Docs: stremai.com/docs/mcp-memory

Try a real recall without an account: stremai.com/playground

Questions or a setup that didn't work? Comment. I read all of them, and broken-setup reports are worth more to me than praise.

DEV Community: Thomas Jumper