Guides / Persistent memory in Cursor.

1658 words | Esment

Persistent memory in Cursor.

Cursor's Memories panel is gone. What Rules, AGENTS.md, conversation search and MCP memory servers each keep between chats, and how to choose.

╌╌╌╌

Cursor does not give you a memory you can see and manage across chats any more. The Memories settings panel went away in the 2.1 releases, and Cursor staff pointed users to Rules instead. For persistent memory in Cursor today you have four practical options: Rules, an AGENTS.md file, the agent's search over past conversations, and an MCP memory server.

Rules and AGENTS.md are the right answer for most people: free, reviewable and loaded without the agent having to decide. An MCP server earns its place when you want memory that grows as you work, or that follows you to other tools. The catch is that the agent decides when to use it, so it needs a rule telling it when.

What happened to Cursor Memories

Memories arrived as a beta in Cursor 1.0 in June 2025, stored per project, and became generally available in Cursor 1.2 a month later.

In November 2025 users started reporting that the panel had disappeared. A Cursor staff member replied on the forum that the feature was "intentionally removed starting from version 2.1.x" and suggested exporting memories into Rules.

The picture then gets less tidy. In January 2026 the same staff member wrote that only the management UI had been removed and that the feature itself still worked. In another thread, a user reported that the agent could list memories but not change them.

So the UI is gone, staff statements differ on what remains behind it, and the current Rules documentation does not mention Memories. We found no changelog entry announcing the change and no newer official statement. It is not something to build on.

What each option keeps between chats

OptionBest forReaches the agentMain limit
Project RulesConventions for one repoAutomatically, if set to always applyYou write and maintain them
User RulesPersonal preferences in every projectAutomaticallyStays in your Cursor settings
AGENTS.mdSimple instructions other tools can read tooAutomaticallyPlain file, no conditions
Conversation searchFinding something you discussed beforeWhen the agent searchesOnly your Cursor chats
MCP memory serverFacts that grow over time, across toolsWhen the agent calls itNeeds setup and a nudge
Rules load into every chat; the chat itself does not carry over; search and a memory server reach back only when the agent uses themCHAT 1CHAT 2CHAT 3RULES,AGENTS.MDLOADED INTO EVERY CHAT, AUTOMATICALLYTHE CHATITSELFCHATSEARCHIF THE AGENT SEARCHESMEMORYSERVERSAVERECALLWHEN THE AGENT CALLS IT · OTHER TOOLS CAN USE IT TOO

Rules: the default answer

Cursor's docs put the problem plainly: language models don't keep memory between completions, and rules provide persistent context at the prompt level. Project rules live in .cursor/rules and go into version control. User Rules apply across all your projects.

A project rule can apply always, when the agent judges it relevant, when matching files are in context, or only when you mention it. Use "always" sparingly, because that text sits in every session. Cursor suggests keeping rules under 500 lines and adding one only when the agent repeats a mistake.

Rules suit stable knowledge: how to run tests, which library to prefer, what not to touch. They suit changing knowledge less well. A decision from Tuesday only reaches a rule if someone writes it down.

AGENTS.md: the same idea, more portable

Cursor describes AGENTS.md as a simple markdown file for agent instructions, an alternative to .cursor/rules for straightforward cases. There is no frontmatter, so you lose the conditional behaviour of rules.

What you gain is reach. AGENTS.md is an open format that many other agents read, including Codex and Windsurf. If your team uses several tools, this is the simplest thing that works.

Conversation search: useful, but not a memory

Cursor's agent can query your past conversations when it needs something you discussed before. It costs nothing to try: ask it to look. It finds what was said, not what is currently true, so an answer you later reversed can come back looking valid.

MCP memory servers

An MCP server gives the agent tools to save and search a store that lives outside the chat. In Cursor it goes in .cursor/mcp.json for one project or ~/.cursor/mcp.json for all of them. The options differ mainly in where memory lives and who keeps it tidy:

  • The reference Knowledge Graph server stores entities and observations in a local JSONL file. It is a good way to learn how this works.
  • Basic Memory keeps notes as Markdown files on your disk that you can edit and version with Git. If you want to read and own every note as a file, it is a better fit than Esment.
  • Memory apps and hosted services, Esment among them, handle storage and search for you, with less hands-on control.

Why an MCP memory can stay silent

