Does Devin Remember Between Sessions? An Honest Breakdown of Knowledge, Memory, and Snapshots

Devin is the AI software engineer that takes a ticket and goes off to work on its own: it plans, writes code, runs tests, and opens a pull request while you do something else. So the natural question when you start trusting it with real work is what happens when the session ends. If Devin fixed a bug on Monday, does it remember any of that on Tuesday?

Short answer: the session itself does not survive. What survives is everything that gets deliberately curated: Knowledge entries, Memory notes, and playbooks. That distinction decides whether Devin compounds on your codebase over time or starts every ticket from zero.

A Devin session is a sealed room

Each Devin session runs in its own isolated virtual machine. You hand it a task, it works, and when the session ends, the conversation is over. Devin's own docs note that it will keep responding to comments on a pull request only while the session is still alive; once the session ends or goes to sleep, that thread of context is done. Open a new session the next day and Devin does not pick up where the last one left off. It can read your repos, so it knows the code — but it does not remember the conversation you had about the code.

This is the same amnesia every session-based agent has, and it matters more for Devin than for a chat assistant precisely because Devin does long autonomous runs. Losing the thread means losing the why behind the decisions: which approach failed, what the reviewer pushed back on, which shortcut was rejected and why.

Knowledge: the part that does carry over

Devin's documented answer to session amnesia is Knowledge. In Devin's own words, Knowledge is "a collection of tips, advice, and instructions that Devin can reference in all sessions." You build it under Settings → Resources → Knowledge. Every entry has a trigger description — a phrase Devin matches against whatever it is currently working on — plus a short body of content. When Devin starts work related to a trigger, the entry gets pulled in automatically.

Two details make Knowledge more than a static wiki. First, entries are scoped to a repo, an organization, or the whole enterprise, so team conventions follow every session instead of living in one person's head. Second, Devin itself proposes new Knowledge: give it feedback in chat and it will suggest saving the lesson for future sessions. Macros — short identifiers starting with ! — let you drop a knowledge item directly into a prompt by name.

What this means in practice: the branch-naming rule, the deploy checklist, the "never touch this legacy module without reading the migration doc" warning — those persist. What does not persist automatically is anything nobody wrote down. Knowledge is curated memory, and it works exactly as well as your curation discipline.

Memory notes and Dreaming

Separate from Knowledge, Devin ships a Memory feature: it saves your preferences, corrections, and project lessons as notes that carry across sessions, while a companion process called Dreaming keeps those notes organized. This is the closest Devin gets to episodic memory — a record of what happened, not just the rules. Correct Devin's test strategy twice and that correction can follow it into the next session without you re-teaching it.

The honest caveat is that this is still note-level memory. It captures facts and lessons, not the full conversation. The reasoning chain from a specific session — the dead ends it explored, the tradeoffs it weighed before choosing — is not something you can pull back up later.

Snapshots keep the machine, not the mind

Devin snapshots session state so the working environment survives: the repo checkout, installed dependencies, environment variables. Related follow-up work skips the setup. But a snapshot is the machine, not the mind. It does not restore the conversation or the decisions made inside it. Two sessions can share files without sharing any memory of what happened in those files.

Scheduled Devin sessions wake up blind

Devin now supports scheduled sessions — recurring automated runs, the closest thing in its world to the cron-job agents automation operators run every night. This is where the gap bites hardest. A scheduled session that triages overnight alerts or refreshes a report starts with zero recollection of the previous run unless Knowledge, Memory notes, or a playbook hands it the context. Devin can analyze session outcomes and turn the successful ones into playbooks, which is the right instinct — but the loop only compounds if what each session learned gets written down somewhere every future session can read.

Devin Desktop plays by different rules

One more wrinkle: Devin Desktop, the editor in the Devin family, has Cascade Memories — auto-generated memories plus user-defined rules at global, workspace, and system level that persist across conversations. But the fine print matters: the Devin Local agent does not persist memories between sessions at all, and users are told to migrate critical memories into skills instead. So even inside the Devin family, memory behavior depends on which surface you are on. Check which one you are using before assuming anything persists.

The pattern, and where Vilix AI fits

Devin's design reveals the real architecture of agent memory: sessions are disposable, and everything durable is curated on purpose. The teams that get compounding value out of Devin treat Knowledge, Memory notes, and playbooks as a maintained system — reviewing what Devin suggests, pruning what goes stale, writing down what the sessions taught them.

If you would rather have that system without the maintenance, that is the gap Vilix AI fills. Vilix AI is a cloud-hosted memory layer — zero infrastructure for you to run — that any agent reaches over MCP. Every session starts with the context it needs: not just curated rules, but the full conversation history from previous sessions, searchable across every tool the agent uses. It works the same whether the agent is Devin, Claude Code, or the scheduled job running your nightly triage, because the memory lives outside any single agent's session. It is free forever on the free plan, with a 7-day Pro trial that asks for no credit card, and you can export or delete everything at any time. The point is simple: the session ends, the memory does not.

So does Devin remember between sessions? The session, no. The knowledge, yes — if someone writes it down. The teams that understand that line get an engineer that compounds. The ones that do not get a brilliant contractor with amnesia.