Start free

Updated

The best memory for Cursor in 2026

The best memory for Cursor is Glen if your team works in Cursor together, and Project Rules plus claude-mem if you work alone and want your sessions captured on your own machine. Cursor removed its Memories feature in the 2.1 releases, so the only memory built into Cursor now is rules someone writes and keeps current by hand, and the best memory for Cursor has to come from a plugin or MCP server that records what the agent actually did.

One limit applies to every option below: Cursor's beforeSubmitPrompt hook can't add context to a prompt. A plugin can record each turn automatically, but recall happens when the agent runs a search, prompted by a rule, a skill or you, instead of arriving with each message. That holds for Glen and for every third-party tool on this page, so the useful comparison is what gets recorded and what a search can reach. We compared six options on exactly that.

Short answer

A team sharing what their Cursor agents work out
Glen
Conventions every session must follow
Cursor Project Rules (Team Rules on Team plans)
Solo, free, sessions captured locally
claude-mem
Notes someone approves before they're saved
ByteRover
One memory API for Cursor and your own app
Supermemory or Mem0

Cursor memory tools at a glance

#ToolConnects viaCapturesTeam sharingPrice
01GlenOur pickPlugin (hooks) plus a CLIEvery turn, automatically; recall on demandWhole orgOrg-wide, filtered per user at recallFree for 15,000 memories, no card
02Cursor rules (Memories was removed)cursor.comBuilt inNone; rules are written by handShared spacesProject Rules through git; Team Rules from the dashboardIncluded with Cursor; Team Rules need a Teams plan
03claude-memcmem.aiPlugin (hooks)Tool use and session end, automaticallyOne personLocal per project; team sharing is a pilotFree locally; CMEM Pro $30/mo
04Supermemorysupermemory.aiPlugin or remote MCPAutomatic with the plugin; tool calls over MCPShared spacesPer repo by default; orgs with scoped keysFree with $5 credit; Pro $19/mo
05Mem0mem0.aiPlugin or remote MCPPlugin, or tool calls over MCPShared spacesPer user, agent or app entityFree tier; paid is usage-based or custom
06ByteRoverbyterover.devSkill installed by the desktop appAgent-driven, with a review stepShared spacesPrivate, team and shared spacesFree tier; Pro from 15/mo billed yearly

How we ranked them

  • Fills the gap Memories left. Rules hold what you type into .mdc files. We looked at whether each option learns from sessions without someone writing it down, which is what Cursor Memories used to do.
  • Records without being asked. Cursor hooks can see each prompt, each agent response and each shell command. Tools that use them capture every turn; tools that rely on a save tool get what the agent remembers to save.
  • What triggers recall. Since Cursor hooks can't inject context per prompt, recall depends on the agent searching. A tool that ships a rule or skill telling it when to search gets used; one that doesn't waits for you to ask.
  • Reaches past one seat. Team Rules reach everyone on a Team plan but only hold what an admin writes. Can a teammate's agent, in Cursor or another tool, read what your session found?
  • Setup and price. How it installs into Cursor, and the first paid tier, from each vendor's pricing page as of November 2026.

