Claude Cowork Guide 2026: Desktop, Web, Mobile & Pricing

The complete July 2026 guide to Claude Cowork: what it is now, what it costs, how the local and remote sessions actually work, and how it compares to every serious alternative.

Over 90% of Claude Cowork usage is not coding. When Anthropic analyzed 1.2 million anonymized Cowork sessions from more than 600,000 organizations in May 2026, business process automation accounted for 33.4% of all usage, content creation for 16.4%, and software development for just 8.7% - TechCrunch. The coding agent wars have officially spilled into the rest of the office.

Here is the problem: almost everything written about Claude Cowork in early 2026 is now wrong. The "research preview" framing is dead. The "macOS only" limitation is dead. The "$100-$200 Max plan required" gate is dead. Cowork went from an invite-gated experiment on January 12, 2026 to generally available on macOS and Windows on April 9, and then to web, iOS, and Android with cloud-hosted remote sessions on July 7, 2026 - Anthropic. If you evaluated Cowork in January and walked away, you evaluated a different product.

This guide is a complete, honest, July 2026 rewrite. It covers exactly what Cowork does today, the full dated timeline from preview to everywhere, the local vs remote session architecture, real usage data from 1.2 million sessions, current pricing from $17/month, the plugin ecosystem, the model stack (including the extraordinary US export-control suspension of Fable 5), a security case study with receipts, and a competitive matrix that replaces the obsolete "nobody else has this" framing, because OpenAI, Microsoft, and Google very much have this now.

Contents

1. The Verdict: Autonomous Agent Platforms Scored
2. What Is Claude Cowork in July 2026?
3. Timeline: From Research Preview to Everywhere in Six Months
4. How Cowork Works: Local vs Remote Sessions
5. What 1.2 Million Real Sessions Say People Actually Do With It
6. Pricing and Usage-Limit Economics
7. The Plugin and Connector Ecosystem
8. The Model Stack: Opus 4.8, Sonnet 5, and the Fable 5 Saga
9. Cowork vs Claude Code vs Claude in Chrome
10. The Practical Delegation Playbook
11. Security: The PromptArmor Case Study and Hardening Checklist
12. The July 2026 Competitive Landscape
13. What Still Does Not Work
14. Future Outlook
15. Conclusion

1. The Verdict: Autonomous Agent Platforms Scored

Before the deep dive, here is the scored comparison of the major general-purpose autonomous agent products as of July 2026. The category has gone from one player to a crowded field in six months, so a structured comparison matters more than it did when Cowork launched. Each platform is scored 0-10 on four weighted criteria, and every cell shows the score plus the reason for it.

The four criteria reflect what actually determines whether an autonomous agent product delivers value. Autonomy and task breadth (30%) measures how much real, unattended, multi-step work the agent completes, backed by computer-use benchmarks. Ecosystem (25%) covers plugins, connectors, and extensibility. Price accessibility (25%) measures the realistic monthly cost of getting meaningful autonomous work. Platform reach (20%) covers operating systems, web, and mobile.

The gap at the top is real but narrower than it looks. Cowork wins on the combination of model quality, platform coverage, and a $17 entry price, but the OpenAI Codex app has closed most of the capability distance since February, and Microsoft's June announcements changed its trajectory entirely. The detailed sections below unpack every one of these scores.

2. What Is Claude Cowork in July 2026?

Claude Cowork is Anthropic's general-purpose autonomous agent: you describe an outcome, and Claude plans and executes the multi-step work to get there, reading and writing files, browsing the web, using connected apps, and producing finished artifacts like spreadsheets, reports, and presentations. It launched on January 12, 2026 as a research preview exclusive to Max subscribers on macOS, positioned as "Claude Code for everyone else" - Anthropic release notes. That framing was accurate then and is worth keeping: Cowork wraps the same agentic engine that made Claude Code the default tool of professional developers into an interface built for non-technical knowledge work.

What changed is everything around that core. Cowork is no longer a preview, no longer Mac-only, no longer Max-only, and no longer purely local. As of July 2026 it is a generally available product on macOS and Windows, included in every paid Claude plan starting at $17/month, with desktop coverage extending to Linux and ChromeOS via the Google Play Store - claude.com/product/cowork. On July 7, 2026 it expanded to web, iOS, and Android, with remote sessions that run on Anthropic's servers rather than your machine - Anthropic. Enterprises can even choose where the compute lives: a standard Claude account, Amazon Bedrock, Google Cloud, or Microsoft Foundry.

The conceptual shift matters more than the feature list. In January, Cowork was a supervised experiment: you gave Claude a folder, watched it work, and treated the whole thing as a glimpse of the future. In July, Cowork is infrastructure. It runs scheduled tasks with no device online, continues working when your laptop is closed, accepts follow-up instructions from your phone, and writes directly into Microsoft 365: drafting and sending email, managing calendars, and creating or updating OneDrive and SharePoint files - Anthropic. The question stopped being "what is this?" and became "which parts of my job do I hand over first?"

That question has an empirical answer now, which earlier guides could only speculate about. Anthropic's own analysis of 1.2 million sessions shows the dominant use is the unglamorous connective tissue of office life: compiling reports, reconciling data, processing documents, updating systems - TechCrunch. Anthropic's broader Economic Index research from June 2026 found that 93% of Claude conversations produce identifiable artifacts, and 86% of surveyed users report speed gains - Anthropic research. Cowork is the product expression of that data: an agent optimized to produce artifacts, not conversation.

It is worth describing what a session actually feels like in July 2026, because the experience has matured well past the January preview. You open a task from any surface (desktop, web, or phone), describe the outcome, and optionally attach a folder, connectors, or files. Claude responds with a visible plan: numbered steps, each of which it then executes while streaming a running log of file reads, web fetches, and tool calls. You can interject at any point ("skip the 2024 data," "use the template in the brand folder"), and the agent folds the correction into the remaining steps rather than restarting. When the work involves anything destructive or externally visible (deleting files, sending an email, updating a SharePoint document), execution pauses on an explicit confirmation prompt. The output is not a chat message but an artifact: a spreadsheet, a formatted document, a deck, a set of renamed and organized files, placed where you asked for it. In-place draft editing, added June 12, means you can revise those artifacts directly rather than round-tripping through conversation - Anthropic release notes.

