Overview

By default, every Cowork task starts completely fresh. It doesn't remember the work you did yesterday, the corrections you gave it last week, or the preferences you've set up over months. The way you fix that is with projects. They're how Cowork carries context across tasks, holds onto what you've taught it, and gets sharper the longer you use it.

Why Projects Exist

In Chat, memory follows you across conversations automatically. In Cowork, it doesn't. Each task is built as a self-contained unit of work, so you don't want yesterday's unrelated context bleeding into today's job.

Projects are the answer. A project gives Cowork a place to hold the things that matter for a specific stream of work: who's involved, where files live, how you like outputs formatted, what corrections you've already made. Every task you run inside that project starts with that context already loaded.

The compound effect is the real point. A project on day one is fine. After a month of real use, it's something else entirely.

Cowork Projects vs Chat Projects

Conceptually they work the same way: a dedicated workspace with its own instructions and memory. There's one important difference, though. A Cowork project lives as a real folder on your computer. The instructions, the memory, the files Cowork produces, all of it sits on your disk where you can see it, open it, and edit it directly.

That matters more than it sounds. If Cowork's remembered something incorrectly, or if you want to change a piece of project instructions, you don't have to dig through a UI to find it. You can open the file in any editor and change it yourself.

Creating a Project

There are three ways to start a Cowork project.

• From scratch. A brand new project with an empty folder. Useful when the work is new, with no existing files to bring in.

• Import a Chat project. Brings your Chat project's files and instructions across to Cowork. It's a one-way copy, so changes you make in Cowork after the import won't sync back to Chat.

• Point at an existing folder. Cowork turns the folder you point at into the project. Useful when you've already got files for the work and just want to bring Cowork to them.

To create one, click Projects in the sidebar, choose New Project, give it a name, and pick the option that fits.

The Project View

The project view is your home base for everything happening inside a project. The two main areas you'll spend time in are Recents and Outputs.

Recents shows all the tasks for this project, running, completed, or waiting on your input. Each task card shows the files it's touched, and you can click any of those files to open them directly.

Outputs shows the recent files this project has produced across every task. Useful when you remember a deliverable but can't remember which task made it.

On the right side of the screen are three panels.

• Instructions is where you set the rules and context for this project.

• Scheduled Tasks lists any recurring work you've set up. (We'll cover scheduled tasks properly in a later chapter.)

• Context shows the folders Cowork can reach inside this project, and the memory it's built up from previous tasks.

The Task View

When you click into a specific task, you land in the task view. The main area is the chat itself, which reads much like a regular conversation. You can watch Cowork thinking, working, and asking you questions as it goes.

On the right are three panels scoped specifically to this task.

• Progress shows what's been done so far and what's still running.

• Working Folders shows only the folders this particular task has actually touched, even if the project has access to more.

• Context is similar to the project-level Context, but scoped down to what this specific task actually used. If you ever wonder whether a particular memory or rule was applied, this is where you check.

Writing Project Instructions

Project instructions are read at the start of every task in the project. There are two levels. Project-level instructions apply to every task across every folder. Folder-level instructions kick in only when Cowork is working inside that specific folder. Keep general rules at the project level and more specific ones where they're needed.

A few things tend to be useful to include:

• Who's involved. Names, roles, how to reach them, so "send this to Rachel" actually means something.

• Where things live. "Contracts are in the Contracts folder. Old reports are in the archive."

• Output preferences. "Drafts in Word, finals as PDF, save everything to the deliverables subfolder."

• Rules and conventions. "Metric units throughout. Cite the source for every number."

The instructions don't need to be polished. A few lines is enough. The difference good instructions make is whether Cowork comes to a task like an experienced colleague who's been across the project for months, or like a very smart intern who knows nothing about it.

Instructions also get better the longer you use the project. After a task, if you notice something you'd want done differently next time, ask Cowork what it would add to the instructions based on what you've just learned together. It'll suggest the wording, you review it and add it yourself, and the next task starts a little sharper.

How Memory Works

Memory is everything Cowork picks up about you and your work that's worth holding onto for next time. Preferences, people, corrections, one-off facts, and sometimes the full background of a client or a piece of work.

It builds up two ways. Passively, as Cowork notices things worth remembering while it works with you. And explicitly, when you tell it. That might be something simple like "remember that reports should always use metric units" or "remember that Sarah handles client approvals," or it might be a much richer addition like the full background of a project or everything about a particular client.

Either way, Cowork writes the memory to a file and pulls it back into context whenever it's relevant to a future task.

The key difference from Chat memory is that Cowork memory is scoped to the project. Memory you build up inside one project stays in that project rather than bleeding into another. Each project ends up with its own picture of how you work.

Because memory lives as real files on your computer, you can read, edit, or delete any of them yourself. The project's MEMORY.md file is the index, with a one-line summary of each memory. The full memory files sit alongside it, each one capturing when Cowork picked it up, why it matters, and how to apply it.

If a memory is wrong or out of date, you can tell Cowork to adjust or remove it, or open the file and change it directly.

Pause Here

If you've got an ongoing piece of work with files already on your computer, create a project and point it at that folder. If you don't have something obvious, start a fresh project around something you're interested in or actively learning.

Once it exists, write a few lines of instructions to give Cowork some context: who's involved, where things live, output preferences, any rules or conventions that matter. Then run a few tasks inside it. Give feedback when something's not quite right, tell Cowork to remember things that you'd want it to know next time, and let the project build up a little.

The way to get good at this is to keep reaching for projects whenever you can. The more you use one, the less you have to explain each time, until it genuinely feels like handing work to someone who's been across it for ages.

Key Takeaways

• Cowork tasks start fresh by default. Persistence comes from projects, which carry instructions, memory, and folder access across every task you run inside them.

• A Cowork project lives as a real folder on your computer. Instructions, memory, and outputs all sit on your disk where you can see and edit them directly.

• Two levels of instructions. Project-level applies everywhere; folder-level only applies inside that specific folder. Useful for keeping general rules separate from local ones.

• Memory builds passively and explicitly. Cowork picks things up as it works with you, and you can tell it to remember anything directly. Each memory is a real file inside the project.

• Projects compound. Good instructions, the right files, and accumulated memory turn a fresh-out-the-box project into something that handles tasks like an experienced colleague rather than a smart but new one.