The 6 best memory tools for Cursor

  1. Glen

    Our pick

    Best for: Teams where several people, and several agents, work in the same codebase.

    Glen homepage at tryglen.com
    tryglen.com
    Connects to Cursor
    Plugin (hooks) plus a CLI
    Captures
    Every turn, automatically; recall on demand
    Shared with your team
    Org-wide, filtered per user at recall

    Glen's Cursor plugin records through four hooks. sessionStart shows your org and recording status, beforeSubmitPrompt records the prompt, afterAgentResponse records the finished turn, and afterShellExecution links each commit to the session that made it. Because Cursor hooks can't add context to a turn, recall is on demand: the plugin's bundled rule and skill tell the agent when to run glen search, and you can ask it to search at any point.

    What that search reaches is the reason to install it. It queries one org memory that also holds your teammates' Claude Code and Codex sessions, public Slack channels, GitHub, tickets, docs and call transcripts from Fireflies, Fathom and Granola. Results are filtered per observation, so each person's agent sees only what that person is cleared to see, and decisions the team has since reversed stop surfacing. With on-demand recall that last part counts: the agent searches once and acts on what comes back.

    Strengths

    • Every Cursor turn is recorded without the agent deciding to save
    • Search covers teammates' Claude Code and Codex sessions, Slack and GitHub
    • glen code-search traces a line back to the session that wrote it
    • glen incognito keeps recall and records nothing

    Limits

    • Recall in Cursor waits for the agent to search; it isn't added to each prompt
    • Hosted only; there is no self-hosted build

    Managed service · Free for 15,000 memories, no card

    Set up Glen in Cursor →

  2. Cursor rules (Memories was removed)

    Best for: Stable conventions you want every Cursor session to follow.

    Cursor homepage at cursor.com
    cursor.com
    Connects to Cursor
    Built in
    Captures
    None; rules are written by hand
    Shared with your team
    Project Rules through git; Team Rules from the dashboard

    Cursor used to have Memories, notes the agent saved from your chats. It was removed in Cursor 2.1.x, and Cursor staff confirmed on the forum on 2025-11-25 that users should export what they had into rules. What remains is three kinds of rules: Project Rules as .mdc files in .cursor/rules/, User Rules in your settings, and Team Rules managed from the dashboard on Team and Enterprise plans, where admins can make them required. Cursor also reads AGENTS.md.

    Rules suit things that rarely change, such as how migrations are named or which test runner to call. Nothing in them comes from a session unless someone copies it in, and nothing comes from Slack, GitHub or other agents. Community add-ons such as cursor-memory-bank (about 3,100 GitHub stars) are themselves a pattern of prompts and rules, not a separate memory store.

    Strengths

    • Free and part of Cursor
    • Team Rules let admins require conventions across a team
    • Project Rules are versioned with the repo

    Limits

    • No automatic memory since Memories was removed
    • Every rule is written and kept current by hand
    • Team Rules need a Team or Enterprise plan

    Built into Cursor · Included with Cursor; Team Rules need a Teams plan

    Visit cursor.com ↗

  3. claude-mem

    Best for: Solo developers who want Cursor sessions captured locally for free.

    claude-mem homepage at cmem.ai
    cmem.ai
    Connects to Cursor
    Plugin (hooks)
    Captures
    Tool use and session end, automatically
    Shared with your team
    Local per project; team sharing is a pilot

    Hooks on tool use and session end are how claude-mem captures, and the same installer that sets it up for Claude Code covers Cursor, OpenCode and Codex too. An LLM compresses each session's activity into summaries, which are stored on your machine in SQLite with FTS5 full-text search plus a Chroma index.

    It's Apache 2.0 with about 112,000 GitHub stars, the most-starred memory project on this page. CMEM Pro, $30 a month after a 30-day trial, is the paid tier. TeamBrain, its feature for sharing between people, was a pilot with no public pricing when we checked, so treat claude-mem as a single-user tool for now.

    Strengths

    • Free and local
    • Captures without the agent choosing to save
    • Same tool across Cursor, Claude Code, Codex and OpenCode

    Limits

    • Memory stays on one machine
    • Summaries cost LLM calls you run or pay for

    Open source (Apache 2.0) · Free locally; CMEM Pro $30/mo

    Visit cmem.ai ↗

  4. Supermemory

    Best for: Developers building on Supermemory's API who also want it in Cursor.

    Supermemory homepage at supermemory.ai
    supermemory.ai
    Connects to Cursor
    Plugin or remote MCP
    Captures
    Automatic with the plugin; tool calls over MCP
    Shared with your team
    Per repo by default; orgs with scoped keys

    Supermemory ships a Cursor plugin next to its Claude Code, Codex and OpenCode plugins, plus a remote MCP server at mcp.supermemory.ai with OAuth sign-in. With the plugin, saving is automatic; over MCP it happens only when the agent calls add_memory. Memory defaults to one container per repo.

    The product underneath is a hosted memory API, so a team building its own agent can point it at the same store. The core is MIT-licensed and runs in Docker if you want to host it. New accounts start with $5 of credit; Pro is $19 a month with three seats, and orgs can add members with scoped API keys.

    Strengths

    • Automatic capture with the Cursor plugin
    • The same API works in your own product
    • Open source with a Docker option

    Limits

    • Access is scoped by repo container and key, not by what each person may see
    • Usage is metered in credits

    Open source (MIT) · Free with $5 credit; Pro $19/mo

    Visit supermemory.ai ↗

  5. Mem0

    Best for: Teams already using Mem0 inside their own product.

    Mem0 homepage at mem0.ai
    mem0.ai
    Connects to Cursor
    Plugin or remote MCP
    Captures
    Plugin, or tool calls over MCP
    Shared with your team
    Per user, agent or app entity

    Cursor is on Mem0's list twice: there's a Mem0 plugin for it, and the docs include a Cursor setup for the remote MCP server at mcp.mem0.ai, which signs in through the browser or with a bearer key. Over MCP, the agent saves and searches by calling tools. Memories are scoped to user, agent, app or run entities and kept in a vector store, with graph memory on the Custom plan.

    The open-source project is Apache 2.0 with about 68,000 GitHub stars. Hosted pricing changed in 2026: Starter, Growth and Pro are closed to new accounts, leaving a free tier of 10,000 adds and 1,000 retrievals a month and then usage billing or a custom contract. Mem0's docs don't describe sharing memory across a team.

    Strengths

    • Apache 2.0 with a large community
    • Both a plugin and an MCP setup for Cursor
    • One SDK for Cursor and your own app

    Limits

    • Over MCP, saving happens only when the agent calls a tool
    • No published paid price for new accounts
    • Team sharing isn't described

    Open source (Apache 2.0) · Free tier; paid is usage-based or custom

    Visit mem0.ai ↗

  6. ByteRover

    Best for: Teams that want memory as reviewed Markdown, versioned like code.

    ByteRover homepage at byterover.dev
    byterover.dev
    Connects to Cursor
    Skill installed by the desktop app
    Captures
    Agent-driven, with a review step
    Shared with your team
    Private, team and shared spaces

    A review step before anything is saved is what sets ByteRover apart. Its desktop app and brv CLI keep a "context tree" of Markdown under .brv/context-tree/ with git-like versioning, and the app installs a skill into Cursor, as well as Claude Code, Codex, OpenCode, Gemini CLI and GitHub Copilot. You ask the agent to record something, then approve the change before it lands.

    That puts it closer to Cursor rules than to automatic capture: what's stored is what someone chose to keep, with versioning and private, team and shared spaces on top. It's source-available under the Elastic License 2.0, with about 4,900 GitHub stars, a free tier that syncs 100 context files, and Pro from 15 a month billed yearly.

    Strengths

    • Every saved change is reviewed
    • Versioned Markdown you can read and diff
    • Team and shared spaces

    Limits

    • Nothing is captured unless someone asks
    • Elastic License 2.0 is source-available, not open source

    Source-available (Elastic License 2.0) · Free tier; Pro from 15/mo billed yearly

    Visit byterover.dev ↗