The other experiential change is continuity. The January product forgot everything between tasks unless you re-explained it. Since memory from chat history reached all users on March 2, Cowork carries context across sessions: it remembers your formatting preferences, your recurring project names, the way you like briefs structured. Combined with plugins (section 7), this is what converts the tool from a very capable intern on their first day into one who has been around for a quarter. The compounding effect is real and measurable in how short your prompts get: heavy users report their task descriptions shrinking from paragraphs to sentences as the system accumulates working context.

For readers comparing this product family internally, we maintain focused companion pieces: a Cowork pricing and ecosystem breakdown, a starter guide for first-time users, and a full Claude Desktop overview covering how Cowork and Code coexist in one app. This guide is the deep, current reference that ties them together.

3. Timeline: From Research Preview to Everywhere in Six Months

No competing article assembles the full dated chronology, and the chronology is the single best way to understand both the product and Anthropic's strategy. Cowork went from invite-only preview to universal availability faster than any comparable product in the agent category, and each date below is verifiable in Anthropic's official release notes - Anthropic release notes.

The speed itself is the strategic message. Anthropic shipped Windows support within a month, plugins within three weeks, and general availability within three months of first preview. That cadence was a deliberate response to competitive pressure: OpenAI's Codex desktop app landed on macOS on February 2, 2026, three weeks after Cowork's preview - OpenAI Codex changelog. The window for owning the "AI coworker" category was measured in weeks, and Anthropic behaved accordingly.

The milestones in prose, because the details matter. Cowork launched January 12, 2026 for Max subscribers on macOS as a research preview, and Anthropic extended it to Pro plans just four days later on January 16, an unusually fast de-gating that signaled confidence in the sandbox architecture - Anthropic release notes. On January 30, Anthropic released 11 open-source knowledge-work plugins covering productivity, sales, finance, legal, marketing, and more - Anthropic. February brought Windows support (both x64 and arm64), followed by the plugin marketplace with admin controls and scheduled tasks on February 24-25. Memory from chat history reached all users on March 2, and computer use expanded as a research preview to Pro and Max in both Cowork and Claude Code on March 23.

April 9, 2026 is the date that retired the "research preview" language for good: Cowork became generally available on macOS and Windows through Claude Desktop. The waitlist disappeared. From there the expansion turned outward: in-place draft editing arrived June 12, Claude Tag launched June 23 for Team and Enterprise plans (letting users delegate Slack tasks directly to Claude) - Anthropic news, and on July 7, 2026 Cowork reached web, iOS, and Android with remote sessions in beta, rolling out over several weeks starting with Max users - Anthropic.

The four-day gap between Max-only launch and Pro availability deserves its own paragraph, because it was the moment Cowork's business model became legible. Research previews normally stay gated for months while feedback accumulates; Anthropic collapsed that to under a week. The plausible reading is that the January 12 gate was operational, not strategic: a way to ramp sandbox infrastructure under load before opening the floodgates, rather than a genuine positioning of Cowork as a premium-tier feature. Once the infrastructure held, the gate served no purpose, because the economics (section 6) favor maximum distribution: an agent that saves someone five hours a week creates upgrade pressure toward Max far more effectively than a paywall creates desire. The waitlist that early coverage described as evidence of exclusivity was gone within the quarter, and by April 9 the phrase "research preview" had quietly disappeared from the product page entirely.

It is also worth noting what did NOT ship in that six-month sprint, because the omissions were disciplined rather than accidental. Anthropic did not ship an always-on ambient agent (the lane Microsoft took with Scout), did not give Cowork an autonomous identity in corporate directories, and did not remove confirmation gates on destructive actions even as competitors marketed friction-free autonomy. The consistent pattern is autonomy expanding inside an accountability envelope: more capability per release, but always with visible plans, running logs, and human confirmation at the blast-radius boundary. Whether that discipline survives competitive pressure from always-on rivals is one of the more interesting open questions of late 2026.

Two practical implications follow from this timeline. First, any evaluation of Cowork older than about eight weeks is describing a materially different product; if your team trialed it in Q1 and passed, the Q3 product deserves a re-trial. Second, the July 7 release is still rolling out by plan tier, Max first, so if you are on Pro and do not yet see remote sessions, that is expected and temporary. The doubled usage limits promotion accompanying the launch runs through August 5, 2026, which makes July the cheapest month yet to stress-test the product at scale.

4. How Cowork Works: Local vs Remote Sessions

The January 2026 story was simple: Cowork runs locally in an isolated virtual machine on your Mac. That is now exactly half the story, and understanding the two halves is the single most useful piece of architecture knowledge for deciding how to deploy it. As of July 2026, Cowork has two session types with genuinely different properties: local sessions that execute inside a sandboxed VM on your own machine through the desktop app, and remote sessions (beta) that execute on Anthropic's servers and keep working when your laptop is closed - Anthropic support.

The split is not cosmetic. Each session type owns capabilities the other cannot have. Local sessions are the only way to give Claude access to local file folders, the only way to use Claude in Chrome for browser automation on your own browser profile, and the only way to run computer use, where Claude visually operates applications. Remote sessions are the only way to get work that survives your hardware: they run scheduled tasks with no device online at all, continue multi-hour jobs while you commute, and accept check-ins from the iOS or Android app. Enterprises add a third dimension: the remote compute can be pinned to Amazon Bedrock, Google Cloud, or Microsoft Foundry instead of Anthropic's own infrastructure, which turns Cowork into something procurable under existing cloud agreements - claude.com/product/cowork.

Inside a local session, the mechanics remain what made Cowork trustworthy at launch. Claude operates in a sandboxed environment with access only to the folders you explicitly grant, produces a visible step-by-step plan, streams a running log of every action, and pauses for confirmation before destructive operations. The difference from January is capability depth: the sandbox now hosts computer use (Claude visually driving applications, in research preview since March 23), and the Claude in Chrome integration is generally available inside Cowork and Claude Code for all paid plans, with tab groups, workflow record-and-repeat, and console-log access - Anthropic support.

Remote sessions invert the supervision model. Instead of watching an agent work on your machine, you delegate and disconnect: assign a research compilation at 9pm, close the laptop, and review the finished artifact on your phone over breakfast. The July 7 update pairs this with Microsoft 365 write tools, so a remote session can draft and send email, manage calendars, and create or update OneDrive and SharePoint files without your hardware being involved at any point - Anthropic. The correct mental model is a junior employee with a company laptop: they do the work on their machine, not yours, and you interact through review and instruction.

