Cursor memory: rules, memory banks and the supermemory plugin

Cursor doesn't remember your earlier chats on its own. It loads the instructions you write down, in rules and AGENTS.md files, at the start of each chat, and everything else stays in the chat it came from. To give Cursor memory of past work, install the supermemory plugin with /add-plugin cursor-supermemory: it saves each chat as you work and brings the relevant parts back in the next one.

Below is what Cursor keeps on its own, how the memory bank pattern fills part of the gap, and how to set up the plugin in Cursor and in Grok Bot. Everything is checked against Cursor's docs and ours as of October 21, 2026.

Does Cursor have memory?

Not of your past chats. Cursor's rules documentation says it directly: large language models don't retain memory between completions, and rules are how Cursor gives the model persistent context. What carries over from one chat to the next is whatever someone wrote into one of these:

What Cursor keeps	Where it lives	When it loads
Project rules	.mdc files in .cursor/rules, committed with the repo	Always, when a matching file is in context, when the agent decides it's relevant, or when you @-mention it
User rules	Customize → Rules	Every Agent chat, in every project
Team rules	The Cursor dashboard, on Team and Enterprise plans	Every Agent chat for the team
AGENTS.md	The repo root and any subfolder	When the agent works in that folder

When rules disagree, team rules win over project rules, and project rules win over user rules.

Cursor did ship a memory feature once. Cursor 1.0 added Memories as a beta in June 2025, saving facts from conversations per project (changelog). As of October 21, 2026, the old Memories docs page redirects to the Rules page, and Cursor's docs index has no Memories page. So anything Cursor should know next week either goes into a rule or into a memory layer that saves it for you.

How to give Cursor long-term memory

The supermemory plugin hooks into Cursor itself, so memory is saved and recalled without you or the model asking for it. Install it from inside Cursor (docs):

1. Make sure Node.js is on your PATH. The plugin's hooks run with Node, and installing Cursor doesn't add it.
2. In Cursor, run /add-plugin cursor-supermemory. Or open Customize, find Supermemory, select Install, and pick project or user scope. Both install the plugin from the Cursor Marketplace.
3. Restart Cursor, or run Developer: Reload Window.
4. Open a new chat and run /supermemory-setup. A browser window opens, and once you sign in to supermemory you're done.
5. Run /supermemory-status any time to check the connection.

If you'd rather use an API key, create one on the API keys page in the console, set it as SUPERMEMORY_API_KEY in your shell profile, and restart Cursor. The plugin is free on every supermemory plan, including Free.

Muskan Jain from our team introduced the Cursor and Grok Bot plugins in a short video on September 9, 2026:

Once it's installed, the plugin works at fixed points in every chat (docs):

When	What the plugin does
A chat starts	Loads your profile: lasting facts about you and the project
You send a substantive prompt	Searches memory with it, drops duplicates, and adds the matches after the first tool result Cursor supports
The agent finishes a turn	Saves the completed turn, and retries anything unsaved when the session ends
You ask for it	Skills and MCP tools for saving and searching on purpose

It also adds an always-on rule that nudges the agent to recall relevant history on its own, and a context-gatherer agent that runs several targeted searches before a big task. On day one, ask the agent to "learn this codebase and remember it": the plugin's memory-init skill explores the repo and saves its architecture and patterns (docs).

One thing to skip: the cursor-supermemory package on npm. The plugin's README describes it as a different, older product with its own local MCP server, so install from inside Cursor instead.

The same plugin in Grok Bot

Grok Bot runs the same plugin, added from xAI's side instead of Cursor's (docs):

1. Open the Supermemory for Grok Bot plugin page and select Add to Grok Bot.
2. Restart Grok Bot so the plugin loads.
3. Ask Grok Bot "Sign me in to Supermemory" and follow the connect card it shows. Ask "Is Supermemory connected?" to check later.

There are no slash commands in Grok Bot. It picks the plugin's skills from what you ask:

Skill	Ask for it like this
memory-init	"Learn this codebase and remember it"
memory-save	"Remember that we use Vitest for unit tests"
memory-search	"What do you remember about our database schema?"

Grok Bot has some memory of its own. A Bot can keep stable preferences, important facts and summaries of its work, and Bots with separate roles and conversations pass context through messages, group chats and shared files (xAI docs). Anything you connect in Grok Bot, this plugin included, is available to every Bot on the account (Grok Bot help), so with supermemory, Bots working on the same repo read and write the same memory, and a later Bot can pick up what an earlier one figured out. Asking "Disconnect Supermemory" removes the stored credentials, and your memories stay in your account.

Cursor rules vs memory banks

Rules and memory banks solve related problems, and they work best together.

Rules are instructions. You write them once, commit them with the repo, and Cursor loads them by type: always, for matching files, when relevant, or on @-mention. They're the right home for conventions and standards that rarely change.

A memory bank is a record of the project that changes as you work: what you're building, what's done, what you decided and why. It's a convention, not a Cursor feature, and Cursor doesn't read a memory-bank/ folder unless a rule tells the agent to.

	Cursor rules	Memory bank
What it holds	Instructions for how the agent should work	Notes on the state of the project
How often it changes	Rarely, when standards change	Often, after each session or milestone
Who writes it	You or your team	The agent when asked, with your review
How Cursor reads it	Built in, by rule type	Only when a rule or your prompt points the agent at it
Good for	Conventions, standards, architecture guidelines	Current task, progress, recent decisions

