What's the actual condition under which memory flows between Chat and Cowork?
Many people assume that as long as memory is enabled overall, it automatically shows up in whatever interface they're using, whether that's Chat or Cowork. But the official documentation attaches an explicit condition: memory flows between Chat and Cowork only when "Cowork is running in the cloud." That means the deciding variable isn't which interface you opened — it's where this particular Cowork task is actually executing. If a task lands on local execution because it needs a local folder, browser, or computer control, memory won't carry over even though you're still using Cowork, still on the same account. This condition is stricter than most people assume, and easy to trip over without realizing it.
Why does Cowork's memory architecture split along "cloud vs. local" rather than "Chat vs. Cowork"?
This comes down to how the memory system itself operates. Memory needs a stable, persistent cloud context to accumulate topics and cross-reference across conversations — that mechanism is itself a cloud service, so whether you're interacting with Claude in Chat or in a cloud Cowork session, both are connected to the same underlying cloud memory system, which is why they can interoperate. A locally-run Cowork session works completely differently: it's closer to a real-time, closed environment scoped to "this task, on this machine," and typically doesn't retain long-term context after the task ends. Making a local session able to access cloud memory would require additionally bridging the local environment to the cloud memory system, which carries real technical complexity, and might also conflict with the isolated, closed-off positioning that local tasks are meant to have in the first place.
Mechanically, how does the topic-based memory system decide what to store?
As you chat, the memory system continuously analyzes the conversation and breaks out information worth remembering into independent "topic" entries — "the user prefers concise report formats" might be one topic, "the user is working on a particular project" another, each existing independently rather than the entire conversation being stored verbatim. This process happens in real time and continuously, not as a summary generated after the conversation ends. In a new conversation or task, Claude retrieves relevant topic entries based on the current context and brings them into that interaction's context. Within a Project, this retrieval scope is confined to that project's dedicated memory space, so it doesn't mix in topics accumulated from other projects or standalone conversations.
What's the practical impact on someone who habitually builds rapport in Chat before handing work to Cowork?
The most direct impact is that the investment you thought was "build rapport once, benefit long-term" may turn out to be entirely unusable for certain task types — specifically ones that inherently need local resources and therefore land on local execution. You might find that among tasks handed to Cowork, some naturally continue the rapport you built up in Chat, while others require you to explain everything from scratch, and the interface won't proactively tell you which one this task is — the gap only becomes visible when Claude behaves as if it doesn't remember you. The more practical response is to write the context that genuinely matters, that you don't want to re-explain, directly into the task instructions or the project's own notes — as a fallback that doesn't depend on the memory system at all.
You've spent several conversations getting Claude to remember your preferred report format, the shorthand names you use for projects, even your dislike of over-explained responses. One day you open a Cowork task on a local folder, assuming all that accumulated rapport is still there — and Claude acts like it's never met you. You explain the format again. You redefine the project names again.
This isn't a memory malfunction. It's an easily-overlooked rule buried in the official documentation: memory only flows between cloud Cowork sessions, and a locally-run Cowork session can't reach it at all.
Claude's memory mechanism, per the official description, "saves memory as a set of individual topics as you chat" rather than waiting until a conversation ends to generate a summary. That makes it continuous and incremental, and you can also directly ask Claude to remember something specific. What it typically retains includes your role, project context, communication and technical preferences, details of ongoing work, and people and places relevant to your work.
Each project has its own separate memory space and dedicated project summary, keeping context focused and separate from conversations outside that project — searches within a project are also limited to that project's scope. For standalone conversations outside any project, memory applies across all of them: as long as memory is enabled, Claude automatically carries what it remembers into every new chat.
This is the part most likely to be misunderstood. Memory genuinely does flow bidirectionally between Chat and Cowork — but the official docs attach one explicit condition: only when Cowork is running in the cloud. The wording is direct: "what Claude remembers from your chats is available when you hand it a task in Cowork in the cloud," but "memory across Cowork and chat only works when Cowork runs in the cloud. It isn't available in Cowork sessions that run locally on your computer."
In other words, the variable that determines whether memory carries over was never "are you using Chat or Cowork" — it's "is this particular Cowork session executing in the cloud or locally." The moment a task lands on local execution — because it needs a local folder, a browser, or computer control — it's automatically excluded from memory's reach, even though you're still on the same account, the same machine.
Sensitive topics (health, race, religious beliefs, political views, gender identity, and similar) aren't saved to memory by default — the user has to explicitly opt in. And opting in doesn't backfill: only content generated after the setting is turned on gets remembered; sensitive topics discussed earlier aren't retroactively added. Certain information is never stored regardless — government ID numbers, criminal history, financial account numbers, and immigration status — even if you directly ask Claude to remember it.
Deletion has an easily-missed quirk too: deleting a conversation doesn't remove the memory entries generated from it — those persist, and you have to delete them individually by hand. So the assumption that deleting a conversation "clears" its associated memory is wrong; the two are managed separately. Incognito chats are explicitly excluded — they're not saved to memory or chat history at all. On Enterprise plans using customer-managed encryption keys, searching past conversations simply doesn't work, since conversation content is encrypted.
If your workflow is "get Claude up to speed in Chat first, then hand the work off to Cowork," that pattern is fine in itself — but keep an eye on whether the task will drop to local execution because it needs local resources. Once it does, everything you've built up in memory becomes unavailable, and you're effectively warming Claude up from scratch every time. The more reliable approach in practice is to route work that genuinely depends on memory continuity through cloud Cowork sessions wherever possible; when a task absolutely requires a local folder or computer control, write the necessary context — formatting rules, project shorthand, special requirements — directly into the task instructions or that project's own notes, rather than assuming memory will bridge the gap automatically.