Shared project memory tools for Claude Code, Codex and Cursor

Eight ways to share project memory

These tools document paths for Claude Code, Codex and Cursor. Their storage, setup and automation differ. “MCP support” means the host can call tools; it does not mean each host captures context automatically.

Documented capabilities and practical tradeoffs, reviewed 24 September 2026
Tool and fit	Integration and setup	Storage and team portability	What to check
Klypix Project decisions, explicit corrections, evidence and human inspection.	`npx klypix-mcp install` in each project on each machine. Claude Code has MCP and lifecycle hooks; Codex has MCP with optional native hooks; Cursor uses MCP and project rules.	A `brain.klypix` project file. Share through Git; install the merge driver in each clone. The Apache-2.0 engine works without the optional Windows workspace.	Capture only covers recorded knowledge. Git sharing is not live sync. Default session presence is machine-local and OS-user-local; file warnings are advisory.
Basic Memory Editable Markdown notes and a shared knowledge graph.	Local setup uses `uv`/`uvx`; Cloud supplies a hosted MCP endpoint. Documents Claude Code, Codex and Cursor, plus lifecycle hooks for Claude Code and Codex.	Free local Markdown files can travel in Git. Paid Cloud adds shared team workspaces. Edit notes directly or with incremental editing tools.	Review note quality and how the team marks superseded decisions. Harness capture records event metadata; it does not automatically turn whole transcripts into notes.
Supermemory Automatic capture and recall across coding tools.	Plugins for Claude Code, Codex and Cursor; configure authentication. Project memory is shared across tools, separately from personal memories.	Hosted free and paid tiers. A free local engine is also documented, with local embeddings and a configured extraction model. Its graph links revised facts to earlier versions.	Inspect capture scope, model processing and current limits. Local mode requires operating the service and extraction model; hosted connectors and the standalone MCP service are excluded from that offering.
Mem0 Memory infrastructure, APIs and coding-agent plugins.	Current Claude Code, Codex and Cursor plugins use a Platform key and Python. Claude Code and Codex recall on the first qualifying prompt; Cursor recall is tool-driven.	Hosted Platform has free and paid tiers; OSS SDKs support self-hosting. Both support explicit updates and history; Platform adds structured export and background consolidation.	Plugins capture session activity for extraction; MCP-only setup supplies tools without lifecycle capture. Self-hosting requires storage and model setup. Verify team scope and provider processing.
Knowit Typed project knowledge reviewed as text in Git.	`npx knowit install`; Node 20+. MCP setup for Claude Code, Codex and Cursor. Task-context retrieval and session-learning capture tools.	Project knowledge in `.knowit/knowledge.jsonl`; Git can carry that text between teammates. Optional global or custom SQLite stores.	Check which store your team uses. Semantic embeddings require an optional OpenAI key; text and tag search work without it.
Klio Memory served through a shared service.	`npx @klio-tech/klio init`. The README documents adapters for Claude Code, Codex and Cursor, with Claude Code hooks and MCP tools.	Local deployment uses Docker, PostgreSQL/pgvector and Redis. A cloud mode is also documented; check its current setup separately.	For local mode, budget for the service stack and backups. Cloud setup offers an optional model API proxy; review its routing and capture behavior before enabling it.
agent-parity Consistent memory, instructions and skills across coding tools.	Repository installer with platform-specific setup. Documents Claude Code, Codex, Cursor and Antigravity CLI integrations.	Shared project files in Git; includes a merge driver for memory changes. Managed project settings align the supported agents.	Its scope includes the agent environment as well as memory. Review the managed files and host prerequisites; Cursor requires MCP approval.
shared-agent-memory A shared knowledge graph with optional edit coordination.	Install from GitHub with `npx github:dan-calin/shared-agent-memory install`, then initialize the project for the selected agents.	Wraps the reference MCP memory server. Defaults to a user-level JSON store; project initialization creates `.shared-memory/` and host instructions.	Choose project-local storage deliberately. File claims are advisory by default; its optional Claude pre-edit hook can warn or block. Agents still need to call the memory tools.

Which should a small team choose?

Our recommendation: trial Klypix if your main need is to carry changing decisions, their evidence and explicit corrections between tools while keeping a project file that people can inspect. Keep stable conventions in AGENTS.md and code in Git.