A concrete pair of walkthroughs makes the split tangible. Local session: you point Cowork at a folder of 80 vendor invoices (PDFs and photographed receipts), ask for a reconciled expense spreadsheet flagged against the budget file in the same folder, and watch it extract, normalize, cross-check, and produce the artifact, all inside the VM, with nothing leaving your machine except the model calls themselves. That task cannot be a remote session, because the invoices live on your disk. Remote session: at 6pm you assign "compile a competitive summary of these five companies' July announcements, cross-referenced against our positioning doc in the project connector, delivered as a two-page brief," close the laptop, and the session runs on Anthropic's infrastructure for however long it takes. At 7am the brief is waiting, and the phone app shows the full step log if you want to audit how it got there. That task should never be a local session, because tying it to your hardware adds nothing but fragility.

The enterprise deployment options add a wrinkle worth spelling out for anyone in a regulated industry. When remote compute runs on Amazon Bedrock, Google Cloud, or Microsoft Foundry, the agent's execution environment inherits the compliance posture, data-residency guarantees, and contractual terms your organization already negotiated with that cloud - claude.com/product/cowork. This is quietly one of the most consequential features of the July release: it means a bank or healthcare organization can adopt remote Cowork sessions under existing vendor risk frameworks instead of opening a new assessment against Anthropic's infrastructure, which routinely cuts procurement timelines from quarters to weeks.

Choosing between the two comes down to one question: does the task need your stuff? If the work depends on files on your disk, your logged-in browser sessions, or an application only installed on your machine, it must be a local session on the desktop app. If the work depends only on cloud-reachable resources (connectors, the web, M365, uploaded files), a remote session is strictly better, because it is unaffected by your battery, your bandwidth, or your bedtime. Teams adopting Cowork seriously tend to converge on a hybrid: local sessions for document-heavy deep work during the day, remote scheduled tasks for the recurring overnight and early-morning workload.

5. What 1.2 Million Real Sessions Say People Actually Do With It

Until July 2026, every "what is Cowork good for" list was anecdote. That ended when Anthropic published an analysis of 1.2 million anonymized Cowork sessions captured between May 11 and May 31, 2026, drawn from over 600,000 organizations - TechCrunch. The headline finding restructures how you should think about the product: the tool descended from a coding agent is overwhelmingly not used for coding.

The distribution is lopsided in an instructive way. Business process automation dominates at 33.4% of usage: report generation, data reconciliation, document processing, system updates, the recurring operational work that every company runs on and nobody enjoys. Content creation takes 16.4%: drafting, editing, repurposing, formatting. Software development, the category Claude Code was built for and the category most journalists assumed would dominate, is just 8.7%. Anthropic's summary phrase for the dominant workload is "the work around the work," and it is the most useful task-selection heuristic in this entire guide.

Why does business process automation dominate? First principles: an autonomous agent creates the most value where work is frequent, structured, and boring. Creative work is infrequent and judgment-heavy, so the human stays in the loop and the agent saves less time. Coding already had a dedicated tool. But the connective tissue of office life (compile the weekly numbers, reconcile the two spreadsheets, extract data from these 40 PDFs, update the tracker, send the summary) is high-frequency, well-specified, and delegable end to end. The 33.4% figure is what happens when a general population, not early-adopter developers, gets an agent that can actually finish tasks.

The 41.5% long tail is just as informative as the top categories, because it shows the product resisting easy categorization. Sessions in the tail span data analysis, research compilation, project coordination, personal administration, learning support, and dozens of smaller clusters, none individually large enough to headline. That shape (a few dominant structured-work categories plus an enormously diverse tail) is characteristic of general-purpose infrastructure rather than a point tool. Spreadsheets have the same usage signature. It suggests Cowork's ceiling is set less by what the agent can do and more by how many of their own tasks users have learned to recognize as delegable, which is a habit problem, not a capability problem, and habit problems resolve slowly and then all at once.

This aligns with Anthropic's June 26, 2026 Economic Index report ("Cadences"), which analyzed usage rhythms across Claude surfaces and found 93% of conversations produce identifiable artifacts, with personal use jumping from roughly 35% on weekdays to 50% on weekends, and 86% of surveyed users reporting speed gains - Anthropic research. Cowork usage patterns track overall chat patterns, meaning the agent is being absorbed into existing work rhythms rather than creating new ones. People are not inventing exotic new agent workflows; they are handing over the parts of their existing job that were always mechanical.

The practical application: when choosing your first Cowork delegations, do not start with your hardest problem. Start with your most repetitive one. Inventory the tasks you perform weekly that follow the same shape every time (gather, transform, format, distribute) and delegate those first. The usage data says this is where 600,000 organizations found the value, and it is also where errors are cheapest to catch, because you know exactly what correct output looks like. We cover the broader delegation strategy in section 10, and our insider guide to Cowork tactics goes deeper on task selection.

6. Pricing and Usage-Limit Economics

The pricing story is the single most outdated thing in early Cowork coverage, including the original version of this article. At launch, Cowork required Claude Max at $100-$200/month, and that number still circulates widely. The reality since January 16, 2026 (four days after launch) is that Cowork is included in every paid Claude plan, and the entry point is the Pro plan at $17/month billed annually, or $20 month-to-month - claude.com/pricing.

The current plan structure bundles far more than Cowork. Pro at $17/month annual includes Claude Cowork, Claude Code, Claude Design, and Claude Science. Max comes in two tiers: $100/month for 5x Pro usage and $200/month for 20x, plus priority access to new features (Max users got the July 7 web/mobile rollout first). Team runs $20/seat annual on the standard tier or $100/seat premium, and Enterprise starts at a $20/seat minimum plus usage-based components - claude.com/pricing. For a deeper cost model of the developer-side sibling, see our Claude Code pricing breakdown.

The number that actually governs your experience is not the price, it is the usage limit, and here the mechanics deserve more attention than any vendor page gives them. Cowork shares subscription limits with Claude chat and Claude Code: one pool, all surfaces - Anthropic support. Limits operate on rolling 5-hour windows (with weekly caps on heavy tiers), and autonomous work is token-hungry in a way chat is not. A single ambitious Cowork session that reads 200 files, browses 30 pages, and drafts a 40-page report can consume in one hour what a chat user spends in a week. If you run Cowork hard on Pro, you will hit the window; that is not a bug or a billing error, it is the subscription's capacity cap doing its job.

