AI memory vs shared context
Windsurf and Cascade memory explained
How Windsurf and Cascade memory works: per-tool memories and rules that help one editor but never reach your team or other tools. Here is the fix.
Windsurf's Cascade agent does keep memory, in two forms. It has rules, the guidance you write on purpose for a project, and it has memories, context Cascade retains so it stays useful as you work. Both persist better than a raw chat history, and both live inside Windsurf. That last part is the catch. The memory helps that one editor. It does not reach your other tools or your teammates.
Here is what each piece does and where the boundary sits.
What Cascade keeps
Two layers, and they are not the same thing.
- Rules. These are intentional. You write project rules and Cascade reads them, the way Cursor reads its rules and Claude Code reads
CLAUDE.md. Because they are files you maintain, they persist and can version with the repo. This is the right home for conventions and the do-not-do list. - Memories. These are retained context Cascade builds up to stay grounded across a project, managed by the tool rather than written by you. They help Cascade carry understanding further than a single prompt.
Together they make Windsurf feel like it knows your project, and within Windsurf, it does. The knowledge is just held inside the tool.
Where Windsurf's memory stops
The boundary is the tool itself, and a few consequences follow.
- It is per-tool. Cascade's memories and running context do not reach Cursor, Claude Code, or a ChatGPT planning thread. Each tool keeps its own state, so what Windsurf knows, the others do not.
- It is per-person in practice. A committed rules file is shared, but Cascade's memories and live context are local to your machine. A teammate opening the same project gets the files and none of the understanding Cascade built for you.
- Memories are not a team decision log. They keep Cascade grounded, but they are not where the team records what it decided and why, in a form every tool and person can read.
- It is still per-tool memory, which is why agents forget. The deeper pattern, that each tool's memory is siloed and short-reaching, is the subject of why AI agents forget.
This is not a flaw unique to Windsurf. It is the same shape as Cursor's session memory and Claude Code's per-session memory. Every tool keeps its own. Good enough for one person in one editor. A problem the moment you add a second tool or a second teammate.
The fix: keep the durable context outside the editor
If you want context that reaches every tool and every teammate, it cannot live inside Windsurf. It has to live in a shared source the tools read.
That is what a shared context layer does. BaseThread keeps a curated context graph for your team, curated, not scraped, organized into layers like Company, Products, Teams, Projects, and You, with three streams: Activity for what happened, Decisions for what you settled and why, and Tasks for what is next. Windsurf reads the relevant slice over MCP through the local Mac app bridge, alongside its own rules, and writes activity, decisions, and tasks back as work happens. The same source is read by Cursor, Claude Code, and ChatGPT over the remote endpoint.
So instead of memory that stops at the editor:
- Windsurf reads the shared layer every session, so it starts with the project, the decisions, and recent activity, not just its local rules.
- A teammate's Cursor reads the same source, so you both work from the same facts.
- A decision Cascade helped you reach gets written back, so it is there for the next session and the next person.
- Adding another tool does not mean rebuilding its memory. It reads the same source.
Keep Cascade's rules and memories for what they are good at, local guidance and editor-level grounding. Put the cross-tool, cross-team truth in the shared layer. This is shared context for AI tools applied to Windsurf.
The quick test
Ask Cascade why a piece of your architecture is the way it is, then ask the same in another tool. If they disagree, each is running on its own memory. One shared source makes them agree.
TL;DR
Windsurf's Cascade keeps rules you write and memories it retains, both of which live inside the tool. They make that one editor sharper and do not reach your other tools or your teammates. To get context that survives and travels, keep the project, decisions, and activity in a shared layer Windsurf reads over MCP alongside its own rules, and writes back to, so the same source feeds every tool and every person.
Give Windsurf, and every other AI tool, one shared context that reaches your whole team. BaseThread is in closed beta.
Related reading
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.
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.
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.
Why AI agents forget, and how teams fix it
AI agents forget because context is per-session and per-agent, not persistent or shared. Here is the real reason, and the fix that works for a whole team.
Frequently asked questions
Does Windsurf remember across sessions?
Windsurf's Cascade agent has its own memories and rules. Rules are files you maintain and they persist. Memories are things Cascade retains to stay useful across a project. Both live inside Windsurf, so they help that editor and do not carry to your other tools or your teammates.
What is the difference between Cascade memories and Windsurf rules?
Rules are intentional guidance you write, like project rules Cascade reads each session. Memories are retained context Cascade builds up on its own. Rules persist because you maintain them. Memories are managed by the tool and stay inside it.
Does Windsurf share memory with my team?
Not in a cross-tool, cross-person way. Committed rules are shared as files, but Cascade's memories and running context are local to the tool and the machine. A teammate using Cursor or Claude Code does not see them.
How do I give Windsurf persistent, shareable context?
Keep the durable facts in a shared source outside the editor and have Windsurf read it over MCP, alongside its own rules. The source carries the project, decisions, and recent activity to every tool and every teammate, and tools write updates back.