What is Claude Cowork?

If you have used Claude CodeClaude Code is Anthropic's terminal-based coding agent. It reads your codebase, writes code, runs commands, and ships changes autonomously. you already know the pattern: give Claude a goal, let it read and act, check what it did. Cowork applies the same idea to a wider range of work, wraps it in a visual interface inside Claude Desktop, and removes the terminal entirely.

The short version. Claude Code is for engineers who want an agent in their terminal writing software. Cowork is for anyone who wants to hand Claude a chunk of knowledge work and come back when it is done. If you are weighing the two, Claude Cowork or Claude Code: which to reach for compares them side by side.

What is Claude Cowork?

Cowork is a tab inside the Claude Desktop application. You do not install anything separately. Open Desktop, switch to the Cowork tab, and you have an agent that can:

• Read and write files in folders you explicitly grant it access to
• Run scheduled routines (nightly, weekly, or on a webhook trigger)
• Connect to external services through Deep Connectors, including Google Drive, Gmail, DocuSign, and FactSet
• Run either locally (laptop must stay awake) or on Anthropic's cloud (laptop can be closed)

It runs in an isolated environment. Anthropic describes this as a virtual machine that is separated from the wider internet, which is intentionally more constrained than Claude Code's open terminal access.

Cowork shipped as part of Anthropic's early-2026 product push. Routines (the scheduled-task layer) reached general availability on April 9, 2026, and are included on every paid Claude plan from Pro upward.

How is Cowork different from Claude Code?

The clearest way to see the difference is to look at the interaction model.

With interactive Claude Code you and Claude go back and forth. You type a request, Claude edits a file or runs a command, you see the result, you steer again. The loop is tight and you are in it the whole time. That is exactly what you want when you are debugging, when the scope is unclear, or when you need to review each step before the next one runs.

Cowork is designed for the opposite situation. You write a complete brief, hand it off, do something else, and review the finished output. The agent carries the whole task without asking you questions mid-way.

The brief-run-review loop matters because it changes what you have to do. In a pairing session you spend time in the agent's rhythm. In a Cowork session you spend time on the brief up front and on the review at the end. The middle is handled.

What kind of work is Cowork good for?

The tasks that fit best share a few traits: the inputs are well-defined, the output is clear, and you do not need to make judgment calls mid-task. Examples from teams using it in production:

Code migrations at scale. Spotify reported a 90% reduction in engineering time for migrations and more than 650 AI-generated code changes shipped per month. The pattern: write a brief that describes the before state, the after state, and the rules. Cowork works through the files.

Research synthesis. Point Cowork at a Drive folder of market research, brief it to pull out themes and contradictions, and get a structured document back.

Document drafting from live data. Connect Gmail and Drive through Deep Connectors, brief Cowork to draft a status update from the last week of email threads and project files, review the draft.

Nightly or weekly routines. A Routine fires on a schedule. You set it once. Cowork runs the task (generate a weekly metrics digest, triage new issues, check for flagged clauses in contracts) and the result is waiting when you arrive.

Work that does not fit Cowork well: anything that requires back-and-forth judgment, real-time debugging where you need to see intermediate state, or tasks where the brief itself is unclear and you expect to discover the shape of the work as you go. For those, interactive Claude Code or plain Claude is the right tool. The when to use Claude Cowork, and when not to guide draws the line in detail.

How do I write a brief that works?

A brief is a message, but the quality of the brief controls the quality of the output. The agent will not interrupt to ask clarifying questions, so front-load the context it would otherwise ask for. For a full walkthrough, see how to brief Claude Cowork for good results.Common gotchaThe common trap is briefing Cowork the way you would prompt a chat window, then walking away. In chat you fill gaps through follow-up turns, but Cowork runs straight to completion on its first read, so a missing constraint becomes a confidently wrong finished document you only catch at review, after the time is already spent.Treat the brief as a one-shot spec: state the output format, the audience, and the failure cases up front, since you get no second turn before it commits.

A weak brief:

A brief that gives Cowork what it needs:

The pattern is: goal · inputs · output format · audience or constraints · anything to watch out for. You are not writing a prompt for a chat window. You are writing a spec for an agent that will run to completion without you.

Routines: the scheduled layer

Routines are Cowork's scheduling system. You write a brief once and attach a schedule to it. The routine fires on that schedule, runs the brief, and surfaces the result.

# Weekly digest routine
 
Schedule: Every Monday 07:00 local time
Brief: Check /projects for any file modified in the last 7 days.
       Write a plain-English summary of what changed and why it matters.
       Save to /digests/YYYY-MM-DD.md.
       Flag any file over 300 lines as a note at the bottom.

If you set the routine to run remotely, it runs on Anthropic infrastructure. Your laptop does not need to be on. If you set it to run locally, the laptop must be awake when the schedule fires.Common gotchaA nightly routine left on "local" silently does nothing if your laptop sleeps or is closed at the trigger time, and you arrive to no output and no error.For any scheduled task you will not babysit, set it to run remotely so it fires on Anthropic's infrastructure regardless of your machine.

Routines are available on Pro ($20/month) and above. Enterprise plans add webhook triggers so a routine can fire from an external event rather than a fixed schedule.

The connector layer

Deep ConnectorsDeep Connectors are Cowork's integrations with external services. They let Cowork navigate and act inside those services, not just read exported files. extend what Cowork can reach. The current set includes Google Drive, Gmail, DocuSign, and FactSet. When a connector is active, Cowork can move around inside that service on its own as part of executing a brief. It can search Drive, read threads in Gmail, pull financial data from FactSet, or flag clauses in DocuSign documents.

You grant connector access explicitly in Desktop settings. Nothing is connected by default.

Is Cowork secure?

Cowork runs in an isolated virtual machine. It cannot reach the wider internet unless a Deep Connector explicitly provides that path. You control which folders and connectors it can touch.

Claude Code, by comparison, has open terminal access and can run arbitrary commands. That power is exactly why developers want it, and exactly why Cowork takes the more constrained approach for general knowledge work where the blast radius of a mistake is harder to predict.

When to reach for each tool

A practical starting point

If you have not used Cowork yet, the fastest way to understand it is to pick one piece of recurring work you do manually and write a brief for it. Something that takes you 20 minutes and follows the same pattern every time. A meeting prep document, a weekly changelog, a sweep of flagged items in a shared folder.

Write the brief in as much detail as you would give a capable colleague who cannot ask you questions. Run it. Review the output. Refine the brief once. After two or three iterations most briefs stabilise and you can attach a Routine schedule and stop thinking about the task entirely.

That is what Cowork is for. Not to pair with you. To take the work away and bring back something finished.

For related context on how Claude Code handles its own autonomous loops, see the Claude Code Workflows guide.