Claude Cowork Memory: Native Recall or an MCP Knowledge Base?

Building through the API instead? The Claude Managed Agents memory guide covers scoped stores, concurrent writes, poisoning, and recovery.

Claude Cowork memory now carries useful context between cloud Cowork tasks and Claude chat. That removes a lot of repetitive briefing: preferences, project status, and working relationships can follow you into the next task. But convenient recall is not the same as a durable project knowledge base. For decisions, procedures, and research that a team must inspect and own, your agent’s memory should also be files you can read, edit, and self-host—not only context managed inside one AI product.

The practical architecture is two layers: use Claude’s native memory for personal continuity, then use an agent-agnostic MCP knowledge base for canonical project facts. This guide explains the boundary and gives you a working Claude Cowork-to-Meshnote setup with a correction, isolation, and handoff test.

What changed in Claude Cowork memory

On August 25, 2026, Anthropic announced that cloud Cowork and Claude chat share one memory. Claude saves short topic files while you chat, and you can inspect, edit, or delete them under Settings → Memory. A correction then applies to future conversations. Native memory is on by default for individual Claude plans; Team and Enterprise owners control availability, and members opt in after an owner enables it.

There are two separate retrieval mechanisms. Memory carries selected topics forward automatically. Chat search uses retrieval-augmented generation to search eligible past conversations when you ask what was discussed. Projects have separate memory spaces, and incognito chats do not contribute to memory or chat search.

One boundary matters for Cowork users: Anthropic’s current help documentation says shared chat/Cowork memory works when Cowork runs in the cloud. Cowork sessions running locally on your computer do not use that native memory. Deleting a source conversation also does not automatically remove memory entries derived from it; those entries must be deleted separately. These details make an explicit source-of-truth policy important.

What the top results explain—and what they leave out

The current top results are strong product summaries. Anthropic’s help center documents chat search, topic memory, project isolation, sensitive-topic controls, retention, exports, and the local-versus-cloud Cowork boundary. TechCrunch focuses on the removal of repeated briefing and the ability to inspect, edit, or delete remembered topics. SD Times covers the same launch for a developer audience, including sensitive-data exclusions and cross-session continuity.

None of those three gives a team an operational pattern for separating personal recall from canonical project truth, connecting an external MCP store, or proving that corrections and project boundaries survive a second session. That is the missing layer below.

Native memory and project memory solve different jobs

Option	Best for	Strength	Trade-off
Claude native memory	Personal preferences and continuity across chat and cloud Cowork	Built in; topic files are visible and editable	Tied to Claude; local Cowork does not use it
Mem0	Automatic fact extraction and semantic recall across applications	Managed retrieval, entities, filters, and a Claude connector	Extracted memories can diverge from the original document unless you govern writes
Zep / Graphiti	Changing facts, relationships, and temporal queries	Temporal knowledge graph and hybrid retrieval	More infrastructure and modeling than a small document-centric team may need
Letta	Stateful agents whose memory is part of the runtime	Agent state and context management are first-class	A runtime-centric model is different from sharing one neutral wiki across tools
Readable MCP wiki	Decisions, runbooks, research, and handoffs	Human-readable source, history, links, export, and client portability	The team must define what deserves promotion and keep pages maintained

This is not an either-or choice. Native memory is the low-friction place for “I prefer concise updates.” A project wiki is the authoritative place for “production deploys require the readiness endpoint and a rollback check.” The broader shared-memory architecture guide explains how that second layer can also serve Claude Code, Cursor, and Codex.

Connect Claude Cowork to readable memory over MCP

Meshnote exposes a linked markdown wiki as a remote MCP server. The hosted endpoint supports OAuth 2.1 with PKCE and dynamic client registration, so Claude can authorize the connector without putting an API key in a prompt or config file.

Sign in at meshnote.io and create a project for one real workstream, such as payments. Keep unrelated clients or products in separate projects.
In Claude, open Settings → Connectors, choose Add custom connector, name it meshnote, and enter https://meshnote.io/mcp. Leave OAuth client ID and secret empty.
Complete the browser authorization. Claude discovers Meshnote’s OAuth metadata, registers the client, and receives a scoped bearer token.
Start a Cowork task with the connector enabled. Ask: Use Meshnote to list my projects, then read the schema and index for payments. Do not write yet.
After verifying the project, ask Cowork to save one durable decision with its rationale and source. A useful request is: Write decisions/refund-window with title "Refund window", status "active", the decision "Refunds are allowed for 30 days", rationale, owner, and source date. Link it from the project index.

That sequence is deliberately read-before-write. It prevents an agent from guessing the project schema or writing into the wrong scope. For tool-level details and another authenticated setup, see the Claude memory MCP guide.

Use a promotion contract, not “remember everything”

Conversation exhaust is not knowledge. Give Cowork a short rule for what crosses into shared memory:

Before substantial work, search the project wiki.
Save only decisions, verified facts, reusable procedures, and handoffs.
Every durable fact needs a source or rationale and an updated date.
Update the existing page when a fact changes; do not append a contradiction.
Never store secrets, access tokens, raw customer data, or speculative claims.
Ask before deleting a page or replacing a high-impact decision.

Keep personal style preferences in native Claude memory. Keep repository-specific instructions in CLAUDE.md. Promote knowledge to the MCP wiki only when another person or agent should be able to use, correct, or audit it. This three-way boundary is also useful in the guide to giving Claude long-term memory.

A six-minute acceptance test

Do not stop when the connector says “connected.” Verify behavior across sessions:

Write: In Cowork session A, create the refund-window page above and include a dated source.
Recall: Close the task. In session B, ask Cowork to find the refund policy using Meshnote. It should cite the page rather than claim vague recollection.
Correct: Change the window to 45 days and add why. Confirm the page now states 45, not both 30 and 45 as competing truths.
History: Ask for the page history. Verify the prior 30-day version exists and can be distinguished from current truth.
Isolation: Search a different project for the refund policy. It should not leak across project scope.
Handoff: Open another MCP-compatible client and read the same page. The answer should survive outside Claude without exporting a chat transcript.

This test catches failures that a happy-path demo misses: wrong scope, stale contradictions, absent provenance, destructive updates, and vendor lock-in. It also distinguishes retrieval from truth. A system can retrieve a sentence accurately while retrieving the wrong version.

When native Cowork memory is enough

Stay with native memory when one person works mostly inside Claude and the remembered material is preferences, relationships, and lightweight project continuity. Anthropic’s topic controls are readable and far better than an invisible profile. Mem0 is compelling when automatic extraction and semantic recall matter more than document authorship. Zep fits temporal relationship-heavy workloads. Letta fits applications built around long-lived stateful agents.

Add a readable MCP layer when knowledge must outlive one client, pass code review, retain revision history, or remain usable after a vendor change. Meshnote’s hosted plan is $8/month, while the self-hosted team plan starts at $10 per seat/month with a five-seat minimum. Start syncing — $8/mo.