Anthropic now gives you three ways to put Claude to work, and the names make them sound like competitors fighting for the same job. They are not. Claude, Claude Code, and Cowork run on the same model and the same underlying engine. What differs is who each one is for, where it runs, and how much of the work it does without you.
Here is the fastest way to hold all three in your head:
Claude is the chat app. Use it to think, draft, and analyse with your hands on every step.
Claude Code is the developer agent. Use it for codebases, git, and the terminal. It plans and executes, you review the changes.
Cowork is the agent for everyone else. Use it for documents, data, files, and repeatable business work, with no command line involved.
One engine, three doors. Pick the wrong door and you either over-complicate a simple task or hand serious work to a tool that was not built to carry it. This guide covers what each one is, when to reach for which, what they cost in 2026, and the token-usage catch that surprises people after they choose.
What is the difference between Claude, Claude Code, and Cowork?
They share a brain and differ in their hands. All three are powered by Anthropic's current Claude models, and Claude Code and Cowork are built on the same agentic architecture. Anthropic actually built Cowork using Claude Code, so the two agents can plan a multi-step task, take action, and check their own work in the same way. The reasoning is identical across all three.
What changes is what each one can touch. Claude the app answers you turn by turn and hands you text. Claude Code and Cowork can read your files, run steps on your machine or in the cloud, and return a finished result. Between those two agents, the split is audience: Code lives in the terminal and IDE for people who write software, while Cowork lives in the Claude app for people who do knowledge work and do not want a command line.
The useful mental model is not three rival products. It is one capability behind three doors, each sized for a different worker and a different kind of task.
Claude vs Claude Code vs Cowork at a glance
Claude | Claude Code | Cowork | |
|---|---|---|---|
Best for | Thinking, drafting, analysis | Codebases, git, terminal work | Documents, data, file and business workflows |
Who it is for | Everyone | Developers | Non-developers doing knowledge work |
Where it runs | Web, desktop, mobile | Terminal, VS Code, JetBrains, desktop, web | Claude app on desktop, web, and mobile |
How you work | Turn by turn, you guide each step | Set a goal, it plans and executes, you approve | Describe an outcome, it returns finished work |
Acts on your files | No, returns text only | Yes, reads and edits code, runs commands, manages git | Yes, reads, edits, and creates files you grant access to |
Setup | None, just sign in | Node.js, a Claude account, a git workflow | Install the app or open the web version, grant access |
Included in | Free and all paid plans | Paid plans | Every paid plan from Pro up |
Details and current pricing are in the pricing section below.
Key takeaways
They are not competitors. All three run on the same Claude models. Choosing between them is about matching the tool to the task, not picking a winner.
The dividing line is autonomy. Claude hands you words. Claude Code and Cowork act on your files and finish tasks on their own, which is what makes them powerful and what makes them worth governing.
Code is for developers, Cowork is for everyone else. Both are the same agent underneath. The difference is a terminal versus a plain-language app.
They share one subscription and one usage pool. Heavy use of one reduces what is left for the others, so plan tier matters more than it looks.
Cowork burns tokens fast. A single autonomous Cowork task can use far more of your allowance than a normal chat, which is why Pro users hit limits quickly and daily users move to Max.
Cowork is no longer desktop-only. As of July 2026 it runs on web and mobile with cloud sessions that keep working after you close your laptop.
Claude: the app for thinking
Claude is the product most people meet first, the chat app on web, desktop, and mobile. You ask, it answers. Paste in a contract and ask what is risky, sketch a strategy and have it pressure-tested, draft an email, or think through a hard decision out loud. In plain chat, Claude does not reach into your files or run anything on your computer. It produces reasoning and text, and you decide what to do with it.
That limit is the feature. Because Claude the app keeps you in the loop on every turn, it is the right tool when judgment matters more than execution and when the output is a piece of thinking rather than a changed file. It also needs no setup at all. What you get out of it depends on the quality of your prompt and the context you give it, not on any configuration.
Use Claude when you want a draft, an analysis, a second opinion, or a plan, and you intend to review and shape every step yourself. If the job is to think, this is the door.
Claude Code: the agent for developers
Claude Code is Anthropic's agentic coding tool. It runs in the terminal, with native extensions for VS Code and JetBrains, a desktop app, a browser version, and a way to tag it directly on GitHub. Wherever you launch it, the pattern is the same. You describe what you want in plain language, and Claude Code reads your codebase, plans the change, edits files across the project, runs commands and tests, and can stage commits, open branches, and raise pull requests. It can run inside your CI pipeline through GitHub Actions or GitLab, and it connects to outside systems like Jira, Slack, and Google Drive through the Model Context Protocol.
Getting started is light if you are a developer: Node.js and a Claude account are the core requirements. The features that matter at scale are the ones that keep the autonomy in check. Plan Mode lets Claude propose an approach before it changes anything. Checkpoints let you roll back. Sub-agents let you split a large task across focused workers. A CLAUDE.md file in your project root gives it the standing rules and context to follow every session.
The trade-offs are worth stating plainly. Claude Code is genuinely autonomous, which means it can make big changes fast. That is an advantage right up to the moment it is a liability. Real use depends on a disciplined git workflow, a habit of reviewing every diff before it merges, and a clear understanding that the engineer stays responsible for whatever ships. Token costs also add up on large or continuous work, so it rewards teams that scope tasks tightly.
Use Claude Code when the work touches a codebase, git, or the terminal, and you are comfortable reviewing changes the way an engineer would. If the job is to build or change software, this is the door.
Cowork: the agent for everyone else
Cowork exists because of a pattern Anthropic noticed: non-developers kept reaching for Claude Code, and developers kept using it for work that had nothing to do with code. People wanted the agent, not the terminal. Cowork is the answer. It lives inside the Claude app as its own tab, alongside Chat and Code, and it brings the same agentic engine to knowledge work through a plain-language, graphical interface.
The workflow is easy to describe. You point Cowork at a folder, describe the outcome you want, and it plans and runs the steps to get there, handing back a finished deliverable rather than instructions. Fill an expense report from a folder of receipt photos. Turn a stack of notes into a first-draft report. Reorganise a messy directory. Pull a folder of interview transcripts into a themed summary. Build a spreadsheet and a dashboard from raw data. It reads, edits, and creates files in the folders you grant it, and it extends its reach through plugins and connectors over the same Model Context Protocol that Claude Code uses, including Google Workspace, Microsoft 365, Slack, and Jira.
Cowork has moved fast. It launched on macOS in January 2026, reached Windows in February, went generally available in April, and expanded to web and mobile on July 7, 2026. That last step matters more than it sounds. The new web and mobile surfaces can run remote sessions on Anthropic's servers, which means a long or scheduled task keeps going after you close your laptop. The older desktop model, where the app had to stay open for a task to run, is no longer the only option.
Use Cowork when the work is real digital labour, documents, data, files, and repeatable workflows, and you want the result done rather than described, without touching a command line. If the job is to operate, this is the door.
One important safety note
Cowork can read, edit, and permanently delete files in the folders you give it. That power is the point, and it is also a real risk. There are documented cases of users losing data to a misjudged instruction. Treat folder access the way you would treat handing a new hire the keys to a filing cabinet: point Cowork at a dedicated folder of non-sensitive files, keep backups of anything important, and do not grant access to credentials, financial records, or irreplaceable documents until you trust how it behaves.
How to decide which one to use in two questions
Most cases resolve with two questions.
1. Does the work touch a codebase, git, or the terminal?
If yes, it is software work, and the answer is Claude Code. If no, move to the second question.
2. Do you want Claude to do the task on your files, or help you think it through?
If you want the task done and a finished file returned, use Cowork. If you want to draft, analyse, or decide with your hands on every step, use Claude the app.
That is the whole tree. Software work goes to Code. Knowledge work that needs doing goes to Cowork. Thinking work stays in Claude.
When to use which: real scenarios
The decision tree handles clean cases. Real work is messier, so here is how the three map onto concrete jobs.
Reach for Claude when the output is judgment. Pressure-testing a go-to-market plan, drafting a sensitive message, summarising a long document and then arguing with the summary, or working through an architecture trade-off before anyone writes code. The deliverable is a better decision or a cleaner draft, and you want your hands on every turn.
Reach for Claude Code when the output is software. Implementing a feature end to end with tests, refactoring a legacy service across dozens of files, tracing a subtle bug through connected modules, standardising documentation across a repository, or automating release notes in CI. The deliverable is committed code, and the reviewer is an engineer.
Reach for Cowork when the output is operational work. Building a formatted report from a folder of notes, turning a spreadsheet into an executive deck, running a competitor analysis into a PDF, cleaning and structuring a pile of data, or standing up a recurring task that produces the same artifact every week. The deliverable is a finished business document or a completed workflow, and the reviewer is whoever owns the process.
The strongest teams use all three on one project. A product team might think through the design in Claude, build the implementation in Claude Code, and run the surrounding operational work, the launch brief, the data pulls, the recurring reports, in Cowork. The tools do not replace each other. They cover different stretches of the same road.
What do Claude, Claude Code, and Cowork cost in 2026?
This is the part most comparisons leave out, and it is the one people most want answered. Here is the current picture, verified July 2026. Anthropic changes plans and limits often, so confirm on the official pricing page before committing a team.
The most important fact is that all three share one subscription and one usage pool. Cowork and Claude Code are not sold separately. They are capabilities included in your Claude plan, and heavy use of one draws down what is left for the others.
Plan | Monthly price | Claude app | Claude Code | Cowork |
|---|---|---|---|---|
Free | $0 | Yes, limited | No | No |
Pro | ~$20 (~$17 billed annually) | Yes | Yes | Yes |
Max 5x | ~$100 | Yes | Yes | Yes |
Max 20x | ~$200 | Yes | Yes | Yes |
Team | Per seat | Yes | Yes | Yes |
Enterprise | Custom | Yes | Yes | Yes |
A few things worth knowing before you pick a tier:
The free plan gives you the chat app only. There is no free Cowork and no permanent free Claude Code tier. To use either agent, you need a paid plan starting at Pro.
Cowork tasks are expensive in tokens. A single autonomous Cowork run that browses, drafts a spreadsheet, and edits files consumes far more of your allowance than a normal chat, by a wide margin. Pro gives you real headroom over Free, but if you run Cowork every day you will hit its limits quickly, which is why daily operators tend to treat Max 5x as the realistic floor rather than the premium option.
Every paid tier runs the full product. Pro, Max 5x, and Max 20x are not feature-tiered. They all run complete Cowork and Claude Code. What separates them is usage allowance, so you are buying headroom, not capability.
The part most comparisons skip: autonomy is the real decision
Most comparisons stop at a feature table. They tell you Claude needs no setup, Cowork wants you to install an app and grant folder access, and Claude Code expects Node.js and a git workflow. All true, and all the easy part.
The hard part starts the moment any of these tools can act without a human between every step. Claude the app cannot do much damage, because it only ever hands you words. Claude Code and Cowork are different. They change files, run commands, and finish tasks on their own. That is exactly why they are useful, and exactly why an organisation cannot treat them as a personal productivity download and walk away.
Once a tool can act, the question stops being which tool and becomes how do we govern what it does. For an individual that means the folder discipline described earlier and a habit of reviewing output. For a team it means something more deliberate: a shared source of context so agents do not improvise, a defined boundary between decisions an agent may make alone and decisions that come back to a person, and review gates at the points where a mistake would be expensive.
None of that is exotic, and none of it depends on which surface the agent runs in. The boundaries are the same whether Claude Code is editing a repository or Cowork is building a report. Choosing between the three is a five-minute decision. Deciding how much you let them do on their own is the decision that determines whether they are an advantage or a liability.
What about Claude Tag and the other surfaces?
Three doors is the useful simplification, but Anthropic has quietly added more ways in, and they matter if you are mapping the full picture.
Claude Tag lets you delegate work to Claude directly inside Slack by tagging it on a message, aimed at teams that want to hand off a task without leaving their chat tool. It launched in mid-2026 for Team and Enterprise plans.
Cowork on web and mobile is now its own answer to "can I use the agent without the desktop app." Since July 2026 you can start a Cowork task from a browser or your phone, and cloud remote sessions keep long or scheduled work running with every device closed.
Claude Code across surfaces has similarly spread beyond the terminal into the desktop app, the browser, and GitHub, so "developer tool" no longer means "command line only."
The pattern behind all of it is the same. Anthropic is exposing one agentic engine through as many doors as there are kinds of worker and places they work. The three in this guide are the ones almost everyone needs to understand first, and the rest are variations on where those same capabilities show up.
The bottom line
Claude, Claude Code, and Cowork are not three products competing for the same job. They are one engine behind three doors, each sized for a different worker and a different kind of task. Use Claude to think, Claude Code to build, and Cowork to operate. When a job crosses all three, use all three, because a single subscription covers the lot.
The choice itself takes about five minutes once you know the pattern. What takes real attention is everything that follows the choice: the token budget you will actually need if you lean on the agents daily, the folders you let Cowork touch, and the review habits that keep autonomous work trustworthy. Get those right and these tools do exactly what they promise. Skip them and the same autonomy that makes the agents valuable is what turns a small mistake into an expensive one.