Three economic consequences follow. First, the promotion matters: Anthropic doubled Cowork usage limits and extended the promotion through August 5, 2026, which makes right now the highest-value evaluation window the product has had - Anthropic. Second, the upgrade path is usage-driven, not feature-driven: Pro and Max run the same Cowork, so pay more only when the 5-hour window actually interrupts your throughput, and our pricing and ecosystem guide includes worked examples of where each tier saturates. Third, for teams, shared limits change scheduling: if the same account powers a developer's Claude Code sessions and an analyst's Cowork runs, they are drawing from one pool, and staggering heavy autonomous jobs into off-hours via scheduled tasks is free capacity management.

A worked example clarifies the tier decision better than abstractions. Take an operations manager who runs the 6am scheduled briefing daily, delegates two document-heavy tasks per workday, and runs one long research compilation per week. On current limits, that pattern fits inside Pro's window most days, with occasional Friday collisions when the weekly compilation lands on top of the daily load; the correct response is schedule-shifting the compilation to overnight, not upgrading. Now take a consultant running four to six parallel client deliverables through Cowork daily, plus Claude Code for tooling: that usage profile saturates Pro's shared pool by early afternoon and loses billable throughput waiting for windows to reset, and Max 5x at $100 pays for itself in the first recovered afternoon. The arithmetic that matters is not the subscription price but the cost of a blocked hour: at any professional billing rate, the $83 monthly difference between Pro and Max 5x is noise compared to even two hours of monthly wait time. Price the limit, not the plan.

The comparison against employing a human for the same connective-tissue work is stark enough that finance teams have started making it explicitly. The 33.4% of usage that is business process automation maps to work that, pre-2026, was performed by coordinators, analysts, and assistants at fully loaded costs of $4,000-$8,000 per month. A Max 20x subscription at $200/month running scheduled tasks around the clock does not replace those roles wholesale (specification, judgment, and exception handling stay human), but it absorbs enough of the mechanical layer that new-headcount conversations increasingly start with "have we tried delegating it first?" That reframing, more than any benchmark, is what the pricing collapse from $200-gated to $17-included actually purchased for Anthropic.

Set against the January framing ("$100+ per month might decrease as competition improves"), the collapse to $17 in under a week was less a pricing decision than a land-grab. Anthropic is monetizing Cowork the way cloud vendors monetize storage: get the workflow embedded everywhere cheaply, and let usage growth pull customers up the tier ladder. For buyers, that means the cheap tier is genuinely good, and the expensive tiers are for throughput, not features.

7. The Plugin and Connector Ecosystem

The original version of this guide predates the entire Cowork plugin ecosystem, which now defines much of the product's practical capability. On January 30, 2026, less than three weeks after launch, Anthropic released 11 open-source knowledge-work plugins: Productivity, Enterprise Search, Sales, Finance, Data, Legal, Marketing, Customer Support, Product Management, Biology Research, and Plugin Create, browsable at claude.com/plugins-for/cowork and published on GitHub as anthropics/knowledge-work-plugins - Anthropic. On February 24-25, a plugin marketplace with admin controls followed, alongside roughly 12 more official plugins and the first partner plugins, bringing the official catalog past 23 plugins - Anthropic release notes.

Understanding what a plugin actually is prevents most confusion. A Cowork plugin is a bundle of four things: skills (procedural knowledge documents that teach Claude how a domain works), connectors (authenticated integrations to external systems), slash commands (shortcuts for recurring invocations), and sub-agents (specialized workers the main session can delegate to) - claude.com/product/cowork. Installing the Finance plugin does not just give Claude finance vocabulary; it gives it opinionated workflows for reconciliation and reporting, connections to the systems that hold the data, and commands your team can standardize on.

The connector layer is what turns Cowork from a file processor into an operations hub. The ecosystem now spans Slack, CRM systems, Databricks, Google Drive, and partner plugins like Brand Voice by Tribe AI plus legal and finance bundles - claude.com/product/cowork. The July 7 update added the most requested enterprise write path: Microsoft 365 tools for drafting and sending email, managing calendars, and creating or updating OneDrive and SharePoint files - Anthropic. And Claude Tag, launched June 23 for Team and Enterprise, closes the loop from the other direction: teammates delegate tasks to Claude directly inside Slack, without opening a Claude surface at all - Anthropic news.

Walking through one plugin end to end shows how the four components interlock in practice. Install the Finance plugin and three things change immediately. The skills teach Claude your domain's shape: what a month-end close involves, how reconciliation differs from review, what belongs in a variance commentary. The connectors link the systems where the numbers live, so "pull June actuals" resolves to a real query instead of a request for a file upload. The slash commands standardize invocation, so /close-checklist produces the same structured process for everyone on the team instead of ten people prompting ten different ways. When a task is large, the plugin's sub-agents split it: one worker extracting from source systems while another formats the reporting pack, coordinated by the main session. None of this is exotic engineering; it is the codification of a workflow that previously lived in a senior employee's head, which is exactly why the plugin format matters more than any individual plugin.

One operational caveat teams learn quickly: connector authentication is per-user and expires. A scheduled task that ran flawlessly for three weeks will fail silently on the morning a connector token lapses, and the failure mode is an incomplete brief rather than a loud error. Treat connector health as part of the workflow: review scheduled-task run logs weekly, and prefer fewer, well-maintained connectors over a sprawling set nobody audits.

Three adoption lessons from teams that have deployed the ecosystem seriously. Start with one plugin, not five: each plugin adds instructions to the agent's context, and stacking many at once makes behavior harder to attribute and debug. Use the marketplace's admin controls if you are on Team or Enterprise: the February marketplace release exists specifically so IT can allowlist which plugins and connectors employees may enable, which matters enormously given the security material in section 11. Build your own with Plugin Create once patterns stabilize: the eleventh launch plugin is a meta-plugin that scaffolds custom plugins, and encoding your company's actual procedures (your report format, your CRM hygiene rules, your escalation paths) is where plugin value compounds. This skills-and-connectors architecture is the same pattern that underpins the broader agent platform world, which we mapped in our guide to building AI agents.

The strategic read: Anthropic open-sourced the launch plugins deliberately. Plugins are distribution, not moat; the moat is the agent quality underneath. By making the knowledge-work plugin format open on GitHub, Anthropic invited consultancies and vendors to build on Cowork the way they once built on Salesforce, and the partner plugins arriving since February suggest it is working.

8. The Model Stack: Opus 4.8, Sonnet 5, and the Fable 5 Saga

