Why does Windsurf forget my previous sessions?

Windsurf forgets previous sessions because Cascade starts every new chat with a fresh context window and has no cross-session memory of past conversations — only short auto-generated Memories survive. Editor crashes can also wipe in-flight Cascade state. A persistent project memory layer keeps past sessions queryable on every new chat.

Cascade is powerful inside a session and amnesiac across them. Three design choices cause it:

1. No cross-session conversation memory. Cascade Memories auto-saves short workspace-scoped notes ("user prefers Bun"), stored at ~/.codeium/windsurf/memories/. It does not save the substance of past chats — the actual back-and-forth, the half-finished plans, the rationale. Open a new chat and Cascade cannot read what you discussed yesterday.

2. The context window is per-session. Cascade runs on frontier models with windows up to roughly 1M tokens. That window is per-chat. New session, new window, zero recall.

3. Editor stability can wipe in-flight state. Codeium's changelog and forum threads document recurring fixes for IDE crashes during Cascade Diff and editor freezes when opening the terminal. When the editor goes down, the live session goes with it — and you are back at Friday's starting point, minus Friday's progress.

The result: your code persists, your rules file persists, the thread of your work does not.

Every fresh chat is a re-onboarding tax:

• The plan disappears. "We are going to split auth.ts into three files, port the session middleware first, then the JWT signing" was Friday's plan. Monday's Cascade has never heard of it.
• Decisions get re-litigated. The trade-offs you walked through together — why you chose pessimistic locks, why you skipped Redis — are gone. Today's Cascade re-proposes the rejected options.
• Half-done work has to be re-explained. The function you and Cascade were three-quarters of the way through still needs the same constraints you walked through last session. You re-state them or you accept drift.

Windsurf has three native mechanisms, none of which give you real cross-session memory.

Cascade Memories auto-generate short notes during chats. They survive across sessions and are workspace-scoped. The store is intentionally lightweight — sentence-length observations, not transcripts. Useful for stable preferences, useless for "remember the plan we built yesterday".

`.windsurfrules` and `global_rules.md` are static rule files that load every session. Great for durable conventions. Not designed to hold a rolling record of what happened in past chats.

The chat sidebar keeps a local history of past sessions. You can re-open one to read it; Cascade cannot search or retrieve from it programmatically.

You can read the official Cascade Memories docs for the full breakdown.

For static behavior, the natives work. For session continuity, they fall short.

Most devs we hear from do not live inside a single editor. They iterate fast in Cascade, run long agentic loops in Claude Code, sketch design in ChatGPT. None of those tools share session history with the others. So even if Windsurf shipped perfect cross-session memory tomorrow, half of your project context would still be sitting in tools Cascade cannot see.

The project is the unit of work. Memory needs to follow the project, not the editor.

MemoryLake is a cross-model memory layer that connects to Windsurf via Cascade's native MCP support. Instead of relying on Cascade to remember yesterday, you give the project its own memory and Cascade reads from it on every new session.

• Session transcripts as retrievable memory. Drop past Cascade chats, plans, and decisions into the project. New chat opens — Cascade can fetch yesterday's plan in one tool call.
• 10,000× more context than raw prompting. MemoryLake's retrieval engine reads from billions of tokens of project memory and returns only what is relevant per turn. No more re-pasting yesterday's chat to bring Cascade up to speed.
• Cross-tool continuity. The same project memory works in Cursor, Claude Code, Claude Desktop, ChatGPT, Gemini, and Grok. Switch from Cascade to Claude Code mid-project and the context follows.

MemoryLake scored 94.03% on the LoCoMo long-context benchmark — the top published result as of 2026 — with millisecond retrieval and AES-256 end-to-end encryption.

1. Create a project and load your context. Sign in to MemoryLake, open Project Management, click Create Project, and name it after your repo (e.g., "acme-app — Cascade sessions"). Upload past Cascade transcripts, plans, and specs through the Document Drive (PDF, Markdown, Word, Excel, images all supported). Add standing instructions and short session summaries in the Memories tab.
2. Generate an MCP Server endpoint. Open the MCP Servers tab inside your project, click Add MCP Server, name it "Windsurf integration", and click Generate. MemoryLake returns an API key ID, secret, and endpoint URL. Copy the secret immediately — it is shown only once.
3. Add the server to Cascade's MCP config. In Windsurf, open Settings → Cascade → Manage MCPs → View raw config, then add a memorylake entry with the endpoint URL and your Bearer token. Save and restart Cascade. Cascade now has a memorylake tool it can call at the start of every session to pull in yesterday's plan and prior decisions.