Connecting a server does not mean it gets used. Cursor uses MCP tools when it judges them relevant, so a connected memory can sit idle through a whole session. By default Cursor also asks you to approve each MCP tool call, so review your run mode and allow the search tool if you are comfortable with that.

A short always-on rule helps. It does not guarantee a search, but it turns an open choice into a standing instruction. Be specific about triggers, and name your server's real tools.

.cursor/rules/memory.mdc
---
description: "When to read and write long-term memory"
alwaysApply: true
---
Before planning a change or answering a question about past work,
search memory for this project and topic.

After a decision, a dead end or a stated preference, save one short
fact, including why. Do not save secrets or routine progress.

If a memory conflicts with the code, trust the code and say so.

Fix two: hooks, with a caveat

Cursor hooks run your own script at set points, so recall need not depend on the model. On paper, a sessionStart hook can return additional_context for the start of the conversation. The beforeSubmitPrompt hook cannot add context; it can only allow or block.

In practice, test this on your version. In April 2026 Cursor staff confirmed a bug where that context was dropped because of a timing issue, and a June reply pointed to improvements in a later release. Related threads were still active in October, and we could not confirm a final fix. Keep the rule above even if you add a hook.

Which should you pick?

  • One repo, one tool, stable conventions: Rules or AGENTS.md. You may not need anything else.
  • Shared team conventions: AGENTS.md or project rules, reviewed in pull requests like code.
  • Decisions and dead ends you keep re-explaining: an MCP memory server plus the rule above.
  • Several tools and one body of context: a memory that sits outside any single editor.

These combine well: what must always be true goes in a reviewed file, and what you learn along the way goes in memory.

Memory that survives switching editors

Cursor's own features stay in Cursor, which matters if you also use Claude Code, Windsurf or ChatGPT, or change editors next year. AGENTS.md carries instructions, not what you learned last week in another tool.

We make Esment, so weigh this section with that in mind. Esment is a memory layer, not an assistant: one shared memory that Claude, ChatGPT, Cursor and others connect to over MCP. A connected assistant saves details it notices, or you ask it to remember something. Esment does not watch your screen or apps.

On a Mac, open Assistants in the app, click the Cursor card, click Configure, then quit Cursor with ⌘Q and reopen it. Cursor receives Esment's instructions automatically, so you skip writing the rule above. Where supported, Configure also installs the Agent Plugin, whose hooks load a session brief before the model answers. The hook caveat above still applies, so confirm it in a new chat with a question only your memory can answer.

The Mac app comes with paid plans. Any editor that supports MCP over HTTP can also connect with this snippet, using your memory endpoint and a key from Personal API key in the web dashboard:

mcp.json
{
  "mcpServers": {
    "esment": {
      "url": "<your memory address>/mcp",
      "headers": { "Authorization": "Bearer <access key>" }
    }
  }
}

Each memory shows which assistant saved it, and changes are recorded in History, which helps when a fact goes stale. In the Mac app, memories are stored on your Mac and never reach Esment's servers while sync is off, though anything an assistant reads is processed by that assistant's vendor. The privacy guide lists what can leave your Mac.

If you only ever work in Cursor and your context fits in a few files, you do not need Esment or any other memory tool.

Save your first memory →

Common questions

In:

Can I still export my old Cursor Memories?

Out:

In November 2025 Cursor staff pointed to an "Export memories" command in the Command Palette, which saves an .mdc file you can add to your Rules. At least one user on 2.1.34 reported that the command was missing, and we have not confirmed it on current versions. Staff also mentioned rolling back to 2.0.77 as a temporary route, which may no longer work.

In:

Are Cursor Rules the same as Memories?

Out:

No. Memories came from your conversations. Rules are instructions you write, so they are more predictable but do not grow on their own.

In:

How do I know Cursor is actually using my memory server?

Out:

Save a fact that exists nowhere in your code, start a new chat and ask about it without naming the tool. Then look for a memory tool call in the agent's steps. If the agent answers without calling it, tighten your rule or check that the server is enabled in Cursor.

In:

Is it safe to commit mcp.json to my repo?

Out:

Only if it contains no keys. Keep anything with an access key in ~/.cursor/mcp.json in your home directory instead.

Written by the team that builds Esment, so we are not a neutral party. Tools change quickly: check each one before you rely on it.

Get the next chapter by email.

One email per new chapter. Nothing else.

0.00