Agent Memory Repo

Executive Summary

Agent Memory Repo is an open specification for keeping an agent's durable context in a separate Git repository. Cognition developed it around a small entry-point file, linked notes, source references, and ordinary file-search tools. The repository also ships an installable skill for trying the workflow with an agent. It is a memory convention and integration starting point, rather than a complete agent runtime. ^[1]

Cognition's October 5, 2026 announcement describes a fuller implementation in Devin: personal memory within each organization, synchronization across concurrent sessions, and daily background “dreaming” that maintains the notes. Those product behaviors should not be attributed automatically to every agent using the open format. ^[2]

For broader category context, see Agent Self-Improvement Tools. This report evaluates the specification and the announced implementation, not a hands-on benchmark.

---

How the Memory Format Works

The repository root contains MEMORY.md. It holds the context needed in every session and an index pointing to topic files. A note is a one-line bullet with optional metadata, including a source-session URL and the date it was added. Links such as [[projects/payments]] resolve from the memory root; non-Markdown files keep their extension. SQL queries and scripts can live beside prose. ^[3]

The documented session loop is to clone memory, search or follow links, update useful entries, and commit edits. Keeping a short index separates always-loaded context from information fetched for a particular task. Several memory repositories can be loaded into separate folders, each retaining its own ownership, permissions, and history. ^{[1] [3]}

That design has two practical attractions. Reviewers can inspect exactly what an agent saved, and an agent can reuse familiar file-navigation tools. Neither property proves that it will retrieve the right note or interpret it correctly. A clean merge resolves file changes; it does not resolve the truth of two conflicting beliefs.

Example: preserve a decision, not a transcript

Consider a team that learns a billing migration must ship before a UI change. An illustrative memory entry could be:

- Billing migrations must land before the dependent UI release [source: https://example.com/sessions/42; added: 2026-10-06]

Put the entry in a project note and link it from the index. On a later release task, the agent can retrieve the decision and inspect its source instead of receiving an entire old conversation. This example follows the published metadata and linking conventions; it is not an observed production result. ^[3]

---

What Devin Adds: Synchronization and Dreaming

Devin's announcement describes a persistent Memory Drive of Markdown files. Each session gets its own Git checkout. After edits, Devin commits, merges other sessions' updates, and saves back to the drive. A revision check rejects a stale write when another session has updated the drive during synchronization; conflicts are surfaced for resolution. These are described product mechanisms, not independent guarantees established by this review. ^[2]

Dreaming maintains the memory between tasks. Cognition describes a daily asynchronous session that reviews conversations and existing notes, consolidates overlaps, removes transient details, captures missed lessons, and removes stale unused records. It preserves source references and explicit preferences while improving the index. Users can inspect memory and recent dreaming sessions under Customize → Memory. ^[2]

The distinction from skills is lifecycle. A skill packages a reusable procedure; memory accumulates context from work and is revisited later. Devin's announced memory is personal to the user within an organization. The open repository's broader team-memory and swarm examples should not be read as a claim that Devin's personal memories are automatically shared organization-wide. ^{[2] [1]}

---

Trying the Open Skill

The repository documents these installation options: ^[1]

npx skills add AgentMemoryRepo/agentmemoryrepo --skill agent-memory-repo

For Devin's plugin interface:

devin plugins install AgentMemoryRepo/agentmemoryrepo

The public skill keeps memory in a separate repository, defaults to local storage, and acts only when invoked. It explicitly does not add hooks, scheduled jobs, or startup scripts. It requires a clean worktree before updates, stages specific files, and prohibits force-pushing or treating stored memory as executable instructions. A private remote requires the user's explicit setup and authorization. ^[4]

A useful first trial is to save a harmless preference in one session and ask a second session to retrieve it from the same path. Repeat from a fresh machine only after configuring persistence. The README warns that a local repository is unavailable on another computer or a new cloud machine unless it is restored from a private remote. This is a real deployment requirement, not something the file format solves. ^[1]

Strengths and Operational Cautions

Inspectable context is the strongest design choice. Plain files, source links, and Git history give developers material they can review. The open format leaves room for different runtimes and storage arrangements. ^[3] The tradeoff is that implementers still need to decide how memory is selected, synchronized, and maintained.

Before relying on it for important work, evaluate:

• Retrieval quality: test old, paraphrased, and contradictory facts. The documented grep-and-link workflow does not establish recall or latency at a particular library size. ^[1]
• Instruction boundaries: the skill says memory is data, not instructions, and excludes credentials. That is a behavioral rule; review whether the chosen runtime actually prevents an untrusted note from redirecting tool use. ^[4]
• Retention and deletion: design a policy for historical commits, backups, and remote clones. Removing a current note should not be assumed to erase every historical copy.
• Maintenance quality: inspect whether consolidation loses exceptions or promotes a one-off observation into a general rule. Devin documents dreaming behavior, but the announcement provides no independent accuracy evaluation. ^[2]
• Cost: measure foreground retrieval and background maintenance separately. An MIT-licensed format does not eliminate inference, compute, or storage costs. ^[5]

These are evaluation recommendations, not reported failures of Devin.

Evidence and Developer Experience

The evidence reviewed on October 6, 2026 is primarily Cognition's announcement and the public repository. The skill pull request reports a local installer check and a throwaway-repository read/write test; it explicitly says the author did not test the Devin plugin install because that CLI was unavailable. Those are contributor-reported checks, not tests performed for this report. ^[6]

The repository discussion reviewed here did not supply independent longitudinal evidence that dreaming improves task outcomes. This was a limited source review, not an exhaustive survey of developer experience. Claims about productivity, lower token consumption, or superior recall need workload-specific measurement.

Relationship to Coding-Agent Platforms

The open format concerns durable context. Platforms that execute agent work also need to manage machines, access to project tools, and human review. Tembo, for example, currently describes isolated cloud VMs, support for multiple coding agents, connected context, and review of agent output before approval. ^[7]

Disclosure: Ry Walker is Tembo's CEO and co-founder. The relevant relationship is complementary: portable memory could preserve context across execution environments, while an execution platform handles the work session. The reviewed sources do not establish a native Agent Memory Repo integration in Tembo. Such an integration would need explicit decisions about repository access, startup loading, write permissions, and background maintenance.

Assessment

Agent Memory Repo is a useful starting point for teams that want to inspect and version what an agent remembers. The small format makes an initial experiment straightforward; the public skill's explicit limits make it possible to separate that experiment from the fuller Devin product.

The adoption decision should turn on measured reuse and safe maintenance. Test whether an agent recalls a correction, respects its scope, updates it when facts change, and preserves its source. Evaluate dreaming against those outcomes before treating accumulated notes as reliable organizational knowledge.

---

Research by Ry Walker Research • methodology