Cowork is only as good as the models underneath it, and the model lineup has turned over completely since this guide's original publication in the Opus 4.5 era. The 2026 release cadence, all documented in Anthropic's release notes, ran: Opus 4.6 on February 5 (with Claude for PowerPoint and native Excel operations), Sonnet 4.6 on February 17 with a 1M-token context window in beta, Opus 4.7 on April 16, Claude Design from Anthropic Labs on April 17, Opus 4.8 on May 28, Fable 5 on June 9, and Sonnet 5 on June 30 - Anthropic release notes.

Two of those releases carry most of the weight for Cowork users. Claude Opus 4.8 (May 28) is the workhorse flagship: $5/$25 per million input/output tokens, a fast mode at $10/$50 that runs 2.5x faster, effort controls shipped across claude.ai and Cowork, and Anthropic's claim that it is 4x less likely than Opus 4.7 to overlook code flaws - Anthropic. Claude Sonnet 5 (June 30) approaches Opus 4.8 performance at a fraction of the cost, with introductory pricing of $2/$10 per million tokens through August 31, 2026 (then $3/$15) and cybersecurity safeguards on by default - Anthropic. Our Opus 4.8 benchmark guide and Sonnet 5 practical guide cover both in model-level depth.

Then there is the story no one saw coming. On June 12, 2026 at 5:21pm ET, a US government export-control directive forced Anthropic to suspend access to its newest frontier models, Fable 5 and Mythos 5, over a claimed safeguard bypass, three days after Fable 5 launched. Anthropic publicly disputed the severity of the finding, and access was restored around July 1, 2026, accompanied by new model-entitlement controls that let Enterprise admins govern which models their organization can invoke - Anthropic. It was the first time a US frontier model was pulled from market by government directive, and the episode is now a permanent feature of enterprise AI risk planning: model availability is subject to regulatory action, and architectures should degrade gracefully to alternate models. Our Fable 5 and Mythos 5 benchmark analysis covers the models themselves.

Why this section matters for a Cowork guide: autonomy claims need an objective yardstick, and for desktop agents that yardstick is OSWorld-Verified, the benchmark measuring how reliably a model completes real tasks on a real computer. On the leaderboard as of July 8, 2026, Claude Fable 5 and Claude Mythos 5 lead at 85%, Claude Opus 4.8 scores 83.4%, Claude Sonnet 5 hits 81.2%, GPT-5.5 lands at 78.7%, and Gemini 3.5 Flash posts 78.4% - BenchLM.

The practical question for a Cowork user is which model to run for which delegation, and the effort controls that shipped with Opus 4.8 across claude.ai and Cowork make this an actual dial rather than a fixed choice - Anthropic. The pattern that emerges from daily use: Sonnet 5 on standard effort handles the recurring structured workload (briefings, reconciliations, formatting, extraction) indistinguishably from the flagship at a fraction of the token spend, which matters directly because tokens are what your shared usage window is made of. Opus 4.8 on high effort earns its cost on the long-horizon tasks where per-step reliability compounds: a forty-step research synthesis at 98% per-step reliability finishes clean far more often than one at 95%, and the difference between those two numbers is invisible on short tasks and decisive on long ones. Fable-class models, where entitled, are the choice for the hardest computer-use work, with the June suspension episode as the reminder to never architect around a single model's availability.

Read the leaderboard carefully rather than triumphantly. Anthropic holds the top four slots, which substantiates Cowork's autonomy positioning with something better than marketing. But the gap from first place (85%) to the best non-Anthropic entry (78.7%) is about six points, not a chasm, and a year ago the entire category was scoring far below any of these numbers. The honest conclusion is that Claude models are currently the best at operating computers, that the advantage is real enough to feel in daily use on long multi-step tasks (where per-step reliability compounds), and that the advantage is not so large that competitors are out of the game. The cross-vendor pricing picture is tracked in our model benchmarks and pricing roundup.

One more data point belongs here because it explains the resourcing behind this release cadence: on May 28, 2026, Anthropic closed a $65 billion Series H at a $965 billion post-money valuation, led by Altimeter, Dragoneer, Greenoaks, and Sequoia, disclosing $47 billion run-rate revenue as of May 2026 - Anthropic. The agent product line, Cowork prominently included, is the growth story that valuation is priced on.

9. Cowork vs Claude Code vs Claude in Chrome

Anthropic now ships three overlapping agent surfaces, and the overlap genuinely confuses people: all three can use computers, all three can touch the browser, and all three can run scheduled work. Choosing wrong wastes time rather than breaking anything, but choosing right is worth a section, because the three surfaces embody different contracts between you and the agent.

