# Cursor memory: what Cursor remembers between chats, and how to add more

URL: https://cursormemory.com/
Last updated: 2026-11-07
Published by Glen (https://tryglen.com), shared memory for coding agents.

> Cursor memory today is whatever you write into rules: the built-in Memories feature was removed in Cursor 2.1.x, and Cursor staff advised users to export their memories into rules. What remains is Project Rules in .cursor/rules/*.mdc, User Rules, Team Rules on Team plans, and AGENTS.md, all text that people write and maintain. For memory of past sessions shared across a team, Glen's Cursor plugin records each session, and the agent recalls it on demand by running glen search.

## Cursor memory today: Memories is gone, rules remain

Cursor 2.1.x dropped the Memories feature. A Cursor staff member confirmed the change on the forum on 25 November 2025 and pointed users toward exporting what they had into rules. So today, everything Cursor knows about your project at the start of a chat is something a person wrote into one of four places. The full story is on [what happened to Cursor Memories](https://cursormemory.com/memories-removed).

*What Cursor loads in place of Memories, November 2026*

| Layer | Where it lives | Who it reaches |
| --- | --- | --- |
| Project Rules | `.cursor/rules/*.mdc`, committed with the repo | Everyone who clones the repo |
| User Rules | Your own Cursor settings | Only you |
| Team Rules | Your Cursor team (Team plans) | Members of that team |
| AGENTS.md | The repo | Cursor and any other agent that reads it |

## Where Cursor memory stops

- Rules hold instructions, not history. The reason a colleague's agent abandoned the websocket approach last week is in their chat, not in any `.mdc` file.
- Nothing gets written unless someone sits down to write it. Busy teams rarely do.
- A teammate on [Codex](https://codexmemory.com) or Claude Code learns things your Cursor never hears about.
- Community memory banks fill part of the gap by having the agent keep notes in markdown. The [memory bank page](https://cursormemory.com/memory-bank) covers what that pattern does well and where it strains.

## Adding team memory to Cursor with Glen

[Glen](https://tryglen.com) is hosted memory for your organization, and its Cursor plugin records your sessions through four Cursor hooks: `sessionStart`, `beforeSubmitPrompt`, `afterAgentResponse` and `afterShellExecution`. Those sessions land in the same store as your teammates' sessions from Cursor, Codex, Claude Code and other agents, next to public Slack channels, GitHub and call transcripts. Each memory is checked at recall against what the asking user is allowed to see.

> **Recall is on demand in Cursor:** Cursor hooks cannot add context to a turn, so Glen can't slip memories in ahead of your prompt the way it does in Claude Code or Codex. Instead, a rule bundled with the plugin tells the agent to run `glen search` when a task touches past work. A search returns a written answer with a citation per claim and takes about 10 seconds.

> **Give Cursor your team's memory** Install the CLI, add the plugin from agent chat, and you're recording. Free for up to 3 people and 15,000 memories. Install: `npx @tryglen/cli@latest install`. Start free at https://tryglen.com

## The benchmark, and why it may differ in Cursor

Glen replayed the last 100 merged PRs of a workspace with two months of Glen history, using Codex 5.5 and five runs per PR in each arm, with memory rolled back to before each PR. With Glen the runs used 29% fewer tokens and finished 21% faster, at equal or better quality. In that test recall landed before the first turn. Cursor recalls only when the agent decides to search, so your results may differ. [Read the method](https://tryglen.com/blog/replaying-100-prs).

## Which Cursor memory option to use

*Where Cursor knowledge belongs*

| You want Cursor to | Use |
| --- | --- |
| Apply the lint and test commands on every task | A Project Rule or AGENTS.md |
| Follow your own style preferences in every repo | User Rules |
| Hold the whole company to a security rule | Team Rules |
| Find out why a teammate's agent dropped the websocket design | Glen, via `glen search` |
| Trace a block of code back to the chat that wrote it | `glen code-search` |

Glen is the wrong tool for anything that must happen every time, because it depends on the agent searching; put that in a rule. It is also hosted only, and recorded sessions are searchable across your organization. For a solo developer who already keeps tidy rules, the extra layer may not pay off. When it does, [the setup guide](https://cursormemory.com/setup) gets you running from one command.

## Frequently asked questions

### What is Cursor memory?

Cursor memory is the context Cursor's agent carries from one chat to the next. Since the Memories feature was removed in 2.1.x, that means Project Rules, User Rules, Team Rules and AGENTS.md, plus whatever a plugin such as Glen records and lets the agent search.

### Does Cursor still have Memories?

No. Memories was removed in Cursor 2.1.x. Cursor staff recommended exporting existing memories into rules.

### What replaced Cursor Memories?

Rules: Project Rules in .cursor/rules/*.mdc, User Rules, and Team Rules on Team plans, plus AGENTS.md. All of them are written by people rather than learned by the agent.

### Does Cursor remember previous chats?

Not on its own. A new chat sees your rules and AGENTS.md. With Glen installed, earlier sessions are recorded and the agent can search them with glen search.

### Can Cursor share memory across a team?

Committed Project Rules and Team Rules share instructions. To share what each person's sessions worked out, every teammate installs Glen into the same organization.