🧠 What Are Claude Cowork Projects and How to Use Them

TL;DR — Too Long Didn’t Read

• Projects (launched March 20, 2026) are persistent workspaces inside Cowork where related tasks, files, instructions, and memory stay together.

• Without Projects, every Cowork session starts fresh. With Projects, Claude carries context forward across sessions — but only within that specific project.

• Each project has four components: instructions, context sources, memory, and scheduled tasks.

• Context sources can be a local folder, a linked Claude Chat project, or a pasted URL — or any combination.

• Projects are desktop-only, stored locally, and cannot be shared — even on Team or Enterprise plans.

• The best use cases are recurring workflows where consistent context, tone, or data access matters: research, client work, content operations, data processing, and personal knowledge management.

1. What Cowork Projects Are (and Aren't)

Before Projects shipped in March 2026, every Cowork session was a blank slate. You'd open a task, re-explain your role, your preferences, the files involved, and the context behind the work — every single time. For one-off tasks, that's fine. For recurring work, it adds friction that compounds over time.

Projects solve this. A Project in Cowork is a persistent workspace you build once and return to. It holds:

• The instructions you want Claude to follow for this type of work

• The files and context it should reference

• The memory it has built up from previous tasks in this project

• Any scheduled tasks you've set to run automatically

Everything scoped to a project stays in that project. If you're running a client content project and a separate competitive research project, what Claude learns in one doesn't bleed into the other.

One important clarification: Cowork Projects are different from Claude Chat Projects. Chat Projects live in Claude.ai and work across your browser-based conversations. Cowork Projects live on your desktop, run locally, and are built around the tasks you execute through Cowork's agentic mode. The two can be linked (more on that in the next section), but they're distinct systems.

2. The Four Components of a Project

Every Cowork Project has the same four building blocks. Understanding what each one does helps you set them up in a way that actually reduces your workload rather than creating more configuration overhead.

1. Instructions

Instructions are standing guidelines that shape how Claude approaches every task in this project. Think of them as what you'd tell a contractor on day one: your preferences, constraints, defaults, and non-negotiables.

What to put here:

• Role or perspective you want Claude to adopt ("You're working as a content strategist for a B2B SaaS company")

• Output format defaults (length, structure, headings, tone)

• Things Claude should always do or never do within this project

• Constraints specific to this workstream (e.g., "don't modify source files, only create new ones")

Keep instructions focused on what's actually relevant to the work. Instructions are loaded into context at the start of every task in the project, so bloated instructions consume context budget without improving output.

2. Context Sources

Context sources are where you tell Claude what to reference when working in this project. You have three options:

Local folder — Select a folder on your computer. Claude reads the files inside and can also write, edit, and create files within it. This is the primary option for document-heavy workflows. Folder instructions can be added separately (and Claude can update them during sessions).

Linked Chat project — If you already have a Claude Chat project with a knowledge base, you can link it directly. This imports the files and instructions from that project into your Cowork workspace, so you don't have to duplicate your setup.

URL — Paste a URL for Claude to reference during tasks. Useful for linking to a specific webpage, documentation, or live resource you want accessible without saving a local copy.

You can combine all three. A project might have a local folder for working files, a linked Chat project for your knowledge base, and a URL pointing to your company's public style guide.

3. Memory

Memory is what makes Projects genuinely useful for recurring work. When memory is enabled, Claude retains context from tasks you've run in this project and applies it to future tasks. It doesn't rely on you re-explaining what was done, what decisions were made, or what files exist.

A few things to know about how memory actually works:

• Memory is scoped strictly to the project. What Claude learns here doesn't affect other projects or standalone sessions.

• Memory doesn't mean Claude remembers everything verbatim — it builds a working understanding of the project's history, decisions, and context.

• For very long projects, it's worth occasionally reviewing what Claude has retained and confirming it's accurate, especially before tasks where past decisions matter.

4. Scheduled Tasks

Scheduled tasks inside a project run in the project's context automatically. Any recurring workflow that belongs to this project — weekly report generation, daily file organization, regular competitive monitoring — can be scheduled here rather than managed globally.

When a scheduled task runs, it inherits the project's instructions, context sources, and memory. You don't have to re-scope it each time. This is the feature that turns a project from a filing cabinet into an active workflow.

3. Six Practical Use Cases

These are use cases where Projects create specific, repeatable value — not hypothetical examples, but the kinds of recurring work that show up across most professional workflows.

Use Case 1: Research and Synthesis Workspace

The problem without Projects: You're researching a topic that spans dozens of files — reports, articles, interview transcripts, notes. Each Cowork session starts without memory of what was read or synthesized before. You either upload everything again or start fresh.

How Projects fix it: Build a project with a local folder containing all your source material. Set instructions that tell Claude how to handle this research (what to prioritize, how to format outputs, what questions to answer). As you run tasks — pull key claims from this report, compare findings across these sources, draft a synthesis — Claude builds memory of what's been processed and what gaps remain.

Practical workflow:

• Local folder: /research/[topic-name] with all source files

• Instructions: research methodology, output format, citation style

• Recurring task: weekly summary of newly added files

• Memory carries: which sources have been processed, key findings so far, outstanding questions

Best for: analysts, researchers, journalists, consultants, anyone building a knowledge base over time.

Use Case 2: Client Work Management

The problem without Projects: Every client is different. You have different tone guidelines, different deliverable formats, different background context. Without a project, you re-brief Claude on the client every session.

How Projects fix it: Create a project per client (or per client account). Load in the context that defines how you work with this client — their brand voice, past deliverables, relevant product information, communication preferences. Every task you run in this project gets that context automatically.

Practical workflow:

• Local folder: /clients/[client-name] with brand docs, past deliverables, product info

• Instructions: tone, format requirements, things to avoid, how Claude should refer to the client's products

• Linked Chat project: if you've been running client research or briefing in Chat, link it

• Scheduled tasks: recurring deliverables (weekly status draft, monthly report skeleton)

• Memory carries: what deliverables have been produced, client preferences Claude has learned, active projects

Best for: agencies, consultants, account managers, freelancers with repeat clients.

Use Case 3: Content Operations Pipeline

The problem without Projects: Your content workflow involves brand guidelines, past content, SEO targets, content calendar data, and specific formatting rules. Assembling this context for a single piece of content takes longer than it should.

How Projects fix it: A content project holds all of this permanently. Claude knows your brand voice, what's already been published, what topics are in the pipeline, and what the output requirements are for different channels.

Practical workflow:

• Local folder: /content with brand style guide, past articles, content briefs, channel-specific formatting rules

• URL: link to your public content guidelines or editorial standards page

• Instructions: writing tone, structure preferences, what to do with a brief, what not to fabricate

• Scheduled tasks: weekly content calendar review, daily brief generation from a shared doc

• Memory carries: published topics, recurring feedback patterns, format decisions made over time

Best for: content marketers, editorial teams, social media managers, newsletter operators.

Use Case 4: Competitive and Market Intelligence

The problem without Projects: Competitive research is ongoing, not one-time. You're tracking multiple competitors across multiple sources, and each round of research doesn't connect to the last.

How Projects fix it: A competitive intelligence project keeps all research in one place with persistent context. Claude knows what was captured last time, what changed, and what to look for in the next pass.

Practical workflow:

• Local folder: /competitive-intel with past analysis docs, competitor profiles, product comparison files

• URLs: key competitor pages, pricing pages, or public documentation you want Claude to reference

• Instructions: what dimensions to track (pricing, features, positioning, messaging), how to format findings, how to flag changes from last time

• Scheduled task: weekly competitor update that reads new files and patches the existing comparison document

• Memory carries: baseline from past analysis, known positioning shifts, open questions

Best for: product managers, growth teams, strategy teams, founders tracking their market.

Use Case 5: Data Processing Workflows

The problem without Projects: You regularly process the same kinds of files — invoices, reports, survey results, exports from tools — into standardized outputs. Each batch requires the same setup from scratch.

How Projects fix it: A data project holds the processing rules, output templates, and context that defines how each batch should be handled. You drop new files into the folder, run the task, and get the same standardized output without re-explaining the logic.

Practical workflow:

• Local folder: /data-processing/[workflow-name] with incoming files subfolder and output subfolder

• Instructions: what the data is, how to process it (transformations, categorizations, calculations), what the output file should look like

• Scheduled task: daily or weekly processing run triggered when new files appear

• Memory carries: previous batch summaries, edge cases Claude has seen and how to handle them, running totals or aggregates

Best for: operations teams, finance, sales ops, anyone with recurring data-to-report workflows.

Use Case 6: Personal Knowledge Management

The problem without Projects: You have years of notes, documents, and conversation history scattered across tools. Getting Claude to help with any of it requires uploading what's relevant each session, and it loses the thread the moment the session ends.

How Projects fix it: A personal knowledge project can bridge your existing context — including Chat history — with Cowork's ability to work directly with local files. The import feature lets you bring in a Chat project's knowledge base, so nothing you've already set up is wasted.

Practical workflow:

• Import from existing Chat project (if you've been building context there already)

• Local folder: your notes folder, journal, reference documents, anything you want Claude to search and reference

• Instructions: how Claude should interact with your notes, what questions to help you answer, how to format responses

• Scheduled task: weekly digest of new notes added, or a "what did I learn this week" summary task

• Memory carries: key themes across your notes, patterns Claude has observed, questions you've been exploring

Best for: anyone doing ongoing writing, research, or learning who wants AI assistance that builds understanding over time rather than resetting it.

4. How to Set Up Your First Project

Three ways to create a project:

1. Start from scratch — Give the project a name, add instructions, and configure context sources. Best for new workflows that don't have an existing Claude Chat project to draw from.

2. Import from a Chat project — Under "Import from project," search your existing Claude Chat projects and select one. Claude will transfer the files and instructions from that project into a new Cowork workspace. You'll name the new project and choose where to save it on your computer. Note: bulk import isn't supported — you select one Chat project at a time.

3. Use an existing folder — Select a local folder you already have and build the project around it. Claude gains access to the files inside and you layer in instructions and scheduled tasks on top.

A few setup decisions that matter:

• Be specific with instructions upfront. The instructions you write on day one shape every task that follows. Vague instructions ("be helpful") produce inconsistent results. Specific ones ("when producing reports, use H2 headings for each section, keep summaries under 150 words, and always include a sources list") produce predictable, usable outputs.

• Start with one context source. It's tempting to link a folder, a Chat project, and three URLs all at once. Start with the one that covers the core of what Claude needs. You can add more as you learn what's missing.

• Enable memory and test it. Run a couple of tasks, then open a new task and ask Claude to summarize what it knows about this project. Check whether the memory is accurate. This reveals early if there are gaps worth correcting in your instructions or context.

5. Limitations (What it Can’t Do Yet)

Desktop-only, no cloud sync. Projects live locally on your machine. If you switch computers, your projects don't follow you. There's no cloud sync at this point.

Not shareable, even on Team or Enterprise. Cowork projects can't be shared with teammates. Each user's projects are their own. On Team and Enterprise plans, this is a meaningful limitation for collaborative workflows — it means projects are a personal productivity tool, not a team coordination layer.

Excluded from audit logs and compliance. Cowork activity (including projects) is not captured in Audit Logs, the Compliance API, or data exports. This makes Cowork unsuitable for regulated work where activity tracking is required.

Windows ARM64 not supported. Cowork requires Claude Desktop on macOS or Windows x64. Windows ARM64 is not currently supported.

Memory is not the same as a searchable archive. The memory in Cowork projects helps Claude maintain context across tasks, but it's not a structured database you can query. For complex knowledge retrieval across hundreds of documents, pair projects with well-organized local folders rather than relying on memory alone.

Paid plans only. Projects require Pro, Max, Team, or Enterprise. The feature is not available on free accounts.

6. FAQs

Can I have multiple projects running at the same time? Yes. You can create as many projects as you need. Each runs independently and memory stays scoped to each project. There's no cross-project bleed.

What's the difference between a Cowork Project and a Claude Chat Project? Chat Projects live in Claude.ai and work within your browser-based conversations. Cowork Projects live in Claude Desktop and are built for agentic task execution — file creation, automation, scheduled runs, multi-step workflows. You can link a Chat Project to a Cowork Project to pull in its knowledge base, but they're separate systems.

If I import a Chat project, do changes in one sync to the other? No. Importing copies the files and instructions from the Chat project into a new Cowork project at the time of import. Changes after that point are independent — there's no ongoing sync.

Does memory carry over when I create a new task in the same project? Yes. Memory is scoped to the project and persists across sessions. This is one of the key differences between using Projects and running standalone Cowork tasks.

Can scheduled tasks access the project's memory and context? Yes. Scheduled tasks that run inside a project inherit the project's instructions, context sources, and memory. This is what makes scheduled tasks genuinely useful for recurring project work rather than just repeated one-offs.

What happens to a project if I delete the local folder it's connected to? The project itself won't be deleted, but Claude won't be able to access the files it previously referenced. The instructions and memory remain, but tasks that depend on the folder content will lose their data source. Always maintain the folder structure your projects depend on.

Can I use a project if I'm on a Pro plan? Yes. Projects are available on all paid plans: Pro, Max, Team, and Enterprise. Usage still counts against your plan's allocation — more so for complex multi-step tasks than for simpler ones.

Is there a limit to how many files I can add to a project's local folder? The folder size is limited by your local machine, not by Claude. Claude's ability to process across many files at once is constrained by its context window, so very large folders benefit from good internal organization so Claude can navigate them efficiently.