The Problem

Cowork sessions are ephemeral. Anthropic's help centre states explicitly: "The desktop app must remain open for your session to continue. Closing the app ends the session." Plugins are saved locally to your machine, but session context, working state, and any custom configurations built during a session are lost when it closes.

You had 6 skills built up, plus MCP integrations, folder instructions, and accumulated context about your workflows. When the session ended, you had to rebuild from scratch.

The Fix: A Local "Session Insurance" System

The goal is to make rebuilding a session take minutes instead of hours. You cannot prevent session loss (yet), but you can make recovery nearly instant.

1. Create a Cowork Recovery Folder

Set up a dedicated folder on your Mac that Cowork always has access to:

~/Documents/cowork-recovery/ ├── README.md # Master context doc (the big one) ├── skills/ # Exported skill definitions │ ├── major-matters.md │ ├── linkedin-voice.md │ ├── article-research.md │ ├── ghost-publishing.md │ ├── image-prompts.md │ └── [other skills].md ├── plugins/ # Custom plugin configs │ └── [plugin folders] ├── mcp-configs/ # MCP server configurations │ └── mcp-settings.json ├── style-guides/ # Reference docs │ ├── mm-style-guide.md │ └── mm-voice-brief.md ├── templates/ # Reusable templates │ └── ghost-elements-template.md └── session-logs/ # Periodic session snapshots └── [dated snapshots]

2. Write the Master Context Document (README.md)

This is the single most important file. When you start a new Cowork session, you point it at this folder and say "read README.md and set yourself up." The README should contain:

Think of it as your Cowork "bootstrap file." Everything Claude needs to become useful again in one read.

3. Export Every Skill as a Standalone File

Each skill you build should be saved as a markdown file in the skills/ folder with the full SKILL.md content. When you create or modify a skill during a session, immediately ask Claude to also save a copy to your recovery folder.

The key here: plugins are file-based (markdown), so they are inherently exportable. The problem isn't that they disappear from your machine. It's that the session loses awareness of them. Your recovery folder ensures you can always re-point a new session at everything.

4. Periodic Session Snapshots

Every hour or so during a long session (or before you think you might close the app), ask Claude:

"Save a session snapshot to ~/Documents/cowork-recovery/session-logs/ with today's date. Include: what we've been working on, what's in progress, what decisions we've made, and what's next."

This gives you a breadcrumb trail if a session dies unexpectedly.

5. Use Folder Instructions as Persistent Memory

Cowork supports "folder instructions" that persist when you select a local folder. These are separate from session state. Make sure your key context lives in folder instructions, not just in conversation. When you set up a new session, selecting the same folder re-loads those instructions automatically.

6. Back Up Plugin Configurations

Cowork plugins are stored locally on your machine. Find where they live (on Mac, likely under ~/Library/Application Support/Claude/) and include that path in your regular backup routine. If you use Time Machine, you're probably already covered, but verify.

7. The "New Session" Startup Prompt

Save this as a text file you can paste when starting fresh:

` I'm Charlie. I run Major Matters, a publication covering payments, AI, and commerce.

Please read ~/Documents/cowork-recovery/README.md for full context on my setup, skills, plugins, and workflows.

Then check ~/Documents/cowork-recovery/session-logs/ for the most recent session snapshot to pick up where we left off.

Set up all skills and MCP connections documented in the recovery folder before we start working. `

8. What Anthropic Needs to Fix (Feature Requests Worth Filing)

PART 2: MAJOR MATTERS ARTICLE

I Lost Six Custom AI Skills in a Blink. Here's What Cowork Doesn't Tell You.

Anthropic's desktop agent is the most capable AI tool most people have ever used. It also has no memory. The gap between power and persistence is a problem nobody is talking about.

I had been building for weeks. Six custom skills, a dedicated MCP server for article research, folder instructions tuned to my publishing workflow, and an accumulated context about how I write, what sources I trust, and how my articles are structured. Claude Cowork had become genuinely useful. Not in the "impressive demo" sense. In the "I rely on this for real work" sense.

Then the session closed.

Everything was gone. Not the files on my machine. Not the published articles. But the working intelligence, the context that made Claude useful without a 500-word preamble every time I needed something done. The skills I had built and refined over multiple sessions. The MCP configuration that connected Claude to my curated news feeds. The accumulated understanding of Major Matters' editorial voice.

I spent an afternoon rebuilding what had taken weeks to develop. And the frustrating part is that Anthropic tells you this will happen. Buried in the help centre, one sentence: "The desktop app must remain open for your session to continue. Closing the app ends the session."

That sentence understates the problem considerably.

The most capable AI desktop agent on the market has the persistence of a goldfish. Every session starts from zero, and the burden of continuity falls entirely on the user.

What Cowork Actually Is

For anyone unfamiliar, Claude Cowork is Anthropic's desktop automation agent. Launched on 12 January 2026 as a research preview, it runs locally on your machine, accesses files you share with it, coordinates sub-agents for complex tasks, and can work for hours on multi-step projects without the timeout issues that plague the web chat interface.

In late January, Anthropic added plugin support. Eleven official plugins spanning sales, legal, finance, marketing, and more. Plus a Plugin Create tool that lets you build custom plugins from scratch. These combine skills (domain knowledge Claude draws on automatically), connectors (MCP servers that link to external tools), slash commands, and sub-agents into packages that turn Claude from a generalist into a specialist.

The pitch is compelling. And the capability is real. When it works, Cowork feels like having a genuinely competent colleague who can read your files, understand your context, and produce professional outputs without constant hand-holding.

The problem is what happens when the session ends.

