Reference Guide

Agent Memory Stores

Where agent memory lives, and when it disappears. Five stores with five different lifespans — plus the three things that bite: the desktop-app dependency, the fact that Cowork and Claude Code cannot read each other, and the reason notes have to be written during the session.

← Back to Reference Hub

Best for: Everything you and the agent work out together in the moment — reasoning, drafts, decisions, corrections.

Lives in: Anthropic cloud, attached to your account
Desktop app required: no
Reachable from: browser, desktop app, mobile
Survives session end: persists as a record, but not as live context
Read by the next session: no — not unless you paste or reference it

Limitations: Persistence and availability are not the same thing. The conversation is still there tomorrow; it is just not in the next session's head. Treating the transcript as memory is the single most common reason an operator is surprised by what the agent has forgotten.

CloudInert after session

Best for: Facts about you that should hold everywhere — your role, how you like output shaped, the people and areas you work with.

Lives in: Anthropic cloud, scoped to the user account
Desktop app required: no
Reachable from: every Claude surface the account signs into
Shape: /profile.md, /preferences.md, /topics/, /areas/, /people/
Right content: who you are, how you work, recurring people and areas

Limitations: Scoped to the person, not the project — writing project detail here leaks it into unrelated sessions and makes the profile noisy. It also does not reach Claude Code, which reads its own store.

CloudCross-surface

Best for: Everything the next session on this project needs to know — decisions made, conventions settled, state of the work.

Lives in: the user's desktop, reached over the device bridge
Desktop app required: YES — this is the dependency that bites
Reachable from: any surface, as long as the desktop app is open
Shape: MEMORY.md as the index, plus topic files
Read by the next session: yes, for Cowork sessions on the same project

Limitations: Disappears mid-session if the desktop app closes — and it fails at the next write, not at the moment the app closes, so everything else keeps working in the meantime. Invisible to Claude Code entirely.

Desktop-dependentCarries forward

Best for: Context that a terminal-side agent needs across its own sessions in a repo.

Lives in: the user's disk, under Claude Code's own configuration
Desktop app required: no — Claude Code is its own surface
Readable by Cowork: no
Readable by Claude Code: yes, its own store only
The shared channel that does work: CLAUDE.md committed in the repo

Limitations: Disjoint from every Cowork store. A dispatch that tells Claude Code to 'follow the conventions in memory' does not error — it just quietly does nothing, and returns work that ignores conventions the operator believes were communicated.

Claude Code onlyNot shared

Best for: Durable instructions you never want to restate — tone, format defaults, standing constraints.

Lives in: account settings
Desktop app required: no
Reachable from: every session, automatically
Written by: the user, deliberately — not by the agent mid-task
Right content: standing instructions that are true across all your work

Limitations: Blunt instrument. No project scoping, no conditional application. Overloading it produces instructions that are wrong more often than they are right.

Always onGlobal scope

The variable is the desktop app, not the surface

The instinct is to assume that typing into a browser means a reduced session and typing into the desktop app means a full one. That is not how it works. You can work entirely in a browser and keep full project memory, as long as the desktop app is running — the agent reaches the desktop over the device bridge no matter where you are typing. Close the app and project memory disappears mid-session, and it fails at the next write rather than at the moment the app closes, so everything else keeps working in between. That delay is what makes it easy to miss. The same asymmetry shows up in approval dialogs: folder access and permission prompts render in the desktop app, so a user reading in a browser can miss one entirely and conclude the request failed when it merely appeared somewhere they were not looking. And the boundary is wider than memory: skills do not cross it either. This page was published by a Claude Code agent following a Cowork skill it could not read — the two surfaces keep separate skill stores exactly as they keep separate memory stores, and the workflow reached the agent only because it was typed into the prompt. Whichever the other side needs, memory or skill, it travels in the prompt or it lives in a file both can read.

Store	Where it lives	Needs the desktop app?	Survives the session	Who else can read it
The conversation	Cloud	No	Persists, but goes inert	You, from any surface
User memory	Cloud	No	Yes	Every Claude surface on the account — chat, mobile, Cowork
Project memory	The user's desktop, over the device bridge	YES — the dependency that bites	Yes — the only store that carries the project forward	Future Cowork sessions on the same project
Claude Code memory	The user's disk	No	Yes	Claude Code only — Cowork cannot see it
Standing preferences	Account settings	No	Yes — injected into every session	Every session, automatically

Read the third column first. It is the one that decides whether a session behaves the way you expect, and it does not line up with the surface you are typing into.

You start a project in the desktop app, then move to a browser on another machine to keep working.Nothing is lost — as long as the desktop app is still running. The surface you type into is not the variable; the running desktop app is.

You quit the desktop app to free up memory and keep the browser session going.Project memory is gone. Expect the failure at the next write, not at the moment you quit — the session keeps behaving normally until something tries to file a note.

The agent goes quiet on device tools for several minutes and then recovers on its own.The device bridge dropped. Nothing you did caused it and nothing you do fixes it; re-file any note that was in flight once tools return.

You dispatch Claude Code with "follow the conventions we agreed on — check memory."It cannot. Put the conventions in the prompt, or commit them to CLAUDE.md in the repo — the one file both surfaces read.

You want a convention to survive both a Cowork session and a Claude Code dispatch.CLAUDE.md in the repository. Project memory covers Cowork only; Claude Code memory covers Claude Code only.

A session ends abruptly — crash, closed lid, dropped connection — three decisions into the work.Only the notes already written survive. This is the argument for filing during the session rather than at the end of it.

You ask for folder access from a browser and the agent appears to stall with no response.Check the desktop app. Approval dialogs render there, and a request that looks failed from a browser is often just a dialog waiting somewhere you are not looking.

You want the agent to remember how you like documents formatted, on every project and every surface.User memory or standing preferences — the two account-scoped stores. Project memory would confine it to one project.

You want the next session on this specific client engagement to know what was decided today.Project memory (MEMORY.md plus a topic file). It is the only store scoped to the project that the next session reads.

You are about to close your laptop for the day mid-task.File the notes first. The transcript persists but goes inert; project memory is the only channel to tomorrow, and it needs the desktop app open to accept the write.

Write during the session, not at the end of it

The five stores have five different lifespans, and only one of them — project memory — carries this project forward into the next session. That single fact turns note-writing from housekeeping into the actual mechanism of continuity. A session that ends abruptly keeps whatever was already filed and loses everything else, so write early, write often is not tidiness advice; it is the only thing that survives. The corollary is that a write can fail for reasons that have nothing to do with what you typed: if the desktop app has closed, the note has nowhere to land, and you will find out at the write rather than at the close.

Agent Memory Stores

1. The conversation

2. User memory

3. Project memory

4. Claude Code memory

5. Standing preferences

The variable is the desktop app, not the surface

Write during the session, not at the end of it