Claude Cowork vs Claude Code: how to choose

What is the difference between Claude Cowork and Claude Code?

Claude Cowork and Claude Code are two Anthropic agents built for different material. Cowork works on documents and office tools, inside folders and connectors you grant it. Claude Code works on a codebase and a shell, on the machine where you start it, which can be your laptop or a VPS (virtual private server) you rent.

The short routing rule: if the deliverable is a file a colleague will open, use Cowork. If the deliverable is a commit or a running service, use Claude Code.

Every capability claim below was checked on 19 August 2026 against Anthropic's own pages: the Cowork product page, the Cowork architecture overview, the Cowork getting started guide and the Claude Code documentation. Availability, surfaces and plan gating are all moving, so check the date on any comparison you read, including this one.

Where does each one run the work?

This is the difference that drives all the others.

Cowork has two execution modes, and the architecture page describes them separately. In a local session, "the agent loop runs natively on the device". That covers conversation handling, file reads and writes in connected folders, web fetches, and local plugin MCP servers. Code execution happens inside an isolated Linux virtual machine on that same device, with network egress filtering and syscall restrictions applied to it.

In a cloud session, "the agent loop and code execution run in an isolated, temporary sandbox on Anthropic-managed infrastructure". Each session gets its own sandbox, created when the session starts and destroyed when it ends, and sandboxes share no state with each other. That sandbox cannot reach private, internal, link-local or cloud-metadata addresses, and every outbound connection passes through a proxy the sandbox cannot reconfigure or bypass, so only allow-listed destinations are reachable.

The payoff of the cloud session is that the work survives you walking away: close the laptop and the task keeps going. The cost is that the sandbox is not your machine. It has no view of your home network, your internal services or your servers, because blocking exactly that is what the egress rules are for.

Claude Code is the other shape. The command line interface (CLI) runs as an ordinary process on a machine you choose, so it inherits that machine's filesystem, its network position and its credentials.

curl -fsSL https://claude.ai/install.sh | bash
cd your-project
claude

You are prompted to log in on first use. Run those same lines inside an SSH session and Claude Code is now running on the server, with your repository and your systemd units in reach.

Claude Code also has a cloud mode, which makes the comparison less tidy and more honest. claude --cloud "fix the failing auth test" starts a session on an isolated Anthropic-managed virtual machine, and that machine clones your GitHub remote at your current branch rather than your local working copy. claude --teleport pulls the session back into your terminal with its branch and history. As of August 2026 the Claude Code web surface is documented as a research preview for Pro, Max and Team users.

What can each one touch?

Cowork touches what you connect, and nothing else. On the desktop app you grant access to specific folders, and Claude can read, write and permanently delete files inside them. Anthropic's safety guidance is direct about the consequence: make "a dedicated working folder for Claude", and keep folders holding credentials or personal records out of it.

The connectors listed on the product page cover Microsoft 365, Google Drive, Slack and Amplitude, alongside custom connectors you add yourself. That is the office surface, and it is where Cowork earns its place.

A cloud Cowork session reaches your local files by asking the desktop app on that device, over a connection Anthropic brokers. Two things follow. The reach stops at the folders that member connected. And "if the desktop app is offline, a session in the cloud can't reach the device", so a scheduled overnight task that needs a local spreadsheet finds nothing when the laptop is shut. Work that lives entirely in cloud connectors keeps running.

Claude Code touches whatever the user account running it can touch. That means the repository, and also apt, systemctl, docker, your database socket, and any host reachable from the network the server sits in. Nobody grants that folder by folder, which is the point and also the risk.

The tool that narrows it is the sandboxed Bash tool, turned on with /sandbox inside a session. It ships with Claude Code and it uses the operating system to enforce a filesystem and network boundary on every Bash command and its child processes, so Claude runs most commands without stopping to ask. It works on macOS, Linux and WSL2. Native Windows is not supported, so on Windows you run Claude Code inside a WSL2 distribution.