The Persistence Gap

Here is what persists between Cowork sessions: installed plugins (as local files on your machine), any files Claude created or modified on your disk, and folder instructions attached to specific directories.

Here is what does not persist: session context, working state, conversation history, any understanding of what you were doing or why, skill configurations that were set up during the session but not saved as files, and MCP server connections that need to be re-established.

In practical terms, this means that every new Cowork session starts from absolute zero. Claude does not know who you are. It does not remember the six skills you spent three sessions building. It does not know that you prefer British English, that your publication uses "we/our" voice, or that your MCP server has 15 RSS feeds configured across four content pillars.

This is not a bug. It is a design choice. Anthropic's architecture treats each session as independent. The rationale likely involves privacy, security, and the complexity of persisting context across the sandboxed virtual machine environment that Cowork runs inside. But the user experience consequence is severe for anyone doing serious, sustained work.

The GitHub issue tracker tells the story. Issue #2954: "Context persistence across sessions, major workflow disruption for complex projects." Issue #12646: "Local Session History and Context Persistence." Issue #14227: "Persistent Memory Between Claude Code Sessions," where one user wrote: "Claude Code starts every session with zero context. It's a goldfish."

Developers have responded by building elaborate workaround systems. One reported constructing a 62-agent architecture just to maintain basic project continuity. Others have built external memory systems, session logging pipelines, and multi-agent handoff protocols. The community is solving a problem that the product should solve natively.

Why This Matters Beyond My Inconvenience

The persistence gap exposes a broader tension in how AI tools are being built and sold.

Anthropic is positioning Cowork as a professional tool for knowledge workers. The plugin ecosystem is explicitly designed for enterprise roles: sales, legal, finance, marketing. The marketing language talks about "specialists" and "colleagues" and "professional outputs."

But professional tools require professional reliability. A colleague who forgets everything they know about your business every time they leave the office is not a colleague. They are a contractor with amnesia.

The irony is sharp. Cowork was built to be "Claude Code for the rest of your work," extending AI agent capabilities to non-developers. But the persistence problem means that the people least equipped to build workaround systems (the non-technical knowledge workers Cowork targets) are the ones most exposed to the limitation.

A developer can write a CLAUDE.md file, build session handoff scripts, and configure persistent storage. A marketing manager who spent two hours teaching Claude their campaign workflow has no such recourse. When the session ends, the teaching evaporates.

This is the gap between AI capability and AI reliability. The models can do extraordinary things within a session. But the infrastructure around those sessions, the persistence, the continuity, the memory, has not kept pace with the capability.

What You Can Do Right Now

Until Anthropic solves this natively, the burden of persistence falls on you. Here is what works.

Create a recovery folder. Dedicate a folder on your machine that Cowork always has access to. Inside it, maintain a master context document (a README that tells Claude everything it needs to know about you and your work), exported copies of every skill you build, MCP configurations, style guides, and templates. When a session dies, you point the new one at this folder and say "read the README and set yourself up."

Save session snapshots. Periodically during a long session, ask Claude to save a snapshot of the current working state to your recovery folder. What you have been working on, what decisions were made, what is in progress. This is your insurance policy against unexpected session loss.

Use folder instructions, not just conversation. Folder instructions persist between sessions when you select the same folder. Put your critical context there, not in the conversation where it will disappear.

Export skills immediately. Every time you create or refine a skill, save a copy as a standalone markdown file outside the session. Plugins are file-based by design. The files survive. The session awareness of them does not.

Write a startup prompt. Save a standard message you can paste when starting a new session. Three sentences: who you are, where to find your context, and what to set up first. This turns a cold start into a warm one.

Back up your plugin directory. Find where Cowork stores plugins locally and include it in your backup routine.

None of this is elegant. All of it is necessary.

What Anthropic Needs to Build

The feature requests are already piling up on GitHub, and they point to a clear roadmap.

Session persistence across app restarts. The most requested feature. Let sessions survive the app closing, the machine sleeping, or an unexpected crash.

Session export and import. Let users save session state as a portable file that can be loaded into a new session. This also enables cross-device workflows, which Cowork currently does not support at all.

Automatic context handoff. A feature request (issue #24320) proposes context threshold hooks that auto-trigger a handoff document when the session approaches its limits. Instead of context silently degrading, the system would proactively preserve what matters.

Native memory integration. Claude's web interface already has memory that persists across conversations. Cowork does not use it. Bridging this gap would give Cowork users the same continuity that web users already have.

Org-wide plugin sharing. Anthropic has acknowledged this is coming. For teams, the ability to share custom plugins across an organisation would mean that rebuilding a session is less painful because the institutional knowledge lives in shared, version-controlled plugin files rather than in one person's local session.

The Bigger Picture

We are in the earliest days of AI agents being used for sustained, professional work. The tooling is extraordinary. The infrastructure is immature. That gap will close. But for now, the people adopting these tools earliest are also the ones most exposed to their limitations.

The persistence problem is not unique to Cowork. Claude Code users report the same issues. So do users of competing agent platforms. The entire category is grappling with the tension between stateless AI architecture and the inherently stateful nature of real work.

The companies that solve this first, that make AI agents genuinely remember, genuinely persistent, genuinely reliable across sessions, will capture the professional market. Because professionals do not work in sessions. They work in projects. And projects require continuity.

For now, build your recovery folder. Save your skills. Write your startup prompts. And keep the app open.

When your AI colleague forgets everything overnight, is it really a colleague, or just a very expensive temp?

Charlie Major is a Product Development Manager at Mastercard. The views and opinions expressed in Major Matters are his own and do not represent those of Mastercard.