# 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.