AI memory vs shared context
Does Cursor remember across sessions?
Does Cursor remember across sessions? Mostly no. Here is what Cursor keeps, what it forgets, and how shared context carries across tools and teammates.
Short answer: mostly no. Cursor does not carry a real memory of your project from one session to the next. It reads your rules files when a session starts, and it holds some context while you work, but that working memory is limited and it lives inside the tool. Close the editor, switch machines, or come back tomorrow, and most of what you explained in the chat is gone.
That trips people up because the editor feels like it knows your project. It does, for as long as the session lasts. The knowledge just does not stick.
What Cursor actually keeps
Two things survive between sessions, and both are things you set up on purpose.
- Project rules. Cursor reads
.cursor/rules(and the older.cursorrules) at the start of a session. This is where your conventions, stack notes, and do-not-do list belong. Because the files are in the repo, they persist and they version with your code. - Open files and the current workspace. The editor reopens where you left it, so the immediate surroundings come back.
Everything else is session state. The chat history, the reasoning it built up about your codebase, the thing you carefully explained three prompts ago. That is held while you work and is not a long-term store.
Where Cursor's memory stops
The gap shows up the moment your work spans more than one sitting or more than one tool.
- The chat does not persist as project knowledge. What you taught Cursor in a conversation is not promoted into anything durable. Next session, you teach it again.
- It is per-tool. A decision you reached while working in Cursor never reaches your Claude Code session or a ChatGPT planning thread. They each keep their own state, which is why sharing context between Cursor and ChatGPT takes a deliberate setup.
- It is per-person. Your rules file might be shared if it is committed, but the live context is not. A teammate opening the same repo gets the files and none of the understanding you built.
- Rules files do not scale cleanly. One flat rules file is fine early on, and gets unwieldy as the project grows, which is its own problem covered in when a flat .cursorrules file isn't enough.
None of this is a knock on Cursor. Session memory is a reasonable design for an editor. It just means the editor is not the right place to store the things you want to keep.
The fix: keep the durable context outside the tool
If you want context that survives every session and reaches every tool and teammate, it cannot live inside one editor. It has to live in a shared source the tools read.
That is the idea behind a shared context layer. BaseThread keeps a curated context graph for your team, curated, not scraped, organized into layers like Company, Products, Teams, Projects, and You, plus three streams: Activity for what happened, Decisions for what you settled and why, and Tasks for what is next. Every AI tool reads it over MCP, through the local Mac app for editors like Cursor or through the remote endpoint at mcp.basethread.ai for tools like ChatGPT. As work happens, your tools write activity, decisions, and tasks back to the layer, so the record stays current without anyone maintaining a file.
So instead of Cursor trying to remember:
- Cursor reads the relevant slice of the shared layer at the start of every session, on any machine.
- The decisions you reached last week are already there, so it stops re-proposing settled choices.
- A teammate's Cursor reads the same source, so you both work from the same facts.
- When a task ships or a decision is made, it gets written back, so next session starts caught up.
This is shared context for AI tools applied to the specific question of Cursor's memory. The editor does not need to remember if the memory lives somewhere every tool can reach.
The quick test
Close Cursor, reopen it tomorrow, and ask why a piece of your architecture is the way it is. If it guesses instead of citing the decision, you are relying on session memory that did not survive.
TL;DR
Cursor mostly does not remember across sessions. It reads your .cursor/rules files each session and holds limited working memory inside the tool, but the chat, the reasoning, and the decisions you reached do not persist and never reach your other tools or teammates. To get context that survives every session and every tool, keep it in a shared layer that Cursor reads over MCP and writes back to as work happens.
Give Cursor, and every other AI tool, one shared context that survives the session. BaseThread is in closed beta.
Related reading
Claude Code memory across sessions
How Claude Code memory works across sessions: CLAUDE.md persists, the rest is per-session and per-machine. Here is how to make context stick across a team.
When a flat .cursorrules file isn't enough for a team
A .cursorrules file is great for one developer. Here are the four moments it breaks down for a team, and what to use when a flat file stops being enough.
How to share context between Cursor and ChatGPT
Share context between Cursor and ChatGPT without copy-paste. Keep one source both tools read over MCP, so your project context follows you between them.
What is shared context for AI tools? (2026 guide)
Shared context for AI tools is the company, project, and decision background every AI reads automatically, so your whole team's tools stop guessing.
Frequently asked questions
Does Cursor keep memory between sessions?
Not in a durable, project-wide way. Cursor reads your .cursor/rules files at the start of a session, and it has some session memory, but that memory is limited and tied to the tool. Close the editor or switch machines and most of the context you built up in the chat is gone.
What is the difference between Cursor rules and Cursor memory?
Rules are files you write on purpose, like .cursor/rules, that Cursor reads every session. Memory is what the tool tries to retain on its own across a working session. Rules persist because you maintain them. Memory is short-lived and per-tool.
Does Cursor share context with my teammates?
No. Cursor rules live in your repo, so a committed rule is shared, but the running context, the decisions, and what you just explained to the chat stay on your machine. Teammates start from scratch.
How do I make Cursor remember my project long term?
Put the durable facts in a source outside the tool. A shared context layer that Cursor reads over MCP gives it the project, the decisions, and recent team activity every session, so nothing depends on the editor remembering.