Set up Glen in Cursor

In Cursor, Glen is a plugin you add after installing the glen CLI. The free plan covers 15,000 memories with no card.

  1. 1. Install the CLI and sign in

    The plugin's hooks call the glen CLI, so install it globally and sign in first.

    bash
    npm install -g @tryglen/cli && glen login

  2. 2. Add the plugin in Cursor

    Run /add-plugin in Cursor and give it the plugin's repository. This adds the four hooks, plus the rule and skill that tell the agent when to search memory.

    text
    https://github.com/Glen-Web-App/glen-cursor-plugin

  3. 3. Work, then ask

    Each turn is recorded from here on. When a task touches earlier work, the bundled rule has the agent run glen search; you can also ask it to search, or run the command yourself.

    bash
    glen search "why the checkout form validates on blur"
Full Cursor setup docs →

Which one should you pick?

Cursor 2.1 removed the one built-in feature that kept notes on its own, so every option here is a replacement of some kind. Working alone, the closest replacement is claude-mem, which captures sessions on your machine for free, with Project Rules for the conventions that don't change. If you'd rather approve every line before it's stored, ByteRover's reviewed Markdown is built for that.

On a team, rules and local capture both stop short. Team Rules reach everyone but hold only what an admin types in, and local tools keep each person's sessions on their own laptop. Glen records every teammate's Cursor turns into one memory alongside their Claude Code and Codex sessions, Slack and GitHub, and a Cursor agent that searches gets that memory filtered to what its user can see. In Cursor the recall waits for that search instead of arriving with each prompt, which is why the plugin ships a rule telling the agent when to run it.

FAQ

What happened to Cursor Memories?
It was removed in Cursor 2.1.x. Cursor staff confirmed it on the forum on 2025-11-25 and told users to export their memories into rules.
Does Cursor have any memory now?
Only what you write: Project Rules in .cursor/rules/*.mdc, User Rules in settings, Team Rules on Team and Enterprise plans, and AGENTS.md. Nothing is learned from sessions automatically.
Why can't a memory plugin add context to every Cursor prompt?
Cursor's beforeSubmitPrompt hook can see a prompt but can't add context to it. A plugin can still record each turn, but recall depends on the agent running a search, which Glen's plugin prompts through a bundled rule and skill.
Can my team share memory in Cursor?
Team Rules are shared, but admins write them by hand. Glen shares memory from the sessions themselves: every teammate's Cursor turns go into one org store, and each search is filtered by what that person can access.
Where does an MCP server go in Cursor?
In .cursor/mcp.json for one project or ~/.cursor/mcp.json for all of them. Cursor supports stdio, SSE and Streamable HTTP servers, with OAuth. Glen uses a plugin in Cursor rather than MCP alone, because the plugin's hooks are what record each turn.
Is cursor-memory-bank a memory tool?
It's a pattern of prompts and rules (vanzan01/cursor-memory-bank, about 3,100 GitHub stars) rather than a separate memory store. It runs through Cursor's rules, so what it keeps depends on the agent following them.