Cowork is a badly chosen name. What clients hear is "coworker," and they picture a collaborator: Claude in the passenger seat, working turn by turn. What they get is a delegate that takes a task, disappears into their files for twenty minutes, and returns with a finished deck.
The collaborative reading fits Chat, so the name points at the wrong product. The mishearing is the first of three confusions in every rollout: Chat versus Cowork, which model family, and how much effort the model spends. Teams read three separate decisions as one dial labeled "make it better."
Most workflow failures are none of the three. A connector that silently returns nothing, a skill that under-specifies the output, or a prompt that never mentioned the key constraint will sink the run no matter what you set. That is the configuration gap, and the dials matter only once it is closed.
Three dials, three different questions
Chat versus Cowork is a question about who does the work. In Chat, you steer every step and assemble the output yourself. In Cowork, Claude plans the task, works through your files and apps on its own, and hands you a finished document, spreadsheet, or deck.
Model family is a question about whether the model can do it at all. The lineup runs Haiku, Sonnet, Opus, and now Fable, in ascending capability. Moving up buys a higher ceiling on the hardest single judgment inside the task.
Effort is a question about how hard the model tries on a given attempt. A setting in the apps and an API parameter, it scales how many tokens the model spends on an answer, thinking and tool calls included. Same model, different level of diligence.
The dials spend differently. Effort changes how many tokens a task consumes at an unchanged per-token rate; Anthropic publishes no percentages, so the level-to-level savings are real but unquantified. Family changes the rate itself: on current API pricing, Sonnet is twice Haiku's price, Opus is two and a half times Sonnet's, and Fable is twice Opus's, 10x end to end.
Cowork multiplies volume hardest, because an agent loop makes dozens of model calls and sometimes spawns parallel subagents. Anthropic quantifies none of that, only warning that Cowork consumes usage faster than Chat. All three dials drain the same usage pool on subscriptions, or the bill on the API.
The dials also interact, in the opposite direction from intuition. When Anthropic launched Opus 4.5, it reported the model matching Sonnet 4.5's best SWE-bench score at medium effort while using 76 percent fewer output tokens, and at a 2 to 2.5x rate gap, the stronger family pays for itself whenever it needs 50 to 60 percent fewer tokens. A family up at lower effort can cost less than a family down working at its hardest.
Diagnose from the failure, not the task
Most model advice online is a task-type chart: Sonnet for daily work, Opus for hard problems, Haiku for simple ones. Those charts fail because the same task can break four different ways, and the failure, not the task description, tells you which dial to turn.
Rule out configuration first, because it produces the most convincing impostor: a broken connector or an under-written skill also fails identically on every retry. Read the run and check whether the model ever had what it needed, because an empty tool result or a vague instruction means you fix the workflow and touch no dial.
If the model had everything it needed and the output is still wrong the same way on every retry, with an error that is conceptual rather than careless, you have a family problem. The model is at its ceiling, and no amount of effort fixes a judgment it cannot make.
If the output is right sometimes and sloppy other times, with a skipped step or a missed edge case it clearly could have caught, you have an effort problem. Effort buys reliability and search depth on problems the model already solves at its best. It cannot raise the ceiling, but it reaches it more often.
And if the output is fine but a person spent forty minutes pasting files into Chat and stitching deliverables together afterward, you have a Cowork problem. Nothing about model quality was wrong. The cost was human assembly labor, and neither a bigger model nor more effort refunds it.
The Cowork problem has a second, quieter version. Chat is not blind, it can search the web or a connected drive mid-reply, but that is a lookup, not a sweep, and it cannot open the folder where the real material lives. What the model sees of your own files is still whatever a person remembers to attach.
So a wrong answer can be nothing more than a missing file. That is the context-starved miss, and the cure is not a better model but the mode that goes and gets the file.
A conceptual miss, a sloppy miss, and a context-starved miss arrive looking identical, so none of this is legible in a single output. Cowork blurs diagnosis from the other side: its agents gather context so well that outputs can improve for reasons that look like intelligence but are actually inputs.
Most tasks are one-offs, and nobody budgets an hour of reruns for one email, so climb a ladder instead of running an experiment. The ladder is the three fixes ordered by how often each one is the answer, one change per retry: repair the inputs, then raise the effort, then raise the family.
Read the run first, and if the model was missing an input, fix the prompt or the connector and go again, because most failures end there. If the inputs were clean, retry once at the next effort level up.
That retry doubles as the diagnostic. A better output means effort, or luck you will happily take; an identical conceptual miss at higher effort means a ceiling, and the next move is a family up. Cowork never needed a rerun, because its signature, a fine answer that cost someone forty minutes of assembly, is visible the first time.
Effort before family is not a claim about price, and it does not contradict the interaction above. The effort retry is the test that proves the ceiling, and when the family rung is the answer for work that repeats, the interaction is your next move: try the bigger model a level down, because the cause and the cheapest configuration are two different findings.
Repeatable workflows are the exception. A skill a team will hit two hundred times a month deserves several runs before it ships, one dial changed at a time, because a failure that reproduces exactly points at configuration or family while one that moves around points at effort. Swapping families on an identical prompt is a clean capability test, and Chat against Cowork on the same task isolates context, because both run the same models.
Autonomy raises the model bar
The ladder guards against overbuying, paying for a bigger family than the failure requires. Cowork rollouts invite the opposite mistake. A team decides the task is mundane, so they assign the cheapest model to it: filing documents, renaming folders, filling out a tracker.
That logic is backwards for long autonomous runs. In Chat, a wrong step gets caught by a human on the next turn, so per-step accuracy can be mediocre and the workflow still lands. In an autonomous run, a mistake at step 3 propagates through step 40 with nobody watching.
Error compounds with horizon length, so the case for a stronger family gets stronger as you remove the human from the loop, even when every step looks trivial. Anthropic's launch note for Fable makes the same point: the longer and more complex the task, the larger its lead over the models below it.
Effort behaves the same way in agent work: at lower effort the model makes fewer tool calls, so it checks less and verifies less. Turning effort down on a long Cowork run quietly cuts the agent's verification budget.
Effort is a calibration, not an upgrade
Effort runs five levels on the current Sonnet, Opus, and Fable models: low, medium, high, extra high (xhigh in the API), and max. Claude Code stacks one more mode on top, ultracode, which pins effort at extra high and adds automatic multi-agent orchestration.
The default on the flagship models is high, the third of five, a mid-range guess shipped because Anthropic cannot know your workload. You are allowed to correct it in either direction.
The direction turns on one question: how much better is the model's most careful pass than its first pass on this work? For long-horizon agentic runs and edge-case-heavy analysis the answer is a lot, which is what the levels above high exist for.
For well-scoped, high-volume work like classification, extraction, routing, and first-pass triage, the answer is barely at all, because a first pass already sits at the ceiling. That is where low and medium earn their keep: same answers, faster, and on the apps they stretch your usage limits further. Half the "Claude is slow and expensive" complaints I hear turn out to be a default nobody calibrated.
The Cowork question sits outside the ladder entirely. Family and effort are configuration changes, invisible to the end user and reversible by lunch. Cowork asks your team to give up per-step review and trust output they didn't watch get made.
That is an organizational decision about supervision, not a technical one. For anyone in a regulated posture, it is the real gate.
Match the dial to the failure. Read what actually went wrong, try the likeliest fix first, and save the model upgrade for errors that repeat identically no matter how hard the model tries.