Anthropic unifies Claude's memory across chat and Cowork - off by default for Team and Enterprise

What happened

On August 25, Anthropic merged the memory systems behind Claude's chat product and Claude Cowork, its cloud agent platform, into one shared memory. Before this, anything Claude learned about you or your business in a chat session stayed in chat, and anything it picked up while running an agent task in Cowork stayed there too. Now both read from and write to the same store. According to Anthropic's announcement, the goal is "less re-explaining and more picking up where you left off."

Memory shows up as a list of topics under Settings > Memory. You can delete any topic outright, but you can't edit the text directly — to correct something Claude remembered wrong, you have to ask it to change the entry in conversation. The feature is on by default for Free, Pro, and Max plans across web, desktop, and mobile. Anthropic reported that for Team and Enterprise plans, it ships off by default.

What is genuinely new

Persistent memory across products isn't new to the industry, but tying it specifically to an *agent execution environment* is. Cowork is where Claude actually does multi-step work — running scripts, editing files, calling tools — not just answering questions. Up to now, every Cowork session effectively started cold: you'd re-brief it on your project, your naming conventions, your client's quirks, every single time. Linking that to the same memory used in ordinary chat means context built up in one place now carries into the other.

Anthropic also shipped the guardrail alongside the feature rather than after complaints forced it: sensitive topics — health, beliefs, and similar categories — are excluded from memory by default, and you have to explicitly opt in to include them.

What it means for a business owner

If you're running agent-based workflows on Claude — coding agents, research agents, anything that operates over multiple sessions — this addresses a real cost, not a nice-to-have. Re-explaining project context at the start of every session is time, and it's also a failure point: humans forget to mention the one constraint that matters, and the agent makes the wrong call as a result. Memory that persists across chat and Cowork reduces both.

But read the plan detail carefully. Anthropic turned this on by default for individual users and off by default for Team and Enterprise — which is to say, off by default for the plan tier that most businesses actually run agent work on. If you want this benefit for your team, someone has to go into settings and turn it on deliberately. That's the right default for a feature that stores information about your business indefinitely, but it means the rollout headlines ("Claude now remembers everything across sessions") don't describe what most paying business customers will experience unless they act.

The honest caveat

Memory that persists is memory that has to be governed. Once Claude is retaining topic-level notes about your clients, your internal processes, or your codebase across sessions, someone on your team needs to own the questions that come with that: who can see what's stored, what happens when an employee with visibility into that memory leaves, and how it interacts with any data-retention policy you've already committed to a client. The "ask Claude to correct it" editing model is also worth testing before you rely on it — a memory system you can't directly audit and edit is harder to trust for anything client-facing.

None of this is a reason to skip the feature. It's a reason not to flip it on for a team account the same day you read about it in a changelog.

What to do about it

If your team runs recurring agent work on Claude — the kind where the same agent touches the same codebase or client account across multiple sessions — it's worth a short, deliberate rollout: turn memory on for one project, watch what gets stored under Settings > Memory for a week, and decide as a team what belongs there before turning it on everywhere. The point of Cowork's memory is fewer cold starts. Getting that benefit without also inheriting a data-governance problem takes about twenty minutes of review, not zero.