Best AI Memory for Zed (2026)

The quick answer

If you want persistent memory wired into Zed's AI panel that follows you across projects and tools: Ricord, added as an MCP context server. If you like curating context by hand: Zed's Rulesand saved threads. If you're building agents on top of Zed: Letta. The matrix below spells out the rest.

Why this matters for Zed specifically

Zed is the fastest editor in this comparison and its AI panel is MCP-native, which is exactly why a hosted memory layer fits so cleanly. Out of the box, Zed's memory is two things: Rules files you write to steer the assistant, and saved threads that hold a conversation's history. Both are useful and both have the same ceiling — they're manual or per-project, they don't recall by meaning, there's no graph across them, and nothing you teach Zed is reachable from your other AI tools.

The fixes cluster into six approaches that differ on a handful of axes — install effort, project portability, auto-extraction, semantic recall vs whole-thread reloads, cross-tool reach, conflict resolution, and cost.

The decision matrix

Eight criteria, six options. The two Zed-native approaches (Rules files and saved AI-panel threads) are evaluated separately because they answer different problems.

Slot-by-slot — which fits you

If you run Zed across many projects

Ricordis built for this — add it as a context server once and every AI-panel session reads and writes the same memory, scoped per project automatically. Zed's MCP support registers it at startup; you get a browsable wiki of what the assistant learned across every project, instead of digging through per-project threads.

If you keep tidy Rules per project

Zed's Rulesare the right tool for stable conventions — style, do-not-touch lists, the deploy command. You write them, the assistant follows them, no infra. They don't learn from your work, but for small static contexts that's the point.

If you just reopen the relevant thread

Saved threadscover you when you remember which conversation had the context and you're still in the same project. The moment you're in a new repo, or you can't recall which thread it was, you're re-explaining — that's the signal you've outgrown thread history.

If you're building an agent product on top of Zed

Lettaships an agent runtime with memory built in. If you're already writing orchestration code, the integrated model is cleaner than wiring memory as a separate service. For memory inside Zed itself, it's overkill.

If retrieval quality is your edge and you want OSS

Mem0open-source is the right pick. Apache-licensed, vector-first, forks cleanly. You'll invest real engineering to get it production-ready, worth it if memory retrieval is your product. When OSS wins →

If Zed is one of several AI tools you use

A hosted layer wins here. Ricord keeps one memory every tool reads — what you teach Zed is live in Claude Desktop, Cursor, and Codex too. Rules and threads, by definition, stay inside Zed.

Why Ricord wins for most Zed users

1. One install covers every project. Memory follows you across repos, scoped automatically — no per-project Rules to keep current or threads to hunt through.
2. Semantic recall + a browsable wiki. The assistant pulls just the relevant facts, and you can read what it learned as a document tree and knowledge graph in the dashboard.
3. It reaches your other tools. The same memory is live in Claude Desktop, Cursor, and Codex via the same MCP server. Teach it once in Zed, recall it anywhere.

bun add -g ricord
ricord login
ricord install   # auto-detects Zed, Cursor, Claude Code, Codex

Restart Zed so it registers the context server. Ask the AI panel to remember something in one project; recall it in another, or tomorrow. The wiki populates as you work.

Getting started

Pick the option that matches your slot. If it's Ricord, the three commands above get you running. If it's Rules or saved threads, you're already set up. The signal that you picked right is whether you've stopped re-explaining the same context to Zed after a week.