Devin Gets Personal Memory and Daily "Dreams" Backed by a Git Repository

Cognition has added two mechanisms to Devin: Memory and Dreaming. The first carries across sessions what the agent has learned from working with a specific person: preferences, corrections, and lessons from projects. The second launches a background session once a day that reviews the accumulated notes, merges duplicates and discards outdated material. Everything is stored in a personal Git repository of markdown files. The company has released the standard for building this kind of memory in the open.

How the memory works

The most useful things about working with an agent often emerge along the way. You correct a wrong assumption. You explain why an approach won't work in the current project. The agent spends half a day fighting a quirk of its environment and finally beats it. Previously, such lessons either vanished when the session closed, or you had to stop and update a skill by hand. Now Devin saves them to notes on its own.

One important detail: these are not session summaries. They are short notes about lessons, and each one links to the session where the lesson was learned. The memory is personal. It is tied to you within your organization on devin.ai and does not turn into shared instructions for the whole team.

Physically, the memory lives in the Memory Drive. This is a persistent Git repository of markdown files that can be organized by repository, project or topic. A short MEMORY.md file holds general preferences and an index of the other files. At the start of a session, Devin loads only that file into context, then finds and reads the notes it needs with the same tools it uses to navigate code. The entire archive is not loaded into the prompt.

Each session works in its own Git checkout. After editing a note, Devin makes a commit, pulls in changes from other sessions and saves the result to the shared drive. If a parallel session managed to write an update first, a revision check rejects the stale write, and Devin retries on the fresh version. Conflicting edits are surfaced for resolution and are not silently overwritten. As a result, several sessions can append to the same memory at once, and no session treats its local copy as the source of truth.

Dreaming: scheduled cleanup

Recording a lesson during a task is only half the job. Notes need to be reviewed with the context of all sessions in mind. That is what Dreaming is for: a daily background session in which Devin goes through past conversations alongside the current memory and improves the index for future runs.

Here is what it does:

• merges overlapping notes;
• removes temporary details, such as a dev-server port that was only relevant during the day;
• looks for useful lessons that did not make it into memory during the work;
• deletes outdated entries and those that no session has used.

When rebuilding the memory, Devin preserves links to sources and any preferences the user stated explicitly. In the example from the announcement, a week of work produces seven flat notes in the index: about the bun package manager, the NextJS and TypeScript stack, Tailwind, and the PR order for migrations. Some of them overlap, and one is already out of date. Dreaming turns such a pile into a structured set. You can view all Dreaming sessions in the interface.

Memory and skills

Cognition draws a line between the two. A skill captures a repeatable process, such as the steps for testing and publishing a release. Memory holds what Devin has learned about you: your choice of stack and the reason you gave for it. A skill provides the procedure, and memory provides the context for applying it. Both can contain instructions, but they live differently. Skills are packaged deliberately for reuse, while memory accumulates from sessions and is revisited through Dreaming.

The open standard deserves separate attention. Developers of other agents can build this scheme into their own products and submit changes to the repository at cognition.ai/agent-memory-repo. Choosing Git and markdown makes the memory readable and verifiable by a human, with no closed vector store.

How to try it

In devin.ai, open Customize → Memory. There you can see all the notes and recent Dreaming sessions. First, check what the agent recorded correctly and what it turned into noise. You can delete anything unneeded, and it is better to state explicit preferences directly in the conversation so they make it into memory. If you are building your own agent, take a look at the open repository: the scheme with a single-file index, per-session checkouts and revision checks transfers to any stack that has Git.