Claude Cowork vs Claude Code: The Real Split (2026)

Anthropic built Claude Code and Claude Cowork on the same agent, then split them by job: Code is a terminal tool for developers, Cowork is a desktop-first app for everyone else. Neither is sold separately. Both come with any paid Claude plan, so entry is $20/month Pro and Max runs $100–$200/month. The catch worth leading with is quota: agentic tasks eat plan usage far faster than ordinary chat, and both tools draw from the same pool as your chat window. We have not tested Cowork, and we say so throughout. What we have done is measure per-token coding cost on real executed tasks — Claude Opus 4.8 at $4.05 per 1,000 tasks and Claude Sonnet 5 at $1.67, both 9/9 — which lets us put a number on the question nobody else answers: at what monthly volume does a flat subscription actually beat paying per token?

What each one is actually for

Cowork and Code are not two products competing for the same user. They are one agent architecture pointed at two different jobs. Both plan a multi-step task, take actions, and check their own work. What differs is the surface they run on and the kind of output they are built to produce.

Claude Code is a command-line tool for developers. It reads a whole codebase, plans changes across many files, runs commands, executes a test suite, reads the failures, iterates until the tests pass, and commits through git. That loop — edit, run, read the failure, edit again — is the thing it exists for.

Claude Cowork is a desktop-first agent aimed at everyone who is not a developer. You point it at a folder, describe an outcome, and it returns a finished deliverable: a synthesised document, extracted data, an organised set of files. It can open code files — they are just files — but it is not built to run your test suite, read the failure, and commit the fix the way Code is.

Cowork vs Code, side by side

The autocomplete cluster around “claude cowork” is mostly people asking the same five questions: which platform, does it do skills, does it do plugins, does it touch GitHub, and how is it different from Code. Here they are in one table. Every row is vendor-documented or from comparison coverage as of July 2026, not from a test we ran.

Two rows deserve a caveat. First, the surface row is a moving target. VentureBeat reported the launch as a macOS-only research preview restricted to Max subscribers; Anthropic's own help centre, checked July 2026, lists Cowork on the desktop app for macOS and Windows, plus a beta on the web and on iOS and Android that is rolling out from the Max plan outward. Anything you read about “Cowork for Windows” being unavailable predates the current state — check the help centre before planning around it. Second, the skills story is the same standard on both sides, packaged differently; the mechanics of authoring one are in our Claude Code skills write-up, and the protocol-versus-procedure question is in MCP vs Agent Skills.

People also compare Cowork to open-source desktop agents. That is a different axis — hosted convenience against a local, inspectable loop — and we cover the open side in OpenClaw.

Price identical, burn rate not

There is no Cowork price and no Claude Code price. Both are bundled into any paid Claude plan. Pro is $20/month. Max is $100/month or $200/month. Team and Enterprise plans include them too. Neither tool is sold on its own, so “which is cheaper” is not a real question — you buy one pool of usage and both tools drink from it, alongside your ordinary chat.

The practical catch is that agentic work drains that pool much faster than chat. A chat turn is one request. A Cowork task is a plan, a series of tool calls, file reads, retries and a self-check — many model calls for one instruction you typed. Anthropic does not publish an absolute token or message cap, and the effective limit moves with message length, attachments, conversation history and model choice. So the honest guidance is behavioural, not numeric: if you run agentic tasks daily, expect Pro limits to arrive sooner than your intuition from chat use suggests.

Claude Code has a second billing path Cowork does not: you can point it at the API and pay per token instead of drawing on the plan. That is what makes the next section possible — and it is also the seam that lets you redirect the agent at a different backend entirely, which we cover in Claude Code router.

Subscription vs per token: the crossover

This is the part nobody else runs, because it needs a measured per-task cost. A subscription is a flat fee: the more you use it, the less each task implicitly costs. Per-token API calls are the opposite: flat per task, no matter the volume. Those two lines cross somewhere. We can put the crossover on a chart because we have executed cost data for both Claude models.