If ordinary Markdown is your priority, start with Basic Memory. If automatic capture is central, evaluate Supermemory and the current Mem0 plugins against each host’s documented behavior. Choose Mem0 OSS when you want to build and operate a memory layer yourself.

If readable JSONL diffs are your priority, evaluate Knowit. If you want a memory service, evaluate Klio’s local and cloud modes. If you also want to standardize skills and instructions, evaluate agent-parity. For a small shared graph with optional file claims, evaluate shared-agent-memory.

About OpenMemory: the current Mem0 OpenMemory repository describes a beta tool for transferring coding-session history between Claude Code, Codex and OpenCode. It does not list Cursor in that support table. Evaluate current Mem0 plugins separately rather than assuming older OpenMemory MCP instructions describe today’s product.

A short rules file and decision records may already be enough for a project with few changing decisions. Add another tool only when your trial shows it retrieves useful context you would otherwise repeat or miss.

How Klypix fits this workflow

Klypix is a portable project workspace with a shared brain. The open-source klypix-mcp engine gives supported coding hosts access to captured decisions, questions and evidence. The optional Windows app lets people inspect and edit that understanding beside project files.

For projects with more than code, the Windows workspace also keeps files, folders, links, notes, images and PDFs together. The iPhone app sends selected material into that workspace through the cloud. Embedded files can travel inside the .klypix archive; linked files still need their originals. This broader workspace is separate from the engine-only setup compared above.

Start a task with brain_sync, retrieve a decision with brain_ask, and record a durable finding with brain_note. An explicit correction can supersede an earlier decision while preserving its history. brain_challenge can surface prior constraints, but an empty result does not prove a proposal is correct.

Keep reviewable decisions in Git. An architecture decision record can stay the approved source for a decision. Link it as evidence in the brain so a later agent can retrieve the rationale and check the underlying document. Klypix does not approve a decision merely because it was captured.

Portability has a tradeoff. The brain is a documented ZIP-based project file, not a folder of Markdown notes. The free engine reads it without the Windows app. The desktop workspace can export Markdown and JSON Canvas; those exports are not lossless round-trips. If editing plain-text memory files directly is a requirement, include that in your trial.

For teammates on different computers, commit and pull the brain through Git. Install the merge driver in each clone; without it, concurrent brain edits can produce a binary conflict. The default live presence lane only sees participating sessions for the same OS user on one machine.

Follow the team setup guide for Git sharing and the integration table for host-specific behavior. A local brain file does not make a connected cloud AI provider local: that provider can receive context supplied to its agent.

Run the same handoff trial

To try Klypix in a disposable project, follow the first-decision and correction walkthrough.

Use a disposable project and the same task for each tool you evaluate. Record the tool version, host version and actual returned answer.

Capture a decision. In the first host, record: “For this trial, use SQLite because the demo must run offline.” Link a short decision record as evidence.
Switch hosts. Start a fresh session in the same project using another coding tool. Ask which database was selected and why, without repeating the answer.
Correct it explicitly. Record: “CORRECTION: use PostgreSQL because the demo now requires concurrent writers.” Ask again in another fresh session. Inspect both the current answer and the retained history.
Move to a teammate’s clone. Follow the tool’s documented sharing procedure. Repeat the question there; a second local session does not prove cross-computer sharing.
Review the costs. Check setup effort, reviewable changes, incorrect or missing retrievals, and what context reaches an external provider.

Reproduce a Klypix handoff: our decision-and-correction smoke test passed 11 assertions across four fresh MCP processes using an initially empty brain. It checks captured rationale, an explicit correction, retained history and a brain-only local copy. The returned context and script are public. This is a small lexical fixture, not host UI testing, teammate synchronization or evidence of superiority.

Coordination checks: a separate published conformance run passed its 15 checks using klypix-mcp 1.86.2. It covers isolated MCP clients and protocol fixtures. It is not the multi-host trial above, an independent review, or a comparative performance result.

Sources and review method

We checked each project’s official documentation for integration paths, installation, storage, corrections and stated limits. Pricing links describe available models; no fixed price or unlimited free tier is assumed. Features can change; use the linked documentation before installing. We do not infer an absent feature merely because a page does not mention it.

Reviewed 24 September 2026. This page includes no paid placements, review scores or invented customer results. The Klypix conformance output is linked with its command and scope so readers can reproduce that check.