Anthropic is launching Claude Cowork on mobile and web

Last Tuesday I watched one of our data engineers kick off a three-hour data-cleaning job from her phone while boarding a flight, then land to find a Slack-style thread of completed subtasks waiting for her. That workflow — an agent that runs long, checks in, and doesn’t need you glued to a laptop — is the whole pitch behind Claude Cowork, and it’s why I think this launch matters more than another chat UI refresh.

What actually shipped

Claude Cowork is Anthropic’s agentic workspace, now available on both mobile and web. The core idea: instead of a single-turn chat where you paste context and get an answer, Cowork is built around long-running, asynchronous tasks. You hand it a goal, it plans, executes across multiple steps, uses tools, and reports back — even when you’ve closed the tab or pocketed your phone.

The headline shift is the interaction model:

• Persistent tasks that survive you leaving the session
• Mobile parity — you can start, monitor, and steer work from a phone, not just review it
• Multi-step tool use as a first-class feature, not a bolted-on function-calling demo
• Human-in-the-loop checkpoints where the agent pauses for approval before consequential actions

If you’ve used Claude’s coding agent or the desktop app’s file-and-terminal access, Cowork is that same agentic backbone repackaged for general knowledge work — spreadsheets, research, document generation, multi-tool orchestration — and, critically, made portable.

A gotcha worth flagging up front: “runs while you’re away” and “runs unattended safely” are not the same claim. In practice, long agentic runs still drift. The checkpoint model exists precisely because letting an agent execute 40 tool calls without review is how you end up with a beautifully-formatted report built on a wrong assumption from step three.

Why a developer should care

You might reasonably ask: I use the API, why do I care about a consumer-facing app?

Two reasons.

First, Cowork is a live spec for what Anthropic thinks agents should do. The product surfaces the patterns they’ve invested in — task persistence, structured checkpoints, tool orchestration — and those patterns tend to show up as API primitives shortly after. When the desktop agent normalized file/terminal tool use, the API tool-use ergonomics matured alongside it. Watching Cowork tells you where the SDK is heading.

Second, it resets user expectations. Once your users have experienced an assistant that runs a 20-minute task and pings them when done, your synchronous request/response app feels broken by comparison. The bar for “agentic” is now asynchronous by default.

Here’s the shape of what you’d build to match it, at the API level:

import anthropic

client = anthropic.Anthropic()

# A long-running task loop — this is what Cowork abstracts away
def run_agent(goal, tools, max_steps=25):
    messages = [{"role": "user", "content": goal}]
    for step in range(max_steps):
        resp = client.messages.create(
            model="claude-opus-4.8",
            max_tokens=4096,
            tools=tools,
            messages=messages,
        )
        messages.append({"role": "assistant", "content": resp.content})

        if resp.stop_reason != "tool_use":
            return resp  # done

        # checkpoint: gate risky tools behind human approval
        tool_results = execute_tools(resp.content, require_approval=True)
        messages.append({"role": "user", "content": tool_results})

The require_approval gate is the single most important line for anyone shipping this to production. A 25-step loop against Opus is easy to write and expensive to run unsupervised.

The cost math nobody shows you

Long-running agents multiply token spend in a way single-turn apps don’t, because the full conversation replays on every step. Say each step adds ~2K tokens of tool output and you accumulate context:

Across 25 steps you might burn ~600K–700K input tokens for one task, because early context is re-sent every turn. On a premium model that adds up fast. This is exactly where model routing pays off: you don’t run all 25 steps on Opus.

How the models stack up for agentic work

The right Cowork-style workload isn’t one model — it’s a routing decision. Here’s how I actually assign work:

In practice, my default Cowork-equivalent loop uses Opus 4.8 for the planning step and final report, Sonnet 4.6 for the bulk of intermediate tool calls, and Haiku 4.5 for cheap deterministic steps like “does this row need cleaning: yes/no.” That mix cuts cost dramatically versus running Opus end-to-end without meaningfully hurting output quality — the intermediate steps rarely need frontier reasoning.

Fable 5’s 1M context deserves a specific note. It’s tempting to treat a huge context window as a replacement for orchestration — just dump everything in. What actually happens is your per-step cost balloons and recall gets uneven in the middle of very long inputs. Big context is a tool for ingestion (read this entire codebase once), not a license to skip retrieval and summarization.

Since these routing setups mean you’re calling several models across providers, this is where routing your traffic through AI Prime Tech earns its keep — you get cheaper access to Claude, GPT, and Gemini endpoints behind one billing surface, which makes multi-model agent loops far less painful to reconcile at month’s end.

The honest limitations

Cowork is genuinely useful, but let me be clear about what I’d verify before betting a workflow on it:

• Async ≠ reliable. Longer runs mean more places to silently go wrong. Checkpoints help; they don’t eliminate the problem.
• Cost opacity. A consumer app hides token spend behind a subscription. When you rebuild the same pattern on the API, that multi-step token replay is your bill, and it’s easy to underestimate by 3–5x.
• Mobile steering is thin. Approving a checkpoint on a phone is fine. Diagnosing why an agent went sideways from a phone is not — you’ll still reach for a laptop when things break.
• Tool surface matters more than the model. The magic in Cowork is less the base model and more which tools it can reach and how well they’re wired. Your homegrown version lives or dies on your tool definitions, not your model choice.

Practical takeaways

• Treat Cowork as a roadmap signal. The patterns it productizes — task persistence, human checkpoints, multi-tool loops — are what you should build toward on the API.
• Route, don’t default. Opus 4.8 for planning and synthesis, Sonnet 4.6 for the bulk of steps, Haiku 4.5 for cheap classification. Reserve Fable 5’s 1M window for genuine large-ingestion needs, not as an excuse to skip retrieval.
• Budget for token replay. A 25-step agent can consume 600K+ input tokens on a single task. Model your worst-case loop before shipping, not after the invoice.
• Gate consequential actions. require_approval on write/spend/delete operations is non-negotiable for unattended runs.
• Consolidate your multi-model billing. If you’re mixing Claude, GPT, and Gemini in one agent, cheaper unified API access through AI Prime Tech keeps both the cost and the accounting sane.

The interesting part of Cowork isn’t that Claude can now run tasks while you’re on a plane. It’s that “asynchronous, multi-step, checkpointed” just became the baseline expectation — and if you’re building on the API, that baseline is now yours to hit too.