Claude Cowork is the delegation surface. Its unit of work is the task: a described outcome that Claude plans and executes with files, connectors, browsing, and artifacts, locally or remotely. It assumes the least technical skill, provides the most guardrails, and produces business artifacts. Claude Code is the engineering surface: terminal-native, repo-aware, optimized for code and infrastructure, and priced into the same plans (see our beginner's guide to Claude Code for where it shines). Claude in Chrome is the browser surface: a Chrome extension that drives your actual logged-in browser with tab groups, workflow record-and-repeat, scheduled tasks, and console-log access; it is generally available inside Cowork and Claude Code for all paid plans, while remaining beta as a standalone in the Chrome browser itself - Anthropic support.

The decision heuristic that holds up in practice has three questions. Is the deliverable code? Use Claude Code; Cowork can write software, but Code's repo tooling, test loops, and diff discipline are categorically better for it. Does the task live inside authenticated web apps with no API or connector (a legacy admin panel, a vendor portal)? That is Claude in Chrome territory, driven from within a Cowork local session. Everything else, meaning files, documents, data, connectors, email, and research: default to Cowork, and prefer a remote session unless local files or the browser are required.

Three scenarios show the heuristic working. A founder wants a landing page shipped: that is a code deliverable, so Claude Code, even though Cowork could technically produce HTML, because Code will scaffold the project, run it, and iterate against what actually renders (our website builder guide covers this path end to end). An operations lead needs 200 records updated in a legacy vendor portal that has no API: that is Claude in Chrome from within a local Cowork session, using workflow record-and-repeat so the agent learns the click-path once and replays it with per-record data. A marketing manager needs last quarter's campaign data compiled from Drive and the CRM into a board-ready deck: pure Cowork, remote session, no reason for the laptop to be involved at all. In each case the wrong-surface version works badly rather than not at all, which is precisely why people persist with mismatched surfaces longer than they should.

The deeper point is that the boundaries are dissolving by design. Computer use shipped to both Cowork and Claude Code on March 23; Chrome capabilities surface inside both; scheduled tasks exist across the family. Anthropic is converging on one agentic engine with three doorways, each tuned to a persona. Pick the doorway that matches the deliverable, not the one you happen to have open, and revisit the choice as the surfaces continue to merge. The developer-side view of this convergence, including the Agent SDK that exposes the same engine programmatically, is covered in our Claude Agent SDK deep dive.

10. The Practical Delegation Playbook

Everything above is context; this section is practice. These are the delegation patterns that consistently work in July 2026, written as recipes rather than feature descriptions, and they take advantage of capabilities (remote sessions, scheduled tasks, mobile approvals, M365 write access) that did not exist when most Cowork tutorials were written.

The 6am briefing is the canonical scheduled-task pattern and the best first recipe. Create a scheduled task that runs before your workday: pull the connectors you care about (inbox, calendar, CRM, project tracker, a handful of news sources), synthesize a one-page brief with anything anomalous flagged at the top, and file it to a fixed location or send it via the M365 email tools. Because scheduled tasks run as remote sessions with no device online, this works even when your laptop is in a bag - Anthropic support. The compounding trick: whenever the brief includes something useless or misses something important, edit the task's instructions that same day; after two weeks of tuning it stabilizes into something you would genuinely pay for.

Close-the-laptop delegation is the pattern that changes evening workflows. Batch your long-horizon tasks (the 60-page document analysis, the competitive research sweep, the quarterly data reconciliation) and hand them to remote sessions at the end of the day, then review artifacts from your phone in the morning, since the July 7 release brought full session visibility to iOS and Android - Anthropic. The skill to develop here is outcome specification: a good handoff names the deliverable format, the sources to use, the sources to avoid, and what "done" looks like. Vague goals produce vague artifacts; there is no mid-task steering when you are asleep.

Parallel sessions exploit the fact that you are the bottleneck, not the agent. Cowork supports multiple concurrent sessions, and the productive pattern is running two or three unrelated tasks side by side (say, expense processing, a research brief, and a slide draft), checking in as each completes. Resist the urge to parallelize dependent tasks; sequencing dependent work through one session with a shared folder of intermediate artifacts is more reliable than trying to coordinate siblings. Remember from section 6 that all sessions draw from a shared usage pool, so parallelism spends your 5-hour window faster; this is exactly the scenario the doubled-limits promotion (through August 5, 2026) exists to let you test cheaply.

The write-action ladder governs how much power you grant. Start every new workflow read-only: Claude drafts, you send. After a few clean cycles, let it write to low-blast-radius targets (its own output folder, a draft email it queues for your approval). Only after sustained accuracy do you allow direct external writes like sending email or updating SharePoint via the Microsoft 365 write tools - Anthropic. This ladder is not paranoia; it is the same graduated-trust process you would use with a new hire, and it maps exactly onto the security model in the next section, where the reasons for keeping write access earned rather than default become vivid.

The document pipeline is the highest-volume recipe in operations-heavy teams and the purest expression of the 33.4% workload. Set up a watched intake folder (or a connector source), and define the standing transformation: every contract gets a one-page summary with obligations and dates extracted to the tracker; every invoice gets validated against the PO and logged; every applicant CV gets structured into the comparison sheet. Run it as a scheduled task on a cadence matching your intake volume, and route only the exceptions to a human: the contract with the unusual clause, the invoice that does not reconcile, the CV the extraction choked on. Exception-routing is the design principle that separates durable pipelines from demos, because it means the human reviews judgment calls instead of re-checking mechanical work, and it means pipeline errors surface as flagged exceptions rather than silent corruption.

Mobile approvals knit all of these patterns together into something that did not exist before July 7. Because the iOS and Android apps expose full session state, the confirmation prompts that gate consequential actions no longer require you to be at a desk: the remote session that drafted twelve customer emails overnight holds them at the approval gate, and you clear the queue from your phone in four minutes over coffee - Anthropic. The result is a supervision model measured in minutes per day rather than hours: the agent works continuously, and your involvement compresses to specification upfront and judgment at the gates.

A final calibration note on task selection. The usage data from section 5 says the winners are frequent, structured, verifiable tasks, and the failure stories almost always involve delegating something the delegator could not have specified precisely in the first place. If you cannot describe what a correct result looks like, the agent cannot reliably produce one; do that thinking first, or do that task yourself.

11. Security: The PromptArmor Case Study and Hardening Checklist

The original version of this guide treated prompt injection as a theoretical risk with no known incidents. That aged badly within days of being written. Roughly 48 hours after Cowork's January 2026 launch, security firm PromptArmor published a working file-exfiltration proof of concept against it - PromptArmor. The mechanics deserve precise description, because they teach more about agent security than any abstract warning.

The attack worked like this. A Word document contained instructions hidden in 1-point white text, invisible to the human who saved it into a folder they later granted to Cowork. When Claude read the document during a routine task, it treated the hidden text as instructions and complied: it used curl to send the user's files to an attacker-controlled account. The exfiltration channel is the elegant, damning part: the sandbox's network allowlist permitted Anthropic's own API endpoints, so the attacker simply had Cowork POST the stolen data to the Anthropic API using the attacker's API key, where the attacker could retrieve it from their own account logs. Every hop looked legitimate: a trusted app, a user-granted folder, an allowlisted domain.

Extract the three structural lessons rather than the headline. First, indirect prompt injection is a data-plane problem: the attack arrived in a document, not a chat message, so "be careful what you type" advice is irrelevant; anything the agent reads is a potential instruction channel, including files, emails, web pages, and calendar invites. Second, allowlists are attack surface: the sandbox worked as designed, and the design was the hole, because an allowlisted endpoint that accepts arbitrary authenticated POSTs is an exfiltration route. Third, disclosure worked: PromptArmor reported the issue, Anthropic tightened the sandbox's egress behavior, and the episode became the reference case that now shapes enterprise agent deployments. Anthropic's own launch documentation had been candid that prompt injection defenses were an active area without guarantees; the PoC converted that disclaimer from boilerplate into an operational planning input.

The right mental frame for agent security is the insider-threat frame, not the malware frame. Cowork with folder access and connectors is structurally equivalent to a fast, tireless employee who believes everything they read: enormously productive, and vulnerable to social engineering through any document that crosses their desk. Organizations already know how to manage that risk profile for humans (least-privilege access, separation of duties, approval workflows for outbound actions, activity logging), and every one of those controls translates directly. What does not translate is the speed: a manipulated human exfiltrates data over days, a manipulated agent over seconds, which is why the confirmation gates on write actions and the egress discipline of the sandbox carry more of the security load than they would in a human process. This is also the strongest argument against the always-on, friction-free autonomy that parts of the market now advertise: friction at the blast-radius boundary is not a UX failure, it is the control.

For teams deploying Cowork at scale, the practical hardening posture in July 2026 looks like this:

• Scope folder grants tightly: per-project folders, never home directories or shared drives wholesale
• Gate write actions: keep confirmation prompts on for sends, deletions, and external updates; climb the write-action ladder from section 10
• Control the ecosystem centrally: use the plugin marketplace's admin controls to allowlist plugins and connectors rather than letting each employee decide
• Prefer remote sessions for untrusted inputs: processing documents of uncertain provenance on Anthropic's servers rather than a corporate laptop shrinks the local blast radius
• Stream telemetry: Enterprise deployments should feed session activity into existing SIEM tooling so anomalous egress or bulk file access trips the same alarms as any other endpoint

None of these controls makes prompt injection solved, and honesty requires saying so plainly: it is an unsolved class of vulnerability across every agent product in this guide, not a Cowork-specific defect. OpenAI's computer-using Codex, Microsoft's Scout, and Google's Gemini Agent all read untrusted content and all face the same fundamental problem. What distinguishes vendors is sandbox quality, egress discipline, patch velocity, and admin tooling, and on those dimensions the January incident plus Anthropic's response is, on balance, evidence the system of checks functions. Treat any vendor claiming immunity as disqualified on that claim alone.

12. The July 2026 Competitive Landscape

The original version of this guide said OpenAI had "no local desktop agent equivalent," that Microsoft "prioritizes user-driven over autonomous behavior," and that Google "lags on a cohesive general-purpose agent." All three statements are now false, and pretending otherwise would make this guide the stale artifact it replaces. Here is the honest field, competitor by competitor, as of July 8, 2026.

OpenAI: the Codex desktop app. OpenAI shipped the Codex app for macOS on February 2, 2026 and Windows on March 4, then spent the spring aggressively expanding it beyond coding: GPT-5.3-Codex on February 5 (25% faster), GPT-5.4 in March with native computer use and 1M context, GPT-5.5 in April, Goal mode out of experimental status in May, and Codex Remote hitting GA in June - OpenAI Codex changelog. The April update added computer use, in-app browsing, image generation, and memory, explicitly repositioning it as a general knowledge-work tool - MacRumors. Goal mode mirrors Cowork's delegation model; Codex Remote mirrors remote sessions. The honest comparison: Codex matches Cowork's shape feature-for-feature, trails on computer-use benchmarks (78.7% vs 83.4-85%), trails on mobile (no phone surface for the agent), and leads wherever a team is already deep in the OpenAI ecosystem. Our GPT-5.5 real-work benchmark guide and founder's guide to Codex cover the details.

Microsoft: Copilot Cowork and Scout. Microsoft did not respond quietly. At Build 2026 on June 2, it made Agent Mode the default for Microsoft 365 Copilot, shipped its own "Copilot Cowork" to general availability on June 16, 2026 (yes, the name is a direct shot), and launched Microsoft Scout, its first always-on "Autopilot": an agent with its own Entra identity that works across Teams, Outlook, OneDrive, SharePoint, desktop, and web, currently in private preview requiring a GitHub Copilot license - Microsoft. The "user-driven, not autonomous" characterization is fully inverted: Scout's always-on model with a directory identity is arguably more autonomous than anything Anthropic ships. Microsoft's advantage is distribution and Graph data depth; its weakness is licensing complexity (a Copilot seat plus a GitHub Copilot license for Scout) and that its strongest pieces are still in preview. Our complete Copilot Cowork analysis does the side-by-side in depth.

Google: Gemini Agent after Mariner. Google discontinued Project Mariner on May 4, 2026, folding its browser-agent capabilities into the Gemini API, Vertex AI, and the consumer-facing Gemini Agent - Wikipedia. That was consolidation, not retreat: Gemini 3 and 3.5 with system-level agent capabilities were the centerpiece of Google I/O 2026, and Gemini 3.5 Flash benchmarks within striking distance on OSWorld at 78.4% - BenchLM. Google's agent story is strongest inside Workspace and Android and weakest as a standalone cross-platform desktop product, which is precisely the ground Cowork occupies. See our Gemini 3.5 Flash benchmark guide for the model-level view.

ChatGPT Atlas remains the odd one out: OpenAI's agentic browser is still macOS-exclusive as of mid-2026 with agent mode gated to Plus/Pro subscribers, and in March OpenAI announced plans to consolidate Atlas, the ChatGPT desktop app, and Codex into one unified desktop application - Wikipedia. Until that consolidation ships, Atlas is a browser bet rather than a full desktop agent, which is why it trails the scored table in section 1. Meanwhile, a different architectural lane exists entirely: cloud-native AI workforce platforms like O-mega skip the desktop question altogether, running teams of role-based agents with browser and computer capabilities in the cloud, an approach that suits organizations wanting agent capacity that is not tied to any employee's machine or personal subscription.

The pricing comparison across the field deserves explicit treatment, because the sticker prices hide different philosophies. Anthropic bundles everything into one subscription with a $17 floor and sells throughput tiers. OpenAI bundles the Codex app into ChatGPT paid plans on similar logic. Microsoft prices per-seat on top of existing M365 commitments, which looks cheap per unit but compounds across an organization and, for Scout, currently stacks a GitHub Copilot license on top of the Copilot seat - Microsoft. Google folds Gemini Agent into its AI plan tiers and Workspace editions. For an individual, the differences are pocket change; for a 500-person org, the Microsoft stack can run an order of magnitude more per year than blanket Claude Pro, and the honest counterweight is that Microsoft's agents arrive pre-integrated with the tenant, identity, and compliance machinery the organization already runs. Total cost of ownership, not subscription price, is the number to model, and it turns on how much integration work each vendor saves you.

Step back and the field has a legible structure. Anthropic leads on agent quality and platform breadth, OpenAI on ecosystem gravity, Microsoft on enterprise distribution, Google on consumer surface area, and workforce platforms on organizational decoupling. Six months ago this guide could truthfully say nobody else had a Cowork. Today the truthful statement is narrower and more useful: nobody else currently combines top-of-leaderboard computer use, seven-platform availability, and a $17 entry price in one shipped product, and that specific combination is Cowork's actual moat while it lasts.

13. What Still Does Not Work

A guide that only lists capabilities is marketing. Here is the honest boundary map of Cowork in July 2026, because knowing where the edges are is what separates successful deployments from disappointed ones.

The rollout is still uneven. Web, iOS, and Android access is beta, rolling out over several weeks by plan tier, Max first, so Pro users may not yet see remote sessions at all - Anthropic. Claude in Chrome is GA inside Cowork and Code but remains beta as a standalone browser experience - Anthropic support. Computer use is a research preview, and it shows: visually operating desktop applications is the least reliable capability in the stack, dramatically better than a year ago and still the place where sessions most often need rescue. Plan pilots around what your tier actually has today, not the announcement blog post.

Usage limits bite on exactly the workloads Cowork is best at. Long autonomous runs are token-intensive, the limit pool is shared with chat and Claude Code, and a heavy afternoon can exhaust a 5-hour window with work queued behind it. The doubled-limits promotion masks this through August 5, 2026; when it lapses, Pro users running daily multi-hour delegations will feel the ceiling and face the Max upgrade decision. Budget owners should model this now rather than discover it in September.

Prompt injection remains unsolved, as section 11 detailed, and remote sessions have their own trust asymmetry: they cannot touch your local files (a security win) but they do run on infrastructure you do not control, which some data-governance regimes will not accept outside the Bedrock, Google Cloud, or Microsoft Foundry deployment options - claude.com/product/cowork. And the June 12 export-control suspension of Fable 5 and Mythos 5 established that even model availability carries regulatory risk - Anthropic. None of these is a reason to avoid the product; all of them are reasons to deploy it with graduated trust, an audit trail, and a fallback plan, which is simply how competent teams deploy anything with write access.

There is also a quieter operational gap that surfaces only at scale: observability across many sessions. An individual watching one task has a perfect running log; a team lead responsible for forty scheduled tasks across a department has no single pane showing what ran, what failed, what was approved, and what is waiting. Enterprise SIEM streaming covers the security dimension, but the management dimension (utilization, outcomes, quality trends across an organization's agent workload) is still mostly spreadsheets and discipline. Every vendor in section 12 has the same gap, which is a reliable sign of where the next competitive front opens: whoever ships genuine fleet management for knowledge-work agents first will have solved the problem that currently caps deployments at the size one attentive human can supervise.

Finally, the oldest limitation is still the truest one: Cowork executes specifications, it does not create them. Tasks whose success criteria the delegator cannot articulate fail at roughly the rate they always did, and no amount of model improvement between Opus 4.5 and Sonnet 5 has changed that. The teams getting the most from Cowork are the ones that got better at specifying work, which is, not coincidentally, the same thing that makes human delegation succeed.

14. Future Outlook

The next twelve months are more predictable than the last six, because the strategic logic is now visible. Expect convergence within Anthropic's stack: Cowork, Claude Code, and Claude in Chrome share an engine and are visibly merging into one agentic system with persona-specific doorways, and the Agent SDK exposes the same engine to builders. Expect the beta gates to fall: web and mobile rollout completing across tiers, Claude in Chrome reaching browser GA, computer use graduating from research preview, and remote sessions gaining more of the local session's capabilities as connector coverage grows.

Watch the model layer for the same reason. The OSWorld-Verified gap between Anthropic's 85% ceiling and the trailing pack's high-70s is the kind of lead that historically lasts two to four release cycles, not forever, and both GPT-5.5's trajectory and Gemini 3.5's I/O showing suggest the computer-use race tightens through late 2026. If the reliability gap closes, the competition resolves to the layers above the model (ecosystem, trust architecture, economics, and distribution), which is exactly where Microsoft and Google are structurally strongest. Anthropic's window for converting model leadership into switching costs (memory, plugins, embedded workflows, organizational habit) is now, and the six-month shipping cadence documented in section 3 reads like a company that knows it.

Expect the competitive field to compress. OpenAI's announced consolidation of Atlas, the ChatGPT desktop app, and Codex into one application is the clearest tell: every major lab is converging on the same product shape (one agent, all surfaces, delegation-first), which means differentiation shifts to the three things that are hard to copy quickly: model quality on long-horizon tasks (where the OSWorld gap lives), enterprise trust architecture (sandboxing, egress control, admin governance, the post-PromptArmor discipline), and usage economics (whose subscription delivers the most completed work per dollar). Pricing pressure is already visible in Sonnet 5's $2/$10 introductory rates and OpenAI's bundling, and it favors buyers.

The deeper shift is organizational rather than technical. When agents run with their own identities (Microsoft Scout's Entra identity is the early example), survive their owner's hardware, and execute scheduled work nobody watches, companies acquire a second, non-human workforce layer that needs the management infrastructure the human layer has always had: provisioning, permissions, review, and accountability. That layer is exactly what workforce-oriented platforms like O-mega are built around, and it is where the desktop-agent story and the AI-workforce story merge. Yuma Heymans, founder of O-mega and co-founder of HeroHunt.ai (@yumahey), has spent 2026 running precisely these delegation patterns across autonomous agents daily, and this guide's playbook sections distill that first-hand operating experience.

15. Conclusion

Claude Cowork in July 2026 is what the January research preview promised and could not yet deliver: a generally available, cross-platform, $17-and-up autonomous agent that does real office work locally and in the cloud, backed by models that lead the objective computer-use benchmark at 85% on OSWorld-Verified - BenchLM. The 1.2-million-session data settles what it is for: not coding, but the work around the work, the recurring operational load that consumes a third of office life.

The decision framework is short. If your work involves recurring, specifiable digital tasks and you are on any paid Claude plan, turn Cowork on this month, while the doubled-limits promotion (through August 5, 2026) makes experimentation nearly free, and start with one scheduled briefing and one close-the-laptop delegation. If you are ecosystem-committed elsewhere, the OpenAI Codex app and Microsoft Copilot Cowork are legitimate near-peers, not afterthoughts, and section 12's comparison is the honest map. If you need agent capacity that belongs to the organization rather than to individual employees' machines and subscriptions, evaluate the cloud workforce lane alongside the desktop one.

Whichever lane you choose, deploy like a manager, not a spectator: scoped access, graduated write permissions, an audit trail, and specifications precise enough that you would accept the same brief from a new hire. The agents crossed the usefulness threshold in 2026. The differentiating skill now sits on our side of the keyboard.

This guide reflects the Claude Cowork product, pricing, and competitive landscape as of July 8, 2026. This category moves faster than any other in software: verify current pricing, availability, and model lineups against official sources before making purchasing decisions.