Windsurf's Memories Died With Cascade. Your Devin Local Sessions Start Blank.

Picture the Monday morning version of this: last week your agent learned how your payments module retries failures and which queue library you threw out for losing messages. Today you open a fresh session, ask it to wire retries into a new endpoint, and it reaches for the library you already rejected. The sidebar still shows Friday's conversation. The agent never read it.

If you came from Windsurf, that whiplash has a cause. Windsurf is now Devin Desktop, and its new primary agent, Devin Local, does not remember anything between sessions. The feature that used to hold your context is gone with the old agent, and the vendor is open about it.

What Your Agent Used to Know

The old Windsurf agent, Cascade, carried a built-in feature called Memories. You could set your own notes, like which auth pattern the project uses or which files not to touch, and the agent would also pick up facts from past interactions by itself. Every new session started with those memories loaded into context, so the agent walked in already knowing things you had settled weeks earlier.

On big repositories that was the difference between getting to work and spending the first stretch of a session re-explaining the architecture. It also had a shadow side: the model could store memories without you confirming first, so researchers flagged it as a quiet spot for injected content to lodge itself and get reloaded into every future session. A memory system you never audit is a risk, not just a convenience.

The Rebrand Broke the Contract

In June 2026, Cognition folded Windsurf into the Devin line as Devin Desktop. The local agent got rewritten from the ground up, and the replacement is Devin Local. Under limitations in its own documentation, Cognition states it plainly: the Devin Local agent does not persist memories between sessions.

There is a migration path of sorts. The docs ship a "Devin: Open Cascade Migration Wizard" that moves your critical memories into skills, the supported way to give Devin Local reusable behavior. What the vendor supports going forward is rules, AGENTS.md files, and skills: context you write down yourself, in files you own.

Read that again, because it is the whole story. Your agent's memory went from something the tool maintained for you to something you maintain for the tool.

Why This Bites Operators Especially Hard

For someone who runs the agent a few times a week in one repo, the rules file solves most of it. For anyone running agents on a schedule, or across several tools, the loss cuts deeper.

Every session now starts from a blank slate and has to reconstruct what it knew. That reconstruction costs tokens, and it costs attention: you watch the agent re-ask a decision you settled, or re-derive an architecture it understood last week, and you pay for both the re-derivation and your own time double-checking it. Stale rules files make it worse, because the agent follows outdated instructions with full confidence and you only find out when something breaks.

Then there is the fragmentation. Rules files live in one project. Your other AI tools do not read them. Context you settle in the IDE stays in the IDE. The moment your workflow touches a second tool, you are briefing two amnesiac agents instead of one.

What to Do About It This Week

If you came up through Windsurf and your sessions feel dumber than they used to, this is probably why. A few things are worth doing before the old behavior fully fades into memory, pun intended.

First, run the migration wizard while your Cascade memories still exist. Anything the old agent knew that matters belongs in a skill or a rules file now, because Devin Local will not pick it up on its own.

Second, consolidate the durable facts into one AGENTS.md or workspace rules file, and treat it like a living document. The moment it drifts from reality, your agent starts acting on fiction.

Third, give the agent one standing instruction: read the shared memory before acting, write to it when something gets settled. Then verify it the hard way, by recalling a fact in a fresh session. If the check fails, the instruction is decoration.

The vendor rebuilt the agent. Your context has to live somewhere the rebuild cannot touch.

The Memory That Follows You Between Tools

The one approach that survives the next rebrand is the one that does not live inside the vendor's tool at all: external memory, connected over MCP, shared by every agent you run. An always-on rule tells the agent to read memory before acting and write when a decision gets settled. The memory itself lives outside the session, outside the IDE, outside the rebrand.

That is the shape Vilix AI is built for. It is a cloud-hosted memory layer that plugs into AI tools over MCP, so the same memory follows you from Devin Local to Claude Code to anything else you run. No servers to maintain, no files to sync, no wizard to run when the vendor rewrites its agent again. Agents store full conversation history there, not just extracted facts, which means you can reopen the actual discussion behind any decision instead of trusting a summary.

The pricing removes the evaluation risk: free forever on the free plan, a 7-day Pro trial with no credit card required. And your data stays portable, so you can export everything or delete it whenever you want. A memory layer should never become another lock-in problem like the one that started this.

Windsurf used to remember. Devin Local does not, by design, and no migration wizard will bring back an agent-side memory store. Put your memory somewhere the next rebrand cannot reach.

Get shared memory for every AI tool at vilix.ai. Free forever, no credit card.