How do you steer a task and review the result?

Cowork is built around handing off a task and checking what comes back. You assign work through Dispatch, one ongoing thread you can reach from your phone or your desktop, and a push notification arrives when the task is done or when Claude needs your go-ahead. Claude sends you the outcome, a spreadsheet or a memo, instead of showing you every step. Progress indicators show what it is doing at each step when you want to follow along.

Approvals come in three settings, and the names are literal. Manually approve pauses for your confirmation on each action. Automatically approve lets Claude review actions for safety and block unsafe ones. Skip all approvals removes those checks, with file deletion still gated. The help centre says the plain thing, and it is worth repeating: no mode replaces your judgement, and you remain responsible for what the agent does on your behalf.

Claude Code is built around a diff. You watch it work in the terminal, you read the change it proposes, and review happens in the workflow you already have: branches and pull requests. When you want to leave the desk, Remote Control exposes a running local session for monitoring from a browser or the mobile app, which is the same pattern as steering a Claude Code session from your phone.

Scheduling exists on both sides. Cowork schedules tasks that run in the cloud, so they no longer need your computer to be awake. Claude Code splits it: routines run in the cloud, and desktop scheduled tasks run on your machine with direct access to local files.

Do connectors and plugins replace MCP servers and skills?

No, because both products stand on the same extension stack. MCP (model context protocol) is an open standard for connecting an agent to outside tools and data. Skills are packaged instructions the agent loads when they become relevant. Plugins bundle skills and connectors together, and in Cowork you manage them under Customize in the Cowork tab.

The real difference is where the server runs. Remote MCP connectors are available across Claude, Cowork and Claude Desktop. Local MCP servers are the exception: "local connectors and plugins that include local MCP servers work through the desktop app only", so a Cowork session opened on the web or on your phone will not see them.

Claude Code takes the same MCP servers and adds what a repository needs. CLAUDE.md at the project root is read at the start of every session. Hooks run shell commands before or after an action, so a formatter can run on every edit. Subagents split work into separate context windows. Those files live in the repo, so they get reviewed and versioned like code.

If you already run your own MCP servers on a VPS, the remote ones are reachable from both products, and that is the cheapest way to give Cowork access to something Anthropic does not ship a connector for. The skills layer is shared too, so a skill you write is portable, and agent skills covers the format.

What leaves your machine?

Answer this before you connect a folder.

In a Cowork cloud session, a lot leaves: "the agent's work, including any local files it opens through the desktop app, is processed on Anthropic's servers rather than staying on the device". That is the design, and it is what lets the session survive a closed laptop. A local Cowork session keeps the agent loop and the file handling on the device instead.

With Claude Code running locally, the process and the files stay on your machine or your server, and so does the command output. What travels is the context: the file contents and command output the model is asked to reason about, because the model itself runs on Anthropic's servers. Nothing about the word "local" changes that part. claude --cloud changes more, since the cloud session clones your repository into an Anthropic-managed virtual machine.

One detail matters if you work under network restrictions. Cloud sessions call the Anthropic API from Anthropic-managed infrastructure rather than from your network, so an organisation IP allowlist makes every Anthropic-hosted cloud session fail with an authentication error until Anthropic support exempts those services.

Which one should you use?

Use Cowork when the work is documents and office systems. Building a deck from a folder of research. Reconciling two spreadsheets. Drafting a briefing from Slack threads and email. Turning a folder of PDFs into a summary someone will read. These tasks run many steps, they cross several apps, and the deliverable is a file.

Use Claude Code when the work is a codebase, a terminal or a server. Fixing a failing test. Bisecting a regression. Writing a migration and running it. Working out why nginx returns 502 after a deploy. Anything where success is checked by a command you run and an output you read.

The tie-breaker is that check. If you verify the result by opening a document, Cowork fits. If you verify it by running a command, use Claude Code, because it can run the command itself and read what came back.

