Cursor memory

Does Cursor have memory?

Not the way it used to. Cursor removed its Memories feature in version 2.1. As of October 2026 it keeps the Rules you write, AGENTS.md and, in the Projects beta, files its agents update as they work. Recallium adds memory your whole team and every coding agent share.

  • What Cursor keeps between chats, checked October 2026
  • Whether Cursor tracks memory across chats, and how to add persistent memory
  • Rules for instructions, Recallium for the record
  • One installer for Cursor and your other agents
How far Cursor’s memory reachesas of October 2026
  1. Every teammate, every agentRecallium
  2. Every teammate in Cursor, through gitProject Rules, AGENTS.md
  3. One Cursor ProjectProjects (beta)
  4. You aloneUser Rules
  5. One chatThe chat history

Team Rules reach every member too, on Cursor’s Team and Enterprise plans, as instructions an admin writes.

What Cursor remembers today

Cursor used to save facts from your chats as Memories. Cursor removed Memories in version 2.1 (November 2025) and suggested exporting them to a rule file. As of October 2026, what Cursor keeps between chats is:

  • Project Rules: .mdc files in .cursor/rules, committed with the repository
  • User Rules: your own global instructions
  • Team Rules: set by an admin from the dashboard and applied for every member, on the Team and Enterprise plans
  • AGENTS.md: plain Markdown instructions at the project root and in subdirectories; Cursor also reads a root CLAUDE.md
  • Projects (beta, September 2026): a set of files that syncs across the machines a Project's agents use, where agents add what they learn about the codebase and how you like work done

Does Cursor track memory across conversations?

Not on its own. As of October 2026, a new Cursor chat starts from your Rules, AGENTS.md and, if you use the Projects beta, that Project’s files. It does not read your earlier chats. The chat history stays in the sidebar for you to open, but the agent is not given it.

So what carries across conversations is only what was written down: a rule you added, a line in AGENTS.md, a file an agent updated in a Project, or an entry saved to a memory server the agent can search. Everything else, including the fix you and the agent worked out an hour ago, has to be explained again.

How to add persistent memory to Cursor

Persistent memory for Cursor comes in over MCP. Cursor reads servers from .cursor/mcp.json in the project, for that repository alone, or from ~/.cursor/mcp.json, for every project. Each entry sits under the mcpServers key: a remote server needs a url, a local one a command and args. Remote servers can sign you in with OAuth.

  1. Add the server: npx -y recallium install writes the entry for you, or paste one into mcp.json by hand
  2. Tell the agent to use it: a User Rule that loads the project’s memory at the start of each chat and saves decisions as they land (the Recallium rule)
  3. Work: the tools are available to Agent, including Plan Mode, cloud agents and the CLI, so the memory follows the repository rather than one window

Any MCP memory server connects this way. What differs is what each one stores and who can read it; Comparisons sets them side by side.

The Cursor Memories feature, and what replaced it

Cursor Memories saved facts from your chats automatically. Cursor removed the feature in version 2.1, in November 2025, and gave users an “Export memories” command that writes what existed into an .mdc rule file you can keep in .cursor/rules. Those rules still load today; they just stopped growing on their own.

The nearest successor is Projects, in beta since September 10, 2026: each Project keeps a set of files that sync across the cloud and local machines its agents use, and the agents add notes on the codebase and on how you like work done. Cursor’s changelog does not say whether teammates see those files, so treat a Project as your memory, synced, rather than the team’s.

Where Cursor's memory stops

  • Rules are written by hand. A rule holds what someone decided to write down, not the decision your agent reached at four o'clock yesterday, or why.
  • Rules are loaded whole. They apply always, by file pattern or when the agent judges them relevant, so they have to stay short: Cursor's guidance is to keep each rule under 500 lines.
  • Rules reach Agent only. Cursor's docs say rules do not affect Tab or its other AI features.
  • All of it stays in Cursor. Rules and Projects context do not reach a teammate working in Claude Code or Codex on the same repository.

Rules are still the right place for standing instructions. Most teams use both.

What Recallium adds to Cursor

  • Memory captured as you work: designs, decisions, root causes and fixes, each linked to the files it is about
  • What the team settled, before the edit: Recallium finds the decisions and fixes about the code being changed and feeds them to the agent
  • Shared with your team: on Cloud Pro, every teammate's agent reads and writes the repository's memory
  • Shared with your other agents: the same memory in Claude Code, Codex, GitHub Copilot and any MCP client
  • Handoffs: workstreams and session recap let the next session pick up where the last one stopped

Add Recallium to Cursor

  1. Run the installer: npx -y recallium install finds Cursor and your other agents, signs you in once and adds the MCP connection
  2. Add the User Rule: paste the Recallium rule into Cursor under Customize → Rules, so the agent loads project memory before its first answer (get the rule)
  3. Open a repository and work: Recallium names the project after the repository and loads its context at the start of each session

Join the waitlist for Recallium Cloud.

Questions

Does Cursor have memory?

Not the Memories feature it once had: Cursor removed it in version 2.1. As of October 2026 Cursor keeps Rules (project, user and team) and AGENTS.md, and its Projects beta keeps files that agents update as they work. An MCP memory server such as Recallium adds memory that persists across sessions, teammates and other coding agents.

Does Cursor remember previous chats?

Not on its own. A new chat starts from your Rules and AGENTS.md, plus the Project's files if you use the Projects beta. What you worked out in an earlier chat comes back only if it was written into one of those, or saved to a memory server the agent can read.

What happened to Cursor Memories?

Cursor removed the Memories feature in version 2.1. Its “Export memories” command writes existing memories to an .mdc rule you can keep in .cursor/rules.

Can my team share Cursor memory?

Team Rules share instructions on Cursor's Team and Enterprise plans. Recallium Cloud Pro shares the memory itself: what each teammate's agent learns in a repository is available to everyone on it, in Cursor and in other agents.

One memory under every agent your team runs.

Recallium gives Cursor the decisions and fixes your team already worked out, and keeps them in step with your other agents. Join the waitlist for Recallium Cloud, the managed engineering memory for your team.