You open Claude Code and explain that the deploy runs through a self-hosted GitHub runner, not Vercel. An hour later you switch to Codex to knock out a migration, and it suggests a Vercel build step. It never knew. Your agents share a repo, a terminal, and a task — and none of them share what the others just learned.

That's the gap four open-source projects are racing to close: shared memory across coding agents. Memmy, Memorix, MemSearch, and memhub all give every tool one searchable memory so a fact learned in one is available in all of them. They're usually pitched on search quality — and on that they're a wash; all four combine keyword and semantic retrieval. The axis that actually decides which one you want is the trust model: does an agent write to shared memory on its own, or does a human approve what becomes durable? That, and how much you're trying to remember — one repo, or you across every tool.

Memorix: the widest net, the least wiring#

Memorix (Apache-2.0) is the drop-in option. It exposes memory as a Model Context Protocol server, and its installer wires 13+ agents — Claude Code, Codex, Copilot, Cursor, Gemini CLI, Windsurf, Kiro, Antigravity, Trae, OpenClaw, OpenCode — through one command each:

npm install -g memorix
memorix init --global                    # optional: writes ~/.memorix/config.toml
memorix setup --agent claude --global    # then: codex, cursor, gemini-cli, …

Under the hood it's SQLite as the canonical store with Orama for full-text search, keyed to your git project. Crucially, retrieval works offline with no API key — keyword matches stay primary, and a semantic fallback kicks in only if you configure an embedding provider (OpenRouter, OpenAI). The MCP server runs over stdio (memorix serve) or HTTP (memorix serve-http --port 3211), and capture happens through per-agent hooks. If your fleet is heterogeneous — Claude Code in the terminal, Cursor in the IDE, Codex for batch — Memorix is the one that reaches all of them with the least glue. We walk through a full Claude Code + Codex + Cursor setup in a companion how-to.

MemSearch: memory you can read in git#

MemSearch (MIT) makes one opinionated bet: Markdown is the source of truth. Conversations auto-capture into daily Markdown files under .memsearch/memory/, and Milvus is "a shadow index — a derived, rebuildable cache" that powers semantic recall. Default embeddings are a local ONNX bge-m3 model — CPU-only, no key, no cost — with Zilliz Cloud or OpenAI as optional upgrades. Retrieval is hybrid: dense vectors plus BM25 with RRF reranking.

Install for Claude Code is a plugin:

/plugin marketplace add zilliztech/memsearch
/plugin install memsearch

Two things make MemSearch distinct. First, it's backed by Zilliz, the company behind Milvus — the most institutional backing in this list. Second, because memory is plain Markdown, you can read it, diff it, and commit it. If you want your agents' memory to show up in a pull request instead of hiding in an opaque database, this is the shape you want.

memhub: never trust a silent write#

memhub (MIT) is the control freak's pick, and that's a compliment. It's a single offline Rust binary with an embedded SQLite database at .memhub/project.sqlite, and it bundles a ~130 MB BGE-small embedding model so semantic search runs fully offline — no server, no daemon, no network calls, ever.

Its defining feature is the write model. Every agent write is attributed by source (agent:claude-code) and stages in a pending_writes table until a human approves it via /wrap-up. Nothing an agent claims becomes durable project knowledge until you say so. The cost is friction: you build from source and the first compile bundles that 130 MB model.

git clone https://github.com/kninetimmy/memhub.git ~/src/memhub
cargo install --path ~/src/memhub --force
cd /path/to/your/project && memhub init

For anyone burned by an agent confidently "remembering" something wrong and propagating it, memhub's human gate is worth the Rust toolchain. Optional cross-machine sync rides on a folder you already sync (Google Drive, rclone); memhub itself never phones home.

Memmy: cross-tool memory of you, not one repo#

Memmy (MIT) is the broadest scope — and the least like the other three. It's a full local agent plus a personal memory hub: a MemOS-powered engine that "collects, understands, and structures your knowledge, preferences, and work experience" and serves it to every tool from a local memory service (http://127.0.0.1:18960). Storage is SQLite plus files under ~/.memmy/workspace; it even exposes an OpenAI-compatible API (memmy serve).

git clone https://github.com/MemTensor/memmy-agent.git && cd memmy-agent
cp .env.example .env
bash scripts/dev-start.sh

The other three remember a project. Memmy remembers you — your preferences and history across Claude Code, Cursor, Codex, OpenClaw, and Hermes, so you stop re-introducing yourself when you switch tools. It runs on trial credits and then bring-your-own-key, and it's local-first with an optional cloud endpoint. If the pain you feel is "every new agent starts by asking who I am and how I like to work," Memmy is aimed squarely at it — at the price of running a heavier local service than a one-file database.

How to choose#

The decision collapses to two questions.

How much control do you want over what's remembered? If the answer is "an agent should never silently write a durable fact," go memhub — the human-approved pending_writes gate is the only one of its kind here. If auto-capture is fine, the other three save you the ceremony.

What are you actually trying to remember?

Whichever you pick, this is the same lesson from the vector-store comparison for agent memory: the interesting differences aren't in the retrieval math, they're in operational shape and trust. And it rhymes with the portability story we told in one SKILL.md across five coding agents — the value isn't in any single tool, it's in the layer that travels between them. Before you commit, it's worth knowing how to read an agent-memory benchmark so a leaderboard number doesn't pick your tool for you.