Claude Code memory vs Codex, Cursor and Copilot memory

What is Claude Code auto memory?

Claude Code has two memory systems. CLAUDE.md files are instructions you write. Auto memory is notes Claude writes itself while it works. The Claude Code memory docs list four kinds of note: user (your role and preferences), feedback (corrections you gave), project (decisions and deadlines the code does not show) and reference (where to look outside the repo).

It lives at ~/.claude/projects/<project>/memory/. The project path comes from the git repository, so every worktree of one repo shares one folder. The docs are plain about the boundary: “Auto memory is machine-local.” Files are not shared across machines or cloud environments.

At the start of every session Claude Code loads the first 200 lines or 25KB of the MEMORY.md index, whichever comes first. Memory files do not expire; they stay until you or Claude edits or deletes them. You review them by opening /memory, which also toggles the feature. It is on by default in local sessions. Where the folder is, how to move it and why it can seem not to work are in Claude Code auto memory.

One newer variant: Claude Code Projects, in public beta on Pro and Max, keeps a separate project memory that every cloud thread in that project reads. It is still one person's project, and the docs say it is not yet available on Team or Enterprise plans.

Where does Codex store memories?

Codex memories are local. The Codex memories docs say they live under your Codex home, ~/.codex/memories/, and include summaries, durable entries, recent inputs and supporting evidence from prior chats. Codex writes them in the background once a chat has been idle for a while, skips short sessions, and redacts secrets from generated fields.

Local Codex memories are off by default. You turn them on with memories = true under [features] in config.toml, or in the ChatGPT desktop app under Settings, Personalization. The docs treat the files as generated state and advise against hand editing them as your main control. Control is per chat with /memories. A memory unused for 30 days drops out of consolidation (max_unused_days in the config reference). /import can copy a Claude Code project's memories into Codex once; nothing flows back. Every setting is in Codex memories.

OpenAI's own advice is the useful line here: keep required team guidance in AGENTS.md or checked in documentation, and treat memories as a recall layer, not the only source for rules that must always apply.

Does Copilot Memory work across a team?

Partly. It is the only one of the four with a shared layer. GitHub's Copilot Memory docs describe two kinds of memory. Repository facts are available to every user with Copilot Memory access to that repository. User preferences stay with one user, across repositories.

Repository facts carry citations to the code that supports them and are checked against the current branch before use. A memory expires 90 days after Copilot created or last upvoted it, and owners can set repository facts anywhere from 7 to 180 days. Repository owners can review and delete repository facts. The Copilot app, CLI, cloud agent, code review, Agentic Autofix, and Copilot in Mobile, Slack and Teams all use it. Repository facts are allowed on every paid plan unless a setting restricts them; user preferences are on by default for Pro, Pro+ and Max and off on Business and Enterprise until an owner enables them.

So Copilot Memory is shared, but per repository and only inside Copilot. A fact a Copilot agent learned about your payments service does not reach Claude Code or Codex. The CLI and the Copilot app can ask you to approve a memory; the cloud agent and code review store without asking. The VS Code memory files on your disk are a different feature: GitHub Copilot Memory keeps the two apart.

What happened to Cursor memories?

Cursor shipped Memories in 2025 and removed them. A Cursor staff reply on the forum (25 November 2025) says “The Memories feature was intentionally removed starting from version 2.1.x” and tells users to export them and paste them into rules.

What Cursor has today is rules: project rules in .cursor/rules, user rules that apply to all your projects, AGENTS.md, and Team Rules that admins manage from a dashboard on Team and Enterprise plans. Team Rules are the closest thing to team memory in any of these tools. They are written by an admin by hand, not learned.

Cursor Projects, in beta since 10 September 2026, add shared context: files that sync across every machine a project's agents use, where agents add what they learn about the codebase. Like Claude Code Projects, the unit is a project, and the agents write to it directly. Projects are on Premium and higher, Teams and Enterprise plans.

The other learned memory left in Cursor is in Automations: since 5 March 2026 each automation keeps a MEMORIES.md it reads and writes across its own runs, on by default. Neither reaches the agent in your editor. The export steps and what replaced Memories are in does Cursor have memory?

Claude Code memory vs Codex, Cursor and Copilot

Read the last two rows together. Each tool's memory is either yours alone or scoped to one repository inside one vendor. The one shared layer that crosses tools today is a file in git: CLAUDE.md, AGENTS.md, .cursor/rules. Our note on whether to commit CLAUDE.md covers what that file should hold.

Is agent memory the same as team knowledge?

No. Agent memory answers “what did this agent learn while working with me?” Team knowledge answers “what did we decide?” They are different objects with different rules.

Take one decision from #eng-payments: payment webhook handlers dedupe on the provider's event id before any write. It was argued in Slack and settled in a PR review thread. For it to reach every agent, four things have to be true that no personal memory provides:

• It came from where the team decides. Slack threads, PR reviews, ADRs. Not from whichever agent happened to be in the room.
• It passed a gate the team set before any agent acted on it, so one wrong session does not quietly teach every agent a mistake.
• It reaches every tool, not only the one where it was first said. The engineer on Cursor needs it as much as the one on Claude Code.
• It retires when it stops being true. When the handler is rewritten, the fact about it should leave with it.

Personal memory is good at what it is for. Your preferred test runner, the flag you always forget. Keep it on. It is just not where a team's decisions should live. What Claude Code itself shares across a team is in Claude Code team memory, and what Anthropic's Slack agent keeps is in Claude Tag.

Where Harbor fits

Harbor is the team layer none of these ship: shared memory for AI coding agents. It learns from where your team decides (Slack, pull request reviews, docs and agent sessions), lets you set what waits for a person, and gives Claude Code, Cursor, Codex and GitHub Copilot the rules that apply to each task, so the webhook decision reaches all four from one record.

Start with the quickstart. For the memory servers people bolt on instead, see MCP memory servers for teams, and for the file based approach, sharing memory between Claude Code, Cursor and Codex.