To use a memory bank in Cursor, put its instructions in a project rule that always applies, such as .cursor/rules/memory-bank.mdc with alwaysApply: true in the frontmatter. Cursor ignores plain .md files in .cursor/rules, so the extension matters (rules docs).

Treat what the agent writes into the bank the way you'd treat a pull request, and review it before it becomes the record. A stale summary that sounds confident will mislead the next session more than an empty file. Keep credentials and keys out of the bank from the start.

How a Cline memory bank carries context across sessions

The pattern comes from Cline. Cline's docs describe its Memory Bank as a documentation method: you paste a set of custom instructions into a Cline Rules file such as .clinerules/memory-bank.md, and those instructions tell Cline to read every memory bank file at the start of every task. You ask Cline to "initialize memory bank" to create the files and "update memory bank" to refresh them. The structure has six core files:

File	What it holds
projectbrief.md	Core requirements and goals
productContext.md	Why the project exists and the problems it solves
activeContext.md	Current focus, recent changes and next steps
systemPatterns.md	Architecture and design patterns
techContext.md	Tech stack, setup and constraints
progress.md	What works, what's left and known issues

That's the whole mechanism: the files stay in the repo, and the instructions make Cline reread them. It works as long as someone keeps the files current and the agent follows the instruction. Anything the files don't say, like the fix you found last Tuesday, is gone once the session ends. Cline can also connect to remote MCP servers (MCP docs), so you can add the supermemory MCP server below there as well, as a Streamable HTTP server ("type": "streamableHttp" in Cline's config).

One memory across Cursor, Claude Code, Codex, OpenCode and Muse Code

The Cursor plugin files memories by repository rather than by tool. The container name comes from the repo's normalized Git remote, and the Claude Code, Codex, OpenCode and Muse Code plugins use the same one (docs):

repo_<project_name>__<project_id>

So a decision you save while working in Cursor is there when you open the same repo in Claude Code, as long as both are signed in to the same supermemory organization. A few details:

• Different repos don't collide. The project ID is a hash of the remote, so two repos with the same folder name stay apart. A repo with no remote falls back to its local path.
• Older memories still count. The plugin keeps reading the cursor_user_* and cursor_project_* containers from older versions, and writes only to the shared one.
• You can pin it. Set repoContainerTag in .cursor/.supermemory/config.json only if you need an explicit shared container.

The coding agents page has the setup for each agent, the MCP page covers chat apps, and the quickstart covers agents you build yourself.

How MCP connects external memory to Cursor

If you don't want hooks running in Cursor, connect the supermemory MCP server instead. MCP is an open standard for connecting AI apps to outside tools and data, and Cursor supports MCP servers natively (Cursor MCP docs). Add this to ~/.cursor/mcp.json (setup):

{
  "mcpServers": {
    "supermemory": {
      "url": "https://mcp.supermemory.ai/mcp"
    }
  }
}

Cursor opens a browser window to sign in with OAuth, so there's no key to paste. The server gives the agent these tools (MCP docs):

Tool	What it does
search_memory	Searches one space for memories that match a question
get_profile	Returns stable and recent profile facts for a space
add_memory	Saves something to memory
forget_memory	Forgets something that's outdated
list_documents	Lists stored documents with their summaries
get_document	Reads one stored document
list_memories	Lists recent memories and the documents they came from
list_spaces	Lists the spaces you can access
who_am_i	Shows the signed-in account, its access and the active space

The trade-off is that with MCP alone, Cursor only saves or searches when the model decides to call a tool, so say it plainly when something matters ("save this to supermemory"). Saves made through MCP alone also go to your active space, not the repo container the plugin uses. The plugin already proxies this same server for deliberate lookups, so you don't need both. More on the server is on the MCP page, and the MCP guide covers connecting Claude and ChatGPT to the same memory.

Test it in two chats

Use a fact Cursor couldn't guess, so a right answer can only come from memory:

1. In a repo with the plugin installed, tell Cursor something specific and made up: "our release codename is Juniper."
2. Let the turn finish and close the chat. Wait a little before the next step, since memories form in the background.
3. Open a new chat in the same repo and ask "what's our release codename?"
4. Open the same repo in Claude Code with the supermemory plugin and ask again. It reads the same memory.
5. Ask from a different repo. The codename shouldn't come up there.

If a step fails, run /supermemory-status first. It checks your credentials and whether supermemory is reachable.

Common questions

Does Cursor remember previous chats?

No. Each chat starts from your rules, your AGENTS.md files and whatever you add to it. Facts from an earlier chat only come back if someone wrote them into a rule or a memory layer saved them.

Is a memory bank still useful with the plugin?

Yes, for project notes you want reviewed and versioned with the code. The plugin covers what happens in chats that nobody writes down.

Can I keep the memory on my own machine?

Yes. The plugin works with self-hosted supermemory: run npx supermemory local, set SUPERMEMORY_API_URL to http://localhost:6767, and use the API key printed on first boot (docs).

What does it cost?

The plugin is free on every supermemory plan, including Free, which comes with $5 of credits a month. What it saves and searches draws on those credits (billing docs). Every coding agent plugin has been free since August 15, 2026, and the pricing page has the rates.