Devin Gets Memory: How Memory and Dreaming Are Changing AI Coding Agents

The biggest pain point for AI coding agents isn't their ability to generate code — it's amnesia. Every conversation starts from scratch. The habits you corrected last time, the pitfalls you discovered in your project, your preferred coding style — all gone. Memory and Dreaming, the new features Cognition has introduced for its coding agent Devin, are aimed squarely at this problem.

What Devin's Memory System Actually Is

According to Cognition's announcement, Devin can now retain its understanding of how you work across sessions. Specifically, Memory records three types of information: your preferences, corrections you've made, and lessons distilled from projects and workflows. This content is saved as short notes and is personal to you.

In other words, when you repeatedly tell Devin things like "use TypeScript without any in this project" or "commit messages should follow a specific format," those corrections are no longer one-time expenditures — they accumulate as long-term memory. When the next session begins, Devin already knows who you are and how you work.

This design directly addresses a core weakness of coding agents. Most mainstream AI coding tools today rely on a single-session context window — when the window closes, everything is forgotten. Persisting experience means an agent can gradually get to know you better over time, rather than perpetually being stuck in a first-meeting state.

The context windows of mainstream AI coding assistants (such as GitHub Copilot and Cursor) typically range from tens of thousands to hundreds of thousands of tokens — enough for a complete coding session, but wiped clean once the session ends. This limitation stems from the fundamental architecture of large language models: models don't carry writable state across requests, and every inference is stateless. Devin's Memory feature essentially establishes a persistent "external memory layer" outside the model, injecting relevant memories into the context at the start of each session to work around the model's inherent statelessness. This approach of "retrieval-augmented personal memory" shares similarities with RAG (Retrieval-Augmented Generation), with the key difference being that what's retrieved isn't a general knowledge base, but personal behavioral data specific to that user.

Dreaming: The Background Mechanism That Organizes Memory

If notes simply pile up, the memory store quickly becomes redundant and chaotic. Cognition designed Dreaming to address this — a background process that runs daily. Its job is to reorganize these memories: removing duplicates, linking memories to specific sessions, and distilling new lessons from them.

The naming is telling. Humans consolidate memories and reinforce learning during sleep; Dreaming borrows the same metaphor. It's not passive storage — it's an active memory maintenance mechanism. For a long-running agent, this capacity for self-organization may be even more critical than memory itself. Without it, a memory store becomes unusable as it grows in scale.

Where Memories Live: A Git Repository

On the technical side, these notes are stored in what's called a "memory drive" — essentially a Git repository of markdown files. Every time a session starts, your memory.md is loaded as context.

Using a Git repository with markdown files to hold memories is a remarkably pragmatic choice. It means memories are readable, auditable, and version-controlled. Developers can directly inspect what Devin has actually remembered, and manually edit or roll back entries when necessary. Compared to a black-box vector database, this transparency carries real value for engineering teams that need to trust their agents.

A common alternative implementation that contrasts with the Git repository approach is a vector database. Vector databases convert memory content into high-dimensional vectors and retrieve relevant memories through semantic similarity search — highly efficient and well-suited to large-scale unstructured data. However, their core weakness is precisely a lack of transparency: stored content is transformed by embedding models, making it impossible for developers to read or modify directly, and difficult to determine which content was actually retrieved. By contrast, the Markdown + Git approach trades some semantic flexibility in retrieval for complete auditability — a clear priority trade-off for engineering teams that need to be accountable for agent behavior. Version control also brings an additional benefit: if a memory update causes anomalous agent behavior, Git history can be used to precisely identify the problematic entry and roll it back.

An Honest Caveat: Untested in the Real World

It must be noted that all of the above information comes from Cognition's official announcement, and the features themselves have not yet been independently tested. Whether the memory system actually works effectively in real development scenarios, how well Dreaming organizes memories, and whether erroneous memories could contaminate future sessions — these questions can only be answered through real-world validation.

"Cross-session memory" is a recognized hard problem in the industry. Getting things wrong is more dangerous than not remembering at all: if Devin records a one-time exception as a long-term preference, it will create problems in subsequent work. So maintaining a cautious stance on effectiveness until real test data emerges is entirely reasonable.

Open-Sourcing the Memory Standard: A Move Worth Watching

Beyond the features themselves, Cognition has done something with potentially deeper implications: they've open-sourced this memory standard, publishing it at cognition.ai/agent-memory-repo, with the goal of allowing other agents to adopt the same format.

The significance of this move is that if the memory format can become a universal standard across tools, the work preferences you've accumulated in one agent could theoretically be transferred to another tool that supports the same standard. For the broader AI coding ecosystem, this could have more far-reaching implications than any single product update from Devin — it points toward a future where memory is portable and context can be shared between agents.

"Memory portability" in the agent ecosystem is analogous to the early Web's data portability debates. Historically, user data locked into single platforms (so-called "data silos") was a significant barrier to ecosystem development; it wasn't until open standards like OAuth and ActivityPub emerged that cross-platform interoperability became possible. Cognition's move to open-source the memory format points toward a similar goal: if the format is widely adopted, the work preferences a user builds up in Devin would no longer be a proprietary asset locked to a single product, but could flow across tools as personal, portable data. Of course, open-sourcing the format is only the first step. Whether it becomes a de facto standard still depends on whether other mainstream tools choose to adopt it — which is largely an ecosystem dynamics question, not a purely technical one.

Conclusion

Memory and Dreaming target the most-criticized flaw of coding agents — their amnesia. The design philosophy — a persistent Git repository, background memory organization, an open standard — is pragmatic and thoughtful. But the real test lies in execution: whether memories are accurate, whether the organization is intelligent, whether long-term reliability holds up. All of that still awaits real-world validation. The direction is right; what remains is seeing it through.