Projects and Memory Management

Memory That Actually Works

Every session with Co-Work starts fresh. That's a good default for general tasks — you don't want your breakfast planning prompt contaminated by context from last week's financial analysis. But for ongoing, complex work — a client relationship, a product launch, a long-running research project — starting from scratch every session is a productivity sink.

Co-Work Projects solve this. A Project is a persistent workspace container with its own memory, its own instructions, and its own context documents. When you open a project, Co-Work arrives pre-briefed on everything that matters for that work. The client's preferences, the decisions already made, the constraints you've established — all of it is there without you re-explaining it.

Understanding the Memory Hierarchy

Co-Work has three distinct layers of memory, and they have different scopes:

• Global memory — applies everywhere; your business context, personal preferences, safety guardrails. This is your Business Brain from Module 2.
• Folder memory — applies within a specific folder; set up in memory.md files in each subfolder. This is the folder-scoped context from Module 3.
• Project memory — applies within a specific project container; written and read automatically as you work in the project. This module covers project memory in depth.

The key distinction: project memory is dynamic. Folder memory is static files you write manually. Project memory is continuously updated by Co-Work as you work — it observes what you do and what you tell it, and saves relevant context automatically.

Three Ways to Create a Project

Pathway 1: From Scratch

Navigate to Settings → Projects → New Project. Give it a name, write its instructions (100–200 words: scope, output format, constraints, key background), and add any context documents you want it to start with. This is the most common starting point for a new client, project, or initiative.

Pathway 2: From Import (Claude.ai)

This is a coverage gap — no community resources cover this path, but it's documented in the official Co-Work docs.

If you have been using Claude.ai Chat Projects for ongoing work, you can import them into Co-Work. The process: Settings → Projects → Import → Connect Claude.ai account → Select project. What transfers: the project's instructions and context documents. What does not transfer: conversation history. Your memory and framing survive the migration; your chat transcripts do not.

Pathway 3: From Folder

Convert an existing Co-Work folder into a Project container. This upgrades a static folder setup (with claude.md and memory.md) into a dynamic project workspace with persistent memory that Co-Work manages automatically. Your claude.md becomes the project instructions; your memory.md becomes the initial memory seed.

What Goes Inside a Project

A well-configured project has four elements:

1. Instructions — the role definition for Co-Work in this context. Who is it working as? What format does it use? What constraints apply? Keep this to 100–200 words. Longer instructions create noise, not clarity.
2. Context documents — files Co-Work can reference on demand. Client background, product specs, pricing, key decisions. These don't live in the instructions — they're loaded when needed with "check [document name]". This is the token-efficient pattern from Business Brain applied at project scope.
3. Memory log — automatically maintained by Co-Work as you work. You can also write to it explicitly.
4. Sessions — conversations within the project that can reference all of the above without re-establishing context.

Memory Management: The Commands You Need

This is the section no community videos cover. Official documentation describes these natural language commands for managing project memory — they're simple but powerful, and most users don't know they exist.

Write to Memory

"Save this to memory: [fact or decision]"
"Remember that [client name] prefers [preference]"
"Note: we decided on [decision] because [reason]"

Read Memory

"What do you know about this project from memory?"
"What do you remember about [topic]?"
"What decisions have we made about [area]?"

Edit Memory

"Update your memory about [topic] — the correct information is [X]"
"Change what you know about [subject] to [new information]"

Delete from Memory

"Remove from memory anything about [topic]"
"Delete the memory entry about [subject]"
"Forget what you know about [outdated information]"

Memory management is essential for long-running projects. Without active management, project memory accumulates outdated information and contradictory entries. A decision that was made in January and revised in March both sitting in memory creates inconsistent behavior.

Context Rot and How to Prevent It

Jack Roberts describes Context Rot as the degradation of response quality that happens in long Co-Work sessions. As a conversation extends, the earlier parts of the session carry less weight in the model's attention, and accumulated context creates noise that interferes with the task at hand.

The practical rule from Jack Roberts: clear context every 30–45 minutes in long working sessions. How to do it: instead of continuing the current conversation, start a new session within the same project. The project memory persists across sessions — so the important context survives the reset. What you lose is the in-session conversation history, which is usually the noise you wanted to clear anyway.

Archiving vs. Deletion

When a project is complete or no longer active, you have two options:

• Archive: The project is hidden from your active list but fully preserved. Memory, instructions, and context documents are all retained. You can restore an archived project at any time. Use this for completed projects you might reference in the future.
• Delete: Permanent. No recovery. Memory, instructions, context documents — gone.