Anthropic Cowork 改为云端运行模型推理与 VM
Key Highlights
Anthropic's computer-using product, Cowork, has quietly swapped its skeleton. Engineer Felix Rieseberg laid out the old and new architectures in a technical post, and the change boils down to one sentence: the model inference and the task-running virtual machine have moved off the user's machine and into the cloud. It is a behind-the-scenes change, but it reshapes who the product is actually for.
The move is less about clever engineering than about fixing a category-level weakness. Every "computer-using agent" launched so far has quietly depended on a powerful, always-on, human-owned machine sitting underneath it. That assumption breaks the moment the human closes the laptop, loses wifi, or simply wants to check progress from a phone. Cloudifying the VM is how Cowork stops being a desktop feature and starts being a service.
What Happened
The old design was "think in the cloud, act on the device": the large-model inference ran on Anthropic's servers, but the virtual machine (VM) that actually clicked, typed and ran scripts lived on your computer. That created three legacy problems — the VM files ate local disk, constant running drained the battery, and performance was capped by the host machine. The most awkward failure mode was simple: close the laptop and the local VM suspended, killing the task on the spot.
The new version is "think in the cloud, act in the cloud": both inference and the VM move to the cloud, with each session an isolated sandbox. The desktop app degrades into a lightweight shell that only handles capabilities requiring local hardware, such as reading and writing files on your machine or using a local camera. The heavy, stateful work now lives somewhere that never sleeps, and the laptop becomes a thin window rather than the engine.
Technical Detail
The key trade-off is deciding which tool calls must stay on the device. Rieseberg's explanation: operations that depend on real hardware — file access, peripherals — cannot be fully cloudified, so the desktop keeps a minimal local proxy; everything that can be remote is pushed into the cloud sandbox. Per-session sandbox isolation also neatly solves cross-task contamination, a class of bug that plagued the old shared-local-VM model whenever two jobs touched the same filesystem.
There is a security upside hiding in the design. A cloud sandbox that is created and destroyed per session is far easier to audit and contain than a persistent local process with broad access to your machine. If a task goes wrong, the blast radius is one disposable sandbox, not your whole operating system. That property is exactly what enterprise security teams ask about before they will let an agent near production data.
Versus Competitors
Compared with browser-bound agents like OpenAI's Operator or Google's Mariner, Cowork differentiates by treating persistent execution as a first-class citizen. A cloud VM means tasks can keep progressing across devices and across time, instead of being chained to one powered-on computer. Where rivals often feel like a clever macro that needs you watching, Cowork is closer to a background process you can walk away from.
That distinction sounds minor until you actually try to use these tools for real work. A macro that stops when you close the lid is a toy; a process that keeps running is a teammate. Cowork's bet is that reliability of this specific kind — not raw capability — is what will separate tools people trust from tools people demo once and forget.
Industry Impact and Use Cases
For everyday users: you can pick up on your phone what the laptop left unfinished, and closing the lid no longer stops the work — a small quality-of-life shift that matters more than it sounds. For enterprises: cloud sandboxes make permissions, audits and compliance isolation dramatically easier, which is exactly what procurement teams ask about. For developers: agent products are shifting from "heavy local" to "heavy cloud", leaving only the necessary bridge on-device.
The broader signal is architectural. The first generation of agent products tried to live inside the user's machine because that was where the screen and the files were. The second generation is realizing the screen and the files can be bridged, but the thinking and doing belong in a place that scales. Cowork's rewrite is a small, concrete instance of that larger migration, and it is likely to become the default shape for operator-style tools.