Cowork is available on paid plans (Pro, Max, Team and Enterprise) and runs on web, desktop and mobile, with mobile in beta and desktop builds for macOS, Windows, ChromeOS and Linux. Plan gating moves faster than anything else here, so read the current page rather than a write-up. Carry one operational note with you: Cowork consumes more usage than standard chat, because an agent that runs many steps spends many turns doing it.

If your real question is which coding agent to adopt, rather than which of these two, the comparison against Cursor, Codex and Copilot is the more useful page.

What changes when the work lives on a VPS

A VPS is where these two products stop overlapping at all. A Cowork cloud sandbox cannot reach private, internal or link-local addresses, so it cannot open an SSH connection to your server, read /var/log/nginx/error.log or restart a unit. Those blocks are deliberate, and no setting in the Cowork interface removes them. A local Cowork session runs on your own device and so sits closer to your network, but it still works through connected folders rather than hosts.

Claude Code on the server has none of those limits, which is why the safety work moves onto you. Run it as a normal user with sudo rules you chose, not as root. Keep the session inside a project directory. Turn on /sandbox so Bash commands are held to a boundary the kernel enforces. Keep credentials out of the working tree, because anything the agent reads becomes context it can repeat back. Running Claude Code safely on a VPS covers the account setup, the firewall and the persistent terminal session in detail.

The pattern that works: the server holds the repository and the services, Claude Code runs there in a terminal session that outlives your SSH connection, and you attach from wherever you are. Work continues while your laptop sleeps because the process lives on a machine that does not sleep. That is the same benefit a Cowork cloud session gives you, reached a different way, on hardware you control.

The failures you should expect

A scheduled Cowork task did nothing overnight. The desktop app was closed. A cloud session keeps running when the app goes offline, but it cannot reach the device, so any step that reads a connected folder finds nothing to read. Move the input into a connected cloud service, or leave the machine awake with the app open.

Cowork read a web page and then did something you never asked for. That is prompt injection: instructions hidden in external content that Claude reads as part of a legitimate task. The defence is a smaller blast radius. Connect one working folder instead of your home directory, and be careful with unfamiliar MCP servers and plugins.

Claude Code touched a file you did not expect. A local session has the reach of the user account that started it. Read the diff before you commit, and work on a branch you can throw away.

A cloud Claude Code session could not see your latest work. claude --cloud clones the GitHub remote at your current branch, not your local checkout, so uncommitted changes are invisible to it. Push first, then start the session.

FAQ

Can Claude Cowork edit code and run commands like Claude Code?

It can run code, since code execution happens in the sandbox in a cloud session and in an isolated Linux virtual machine in a local session. It is not built around a repository. There is no git review flow, no CLAUDE.md read at the project root, no hooks and no terminal you drive yourself. For a one-off script over a spreadsheet, Cowork is fine. For work in a codebase you maintain, Claude Code is the tool, because the review layer is git and the success check is a command.

Can Claude Cowork reach my VPS or my internal server?

A cloud session cannot. The sandbox cannot reach private, internal, link-local or cloud-metadata addresses, and all outbound traffic passes a proxy that allows only listed destinations, so an SSH connection to your VPS is not available to it. If you want an agent working on a server, install Claude Code on that server and run it there.

Do I need the Claude Desktop app to use Cowork?

For local files and local MCP servers, yes. Cowork runs on web, desktop and mobile, but a cloud session can read and write files in connected folders only while the desktop app is open on that computer. Live artifacts, browser use and local connectors are desktop features. A task that uses only cloud connectors such as Google Drive or Slack runs without the app.

Can I reuse the same skills and MCP servers in both?

Mostly. Remote MCP connectors work across Claude, Cowork and Claude Desktop, and skills are shared, so a lot of your setup is portable between them. Local MCP servers are the exception in Cowork, because they work through the desktop app only. Claude Code then adds repository-level pieces such as CLAUDE.md and hooks, which have no Cowork equivalent.