# Cursor Memory --- --- > What Cursor remembers now that Memories is gone (rules, AGENTS.md, memory banks) and how a team adds shared, searchable memory to Cursor with Glen. --- --- # 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. --- # What happened to Cursor Memories URL: https://cursormemory.com/memories-removed Last updated: 2026-11-07 Published by Glen (https://tryglen.com), shared memory for coding agents. > Cursor removed its Memories feature in version 2.1.x, and Cursor staff confirmed it on the forum on 25 November 2025, advising users to export their memories into rules. The replacements are Project Rules (.cursor/rules/*.mdc), User Rules, Team Rules on Team plans, and AGENTS.md. Rules carry standing instructions; they don't record what past sessions worked out, which is the gap a session memory such as Glen fills. ## The removal Memories was Cursor's feature for keeping facts from one chat available in later ones. In the 2.1.x releases it disappeared. When users asked about it, a Cursor staff member confirmed on the forum on 25 November 2025 that it had been removed and suggested exporting saved memories into rules. Rules have one clear strength over a hidden memory store: they are explicit. You can read every line the agent will see, and a committed rule goes through code review like any other change. ## Where instructions live now *Cursor's instruction layers after Memories* | Option | Location | Scope | Good for | | --- | --- | --- | --- | | Project Rules | `.cursor/rules/*.mdc` | This repo, via git | Build commands, conventions, no-go areas | | User Rules | Your Cursor settings | You, in every project | Personal style and habits | | Team Rules | Your Cursor team | Everyone on a Team plan | Company-wide policy | | AGENTS.md | The repo | Cursor and other agents | Rules shared with Codex, Grok Build and others | ## Sorting old memories into the new homes - A fact about this codebase that every task needs, like the test command, goes into a Project Rule or AGENTS.md. - Your own preferences (terse answers, a favourite library) fit User Rules. - Policy the whole company follows is a Team Rule, if you're on a Team plan. - Anything that was really a story about one past bug or decision doesn't belong in a rule at all. Rules load every time, so history there costs context and goes stale. > **A useful filter:** If the agent should obey it today on an unrelated task, it is a rule. If it only answers a question someone might ask later, it is memory, and rules are the wrong place for it. ## What rules can't replace Rules only hold what a person types into them. The reasoning from a long debugging chat, a teammate's dead end, the trade-off settled in a Slack thread: none of it reaches a rule unless someone stops to write it down. Community [memory banks](https://cursormemory.com/memory-bank) ask the agent to keep notes instead, which helps for one project. [Glen](https://tryglen.com/docs/cursor) takes a different route. Its Cursor plugin records each session into memory your organization shares, and a bundled rule tells the agent to run `glen search` when a task touches earlier work. Recall is on demand because Cursor's hooks can't add context to a turn. For the wider question of how agents keep memory at all, see [long-term memory for AI agents](https://longtermmemoryai.dev). > **Replace the history Memories never kept** Glen records every Cursor session for your team and makes it searchable. Free for 15,000 memories. Install: `npx @tryglen/cli@latest install`. Start free at https://tryglen.com ## Frequently asked questions ### Why did Cursor remove Memories? Cursor removed it in 2.1.x and its staff pointed users to rules as the place for that information. The forum confirmation on 25 November 2025 advised exporting memories into rules. ### How do I export Cursor memories to rules? Copy each memory you still need into the right layer: a Project Rule in .cursor/rules/ for repo facts, User Rules for personal preferences, or AGENTS.md for rules other agents should share. ### Is there a replacement for Cursor Memories? Inside Cursor, rules and AGENTS.md are the replacement for standing instructions. For recall of past sessions, teams add a tool such as Glen, which records sessions and lets the agent search them. ### Do Cursor rules work like memory? Partly. Rules load into context every time, which suits instructions. They don't learn from chats, so anything not written down by hand is lost. --- # The Cursor memory bank pattern, explained fairly URL: https://cursormemory.com/memory-bank Last updated: 2026-11-07 Published by Glen (https://tryglen.com), shared memory for coding agents. > A Cursor memory bank is a community convention, not a Cursor feature: a folder of markdown files that a rule tells the agent to read at the start of a task and update as it works. It gives a project durable, reviewable context that can live in git. Its limits are that it holds only what the agent chose to write, it drifts without upkeep, and it isn't built to gather what every teammate's sessions learned, which is the part Glen records automatically. ## How a memory bank works There is no official memory bank in Cursor. The name covers a family of community setups that share one idea: since the agent forgets between chats, have it keep its own notes in files it can reread. 1. A folder of markdown files holds the project's context, often split by purpose: what the project is, what is in progress, what has been decided. 2. A Project Rule tells the agent to read those files before starting work. 3. The same rule asks it to update them when something changes, such as a task finishing or a decision landing. 4. You commit the folder, so the notes travel with the repo. ## What it does well - Everything is plain text you can read, diff and correct. - It costs nothing and needs no service, account or network call. - For a long solo project, a current "where are we" file saves real time at the start of each chat. - Reviewers see memory changes in pull requests, which keeps bad notes from hiding. ## Where it strains - **It records only what the agent writes.** If the model skips the update step, or summarises a long debugging session in one line, the detail is gone. - **It grows.** Files read on every task cost context on every task, so a bank that keeps everything gets expensive and then gets trimmed. - **It drifts.** A note about a design the team later reversed reads exactly as confidently as a current one. - **It is per repo and per writer.** Two people's agents updating the same files produce merge conflicts, and nothing from a teammate's Codex or Claude Code sessions lands there at all. ## Memory bank compared with Glen *Two ways to give Cursor memory of past work* | | Memory bank | Glen | | --- | --- | --- | | Capture | The agent writes notes when the rule reminds it | Cursor hooks record each session | | Recall | Files loaded each task | On demand, when the agent runs `glen search` | | Reach | One repo, through git | Your organization, across agents, filtered per user | | Old decisions | Stay until someone edits them | Glen aims to follow the one that stuck; `glen forget` removes the rest from recall | | Where it lives | Markdown in your repo | Glen's hosted service | | Cost | Free | Free to 15,000 memories and 3 people | The two can coexist. A short memory bank file describing current work is a reasonable thing to keep loaded, while Glen holds the long tail of history that would bloat it. Be aware that Glen is hosted only, and its recall in Cursor depends on the agent choosing to search. > **Keep the bank small, search the rest** Glen records every Cursor session for your team and the agent searches it when a task needs history. Install: `npx @tryglen/cli@latest install`. Start free at https://tryglen.com ## Memory banks over MCP Some setups swap the markdown folder for an MCP memory server. The reference one, `@modelcontextprotocol/server-memory`, stores a knowledge graph of entities, relations and observations in a local JSONL file set by `MEMORY_FILE_PATH`. It shares the bank's main limits: one machine, and only what the model decides to save. Glen also runs a [remote MCP server](https://memorymcp.dev) any MCP client can search, and the wider design space is covered on [AI agent memory](https://aiagentmemory.app). ## Frequently asked questions ### What is a Cursor memory bank? A community pattern, not a built-in feature: markdown files that a rule tells the agent to read before work and update afterwards, usually committed to the repo. ### Does the Cursor memory bank still work after Memories was removed? Yes. It never depended on Memories; it runs on Project Rules and ordinary files, both of which Cursor still supports. ### Is a memory bank better than Glen? For one person on one project who wants everything local and in git, a memory bank may be enough. Glen fits when several people or agents need to recall each other's sessions without anyone writing notes. ### Can I use an MCP server as Cursor memory? An MCP memory server can fill that role. The reference one keeps a local knowledge graph on one machine, while Glen's remote MCP server at https://mcp.tryglen.com/mcp lets any MCP client search a team's memory. --- # How to add memory to Cursor URL: https://cursormemory.com/setup Last updated: 2026-11-07 Published by Glen (https://tryglen.com), shared memory for coding agents. > Install the glen CLI with npx @tryglen/cli@latest install and sign in, then type /add-plugin in Cursor's agent chat and add https://github.com/Glen-Web-App/glen-cursor-plugin. The plugin's hooks record each session to your organization's memory. Cursor hooks can't add context to a turn, so recall is on demand: a bundled rule tells the agent to run glen search when a task touches past work. 1. **Install the CLI and sign in** You need Node.js. The installer sets up the `glen` command, which the plugin's hooks and rule both call, and opens a browser to sign you in or join your team's organization. ```bash npx @tryglen/cli@latest install ``` 2. **Add the plugin from agent chat** Open Cursor's agent chat, type `/add-plugin`, and give it the plugin's repository URL. ```bash https://github.com/Glen-Web-App/glen-cursor-plugin ``` 3. **Import past sessions** Optional. Backfilling your last 30 days of local sessions means `glen search` has answers on the first day. ```bash glen import ``` 4. **Try a recall** Ask the agent about earlier work, or run a search yourself in the terminal. Expect a written answer with a citation for each claim in about 10 seconds. ```bash glen search "why did we drop the websocket transport" ``` ## The hooks the plugin uses *Cursor hooks registered by Glen's plugin* | Cursor hook | Fires | | --- | --- | | `sessionStart` | When an agent session begins | | `beforeSubmitPrompt` | Before your prompt is sent | | `afterAgentResponse` | After the agent replies | | `afterShellExecution` | After the agent runs a shell command | Glen uses these to record the session. None of them can put text into the turn, which is why Glen in Cursor works differently from Glen in [Claude Code](https://claudecodememory.com), where memories arrive with every prompt. ## Getting the most from on-demand recall - Say it outright when history matters: "check glen for how we handled this last time" makes a search far more likely. - Run `glen search` in your own terminal while planning. Same memory, no agent required. - Once an answer keeps coming up, promote it into a Project Rule so it applies without any search. - Use `glen code-search` with a file path and line range to reach the conversations that wrote those lines. ## Recording controls *Glen's recording modes* | Command | What still happens | | --- | --- | | `glen incognito` | Search works; nothing is recorded to team memory | | `glen silent` | Sessions are recorded; nothing is surfaced | | `glen off` | Neither | > **Add Glen to Cursor** Free for up to 3 people and 15,000 memories. No credit card. Install: `npx @tryglen/cli@latest install`. Start free at https://tryglen.com Glen does not train AI models on customer content. Read [Glen's Cursor docs](https://tryglen.com/docs/cursor) for the details and the [privacy policy](https://tryglen.com/privacy) for how data is handled. ## Frequently asked questions ### Why doesn't Glen inject memory automatically in Cursor? Cursor hooks can't add context to a turn. Glen records through the hooks and relies on a bundled rule that tells the agent to run glen search. ### Does the Cursor plugin need the glen CLI? Yes. The hooks and the bundled rule call the glen command, so install it first with npx @tryglen/cli@latest install. ### Can I use Glen in Cursor through MCP instead? Glen's remote MCP server at https://mcp.tryglen.com/mcp works with any MCP client, but MCP alone gives you search, not automatic recording. The plugin is what records your sessions. ### How long does a glen search take? About 10 seconds. A language model writes the answer, so check the cited sources when it matters.