Here is what we measured. Nine Python tasks, each scored by running the returned code against assertions the model never sees, temperature 0, one scored attempt per task:

Cost here is computed, not invoiced: the exact token counts the API reported multiplied by that model's list price. The run went through OpenRouter's OpenAI-compatible endpoint, deliberately not through our own gateway, so the figures do not depend on our infrastructure. Full method: our testing methodology and the coding-cost benchmark.

Divide the subscription fee by monthly task count and you get an implied per-task price. Set it against the flat per-token cost:

Highlighted cells are where the flat plan's implied per-task cost has finally dropped below at least one of the two per-token columns — Opus 4.8 first, Sonnet 5 much later. Note the last row: $100 over 60,000 tasks is $0.001667, which slips under Sonnet 5 by a hair, not by a margin worth planning around. The crossover volumes fall out of the same arithmetic:

Read this as a model, not a measurement of either product. Three things have to be said plainly:

• Our nine tasks are small. They are single-function problems capped at 4,000 output tokens. A real Claude Code session reads a repository, plans across files, runs tests and retries — far more tokens per “task” than ours. We have not measured that, so we will not invent a multiplier. But the direction is not in doubt: the closer your work is to a full agentic session, the lower the volume at which $20 flat beats per-token, and the further left every crossover on that chart moves.
• A subscription buys more than tokens. It buys the harness, the agent loop, the UI, the scheduling, the file access. Paying per token gets you the model and nothing else — you supply the loop. That is a real cost, just not one denominated in dollars per token.
• The subscription only buys Claude. Per-token, you pick the model. In the 13-model sweep this data comes from, 10 of 13 models scored 9/9, and the cheapest perfect scorer landed at $0.10 per 1,000 tasks — roughly 40x below Opus 4.8. Measured against that model rather than Claude, the per-token side stays cheaper far longer. We ran the comparison against Claude on purpose, because it is the conservative version.

If you are optimising a per-token bill rather than choosing a plan, cutting token costs in coding agents and our best coding LLM guide are the follow-ups. If you are comparing plan-style billing across vendors, credit-based AI coding pricing covers why those units are so hard to compare, and Claude API pricing has the per-token side in full.

Which one to open

The decision is not close once you name the deliverable.

Open Claude Code if the output is committed code. Multi-file refactors, migrations, making a failing suite pass, anything that ends in a diff and a commit. It is also the only one of the two with an API-billing path, so it is the one that can be metered per token.

Open Cowork if the output is a document, a dataset or a tidy folder. Synthesising a stack of PDFs, pulling structure out of unstructured files, cross-application workflows, work you would otherwise do by hand in a file manager and a word processor. No terminal required.

If you are a developer, you may well use both. Code for the repository; Cowork for the release notes, the spreadsheet and the folder full of customer emails. They share a quota, which is the only reason the choice has a cost dimension at all.

One framing to avoid: treating Cowork as “Claude Code for people who cannot code.” It runs the same agent, but the loop that makes Code useful on a codebase — run the tests, read the failure, try again, commit — is exactly what Cowork is not built around. If you want that loop, you want the terminal tool. The broader distinction between prompting a model and running an agent loop is in vibe coding vs agentic coding, and the anatomy of the loop itself in the AI agent harness.

What we did not test

Being explicit about the gaps is the point of this site, so:

• We have not run Claude Cowork. No first-party numbers on its speed, quality, quota burn or reliability appear anywhere on this page.
• We have not measured Claude Code's token consumption per real session. The crossover chart uses our nine small executed tasks as the unit, which is a floor, not a typical agentic session.
• Our benchmark measures one narrow thing. Nine executed Python tasks. It does not measure long-context reasoning, multi-file refactoring, agentic tool use or non-Python work — and the 4,000-token output ceiling can truncate a very verbose model and score it as a miss.
• Plan quota units are not public. Anthropic publishes plan prices, not an absolute cap, so no one — us included — can convert “$20/month” into a guaranteed number of Cowork tasks.

What is solid: the two per-token figures, both from the same sitting on the same harness, and the arithmetic built on top of them.

FAQ