Project memory: semantic search over what earlier sessions did
A session writes its own summary when it closes, so the corpus grows without anyone keeping notes.
Why does a fresh Claude Code session know nothing?
Because each session starts from an empty context. Everything an earlier session worked out — the reason a library was rejected, the shape of a schema that took an afternoon to settle, the approach already tried and abandoned — leaves with the process. The next session re-derives it, or asks you to, or quietly repeats the mistake.
Running twelve sessions at once makes that worse rather than better. Twelve agents each learning the project for the first time is twelve times the same explanation.
What project memory does
It is semantic search over what earlier sessions actually did and decided — for you, and for the agents through an MCP tool of their own. An agent that can ask has anyone here tried this before? gets an answer from the project's own history instead of guessing, and you get the same answer from the same corpus without reading a journal.
Who writes the corpus?
The sessions do. A session writes its own summary when it closes, so the corpus fills itself and nothing depends on anyone keeping notes.
That is the design decision the rest follows from: a memory that needs discipline to maintain is a memory that is empty after two weeks. Nobody tags anything, nobody remembers to write it down, and there is no step to forget.
Where does the index live?
On your machine. The embedding model runs locally and the index never leaves it — the same rule as the rest of the app, which adds no account, key or subscription of its own and sends nothing anywhere.
The corpus is part of what settings sync carries, so it follows you to another machine through a private repository you own rather than through anybody's cloud.
How it is built
The engine is a separate Rust crate — crates/cowork-memory —
built and tested on its own rather than inside the app. Its tests run against
a deterministic fake embedder so they are reproducible in CI; the ones that
need the real model are marked #[ignore] and run deliberately.
Keeping it a sidecar is what makes the embedding model swappable and the index inspectable without the app running. It is the piece the deck was missing rather than a piece it improves, and it is tracked from issue #35.
What it does not do
It does not read your code. The corpus is made of session summaries — what was attempted and what was concluded — not of the repository, which the agent can already read for itself. It is memory of the work, not an index of the files.
And it starts empty. The first session in a project has nothing to search, because nothing has closed yet; the corpus is worth something after a week of ordinary use, not on the first afternoon.