Anthropic just did something clever and almost nobody is talking about the real implication. When they launched Claude Cowork in January 2026, the headline was “Claude Code power for knowledge workers.” What they actually shipped was something more structurally significant: they moved the execution layer from their servers to your laptop.
Let me explain what that means and why it matters for everything from commerce protocols to the future of how AI agents actually operate in the wild.
The Architecture Nobody Is Discussing
Claude Cowork runs a lightweight Linux virtual machine — Ubuntu 22.04 LTS on ARM64 — directly on your local machine using Apple’s Virtualization Framework. When Claude writes a script in Cowork, it executes on your hardware, checks the output locally, and iterates without ever sending your files to Anthropic’s servers. The reasoning still happens in the cloud. The model inference still runs on Anthropic’s GPUs. But the execution — the actual doing — happens at the edge.
This is the client-side vs. server-side processing debate from web development, playing out in real time in AI. And if you have been building websites for any length of time, you recognize the pattern immediately.
In the early web, everything ran server-side. Every button click, every form validation, every calculation — round trip to the server and back. Then JavaScript matured, browsers got powerful, and the industry realized: why send everything to the server when the client machine sitting right there can handle the work? The result was the modern web — React, Vue, client-side rendering, edge functions. Faster, cheaper, more private.
Cowork is that same architectural shift applied to AI agents. Anthropic kept the expensive part (model inference) centralized where they control quality and monetization. But they pushed the operational overhead — file manipulation, script execution, iteration loops, document creation — to your device. Research from hybrid edge-cloud architectures shows this split can deliver energy savings of up to 75% and cost reductions exceeding 80% compared to pure cloud processing.
Why This Is Strategically Brilliant for Anthropic
The economics tell the story. In 2025, the AI industry hit a structural inflection: inference cost — not training cost — became the primary economic bottleneck. Running models 24/7 to serve millions of agentic workflows is prohibitively expensive at scale. Cowork solves this by making the user absorb execution costs. Your CPU runs the scripts. Your disk stores the files. Your RAM holds the working state. Anthropic only burns GPU cycles on the reasoning step.
This is not a minor optimization. When Claude iterates on a document inside Cowork — running a Python script, checking output, adjusting, running again — that entire feedback loop happens locally in milliseconds. The same workflow on Claude.ai requires a network round trip for every iteration. Cowork can iterate 10 to 100 times faster on operational tasks because the execution environment is local. The user gets a better experience. Anthropic gets lower infrastructure costs. Both sides win, but Anthropic wins structurally.
There is a data play here too. Enterprise adoption of AI has been throttled by a single concern: where does my data go? Cowork answers that cleanly. Financial records, legal documents, proprietary code, patient data — none of it leaves the organizational network during execution. The model sees what it needs to reason about, but the files themselves stay local. That is a compliance unlock for HIPAA, GDPR, SOC 2, and every other framework that has been blocking enterprise AI adoption. Eighty-four percent of organizations now expect to run AI on-premises or at the edge alongside cloud, and Cowork is positioned directly in that path.
MCP Is the Nervous System
Edge execution is only half the story. The other half is connectivity — and that is where the Model Context Protocol becomes critical infrastructure.
MCP, launched by Anthropic in November 2024, is an open-source standard for connecting AI agents to external tools and data sources. The analogy everyone uses is “USB-C for AI” — one standardized interface instead of custom integrations for every tool. Before MCP, connecting M applications to N tools required M×N unique integrations. With MCP, it is M+N. Linear scaling instead of quadratic.
The adoption curve has been vertical. From 100 MCP servers at launch to 5,867 by mid-2025 to 97 million monthly SDK downloads by February 2026. OpenAI integrated MCP across their Agents SDK and ChatGPT Desktop in March 2025. Google DeepMind confirmed Gemini support. Microsoft, AWS, Cloudflare, PayPal, and MongoDB followed. By December 2025, MCP was placed under the Linux Foundation’s Agentic AI Foundation governance alongside six co-founders: OpenAI, Anthropic, Google, Microsoft, AWS, and Block.
For Cowork specifically, MCP is what transforms a local VM from a sandboxed execution environment into a connected agent. MCP servers give Cowork access to Slack, Notion, Figma, Asana, Shopify — any service with an MCP server. In late January 2026, Anthropic launched MCP Apps, which render interactive UI components — dashboards, forms, data viewers — directly inside the agent interface through sandboxed iframes. Nine launch partners including Figma, Slack, and Asana shipped day one.
The transport layer has also matured. The original stdio transport (standard input/output) handles local connections. For remote servers, Streamable HTTP replaced the deprecated SSE transport in March 2025 as the production standard. This means MCP works across both local tools and cloud services with a unified protocol.
Google’s UCP and OpenAI’s ACP: Commerce Gets an Agent Layer
Now zoom out. If MCP is how agents connect to tools, what happens when agents need to buy things?
Google answered this on January 11, 2026 with the Universal Commerce Protocol. UCP is an open standard co-developed with Shopify, Etsy, Wayfair, Target, and Walmart, and endorsed by over 20 organizations including Visa, Mastercard, Stripe, American Express, Adyen, Best Buy, and The Home Depot. It defines three core capabilities: agent-initiated checkout, cross-service identity linking, and post-purchase order management. UCP gives agents a standardized way to discover products, initiate purchases, and manage orders without custom merchant integrations.
OpenAI’s response was the Agentic Commerce Protocol, announced in partnership with Stripe and built on their Commerce Platform for ChatGPT. ACP focuses on the checkout and merchant integration layer — how agents securely complete transactions, handle payment authorization, and manage the trust relationship between an agent acting on behalf of a user and a merchant accepting that agent’s authority to transact.
Google also launched the Agent Payments Protocol (AP2) alongside UCP, which handles the specific problem of payment authorization for agents — how a merchant or payment processor can verify that an agent is authorized to spend a user’s money. Coinbase contributed x402, repurposing HTTP status code 402 (Payment Required) for autonomous micropayments where agents negotiate and pay for API access, data, or services on behalf of users without explicit per-request authorization.
The stack is forming fast. MCP for tool access. A2A (Agent-to-Agent protocol) for inter-agent coordination. UCP plus AP2 for commerce standardization. ACP for merchant checkout. x402 for execution-layer micropayments. Each protocol solves a different layer of the same problem: how do autonomous agents operate in the real economy?
The Agent SDK Ties It Together
Underneath all of this — Cowork, MCP, the commerce protocols — sits the Claude Agent SDK. Released in March 2025, the SDK formalizes the three-phase agentic loop that powers both Claude Code and Cowork: gather context, take action, verify work. It ships with built-in tools for file operations, shell execution, web search, and MCP integration across Python, TypeScript, Go, Java, Ruby, PHP, and C#.
The significance is in the decoupling. The Agent SDK separates the agentic architecture from the interface. Claude Code uses it through a terminal. Cowork uses it through a desktop GUI. Third-party developers use it through the API. Same primitives, different surfaces. This is why Anthropic partnered with ServiceNow in January 2026 to make Claude the default model powering their Build Agent — the SDK is a platform, not a product.
In early 2026, Anthropic added Agent Skills — organized instruction bundles that agents discover and load dynamically. Skills let agents perform better at specific tasks without hardcoding capabilities. Combined with MCP for external tools and the commerce protocols for transactions, you get a complete agent operating system: reasoning (Claude model), execution (local VM or cloud), connectivity (MCP), commerce (UCP/ACP), and specialization (Skills).
The Convergence: What This Actually Means
Here is where the threads weave together. Today in March 2026, the architectural picture looks like this:
At the top, you have application surfaces — Cowork for knowledge workers, Claude Code for developers, ChatGPT for consumers, Gemini for Google’s ecosystem. These are the interfaces people interact with. Below that, the Agent SDK and equivalent frameworks handle the agentic loop — the reasoning, planning, and verification cycle. Below that, MCP provides the integration layer — 5,867 servers connecting agents to every major SaaS platform, database, and service. Below that, UCP, ACP, AP2, and x402 form the commerce and payments layer — standardized protocols for agents to transact in the real economy. And at the bottom, the execution happens either at the edge (Cowork’s local VM) or in the cloud, depending on the task requirements.
The edge execution piece is what makes this whole stack viable at scale. If every agent action required a cloud round trip, the inference costs would be staggering. By pushing execution local — file operations, script iteration, document manipulation, data processing — the cloud only handles what it must: model reasoning. The edge handles everything else. This is the same economic logic that moved web applications from server-rendered pages to client-side JavaScript. It is the same logic that put CDNs at the edge of the network instead of serving every asset from origin. And it is the same logic that will determine which AI companies survive the inference cost crisis of 2026 and 2027.
The governance structure suggests this is not a temporary arrangement. The Linux Foundation’s Agentic AI Foundation — with six co-founders spanning every major AI lab and cloud provider — mirrors the W3C’s role in web standards. These protocols are being designed for permanence, not experimentation.
What I Am Watching
Three things specifically. First, whether MCP becomes the true universal standard or fragments under competitive pressure. Ninety percent of organizations were expected to use MCP by end of 2025, but OpenAI and Google both have incentives to push their own protocol extensions. The Linux Foundation governance helps, but interoperability is not guaranteed.
Second, how the edge execution model scales beyond macOS. Cowork launched on Mac in January 2026 and added Windows in February, but the real test is whether this architecture works on lower-powered devices, mobile, and eventually in browser-based environments. The client-side processing analogy breaks down if the client is not powerful enough to handle the workload.
Third, the commerce protocols. UCP has 20-plus endorsers. ACP has Stripe. AP2 has Google and the card networks. But none of these have been tested at scale with real autonomous agent transactions — the edge cases around fraud detection, inventory conflicts, tax compliance, and customer support when agents transact on behalf of users are largely unsolved. McKinsey identifies agentic commerce as transformative, but transformative and production-ready are different things.
The pattern I keep coming back to is this: Anthropic built the execution layer (Cowork), the connectivity layer (MCP), and the developer layer (Agent SDK). Google built the commerce layer (UCP/AP2). OpenAI built the checkout layer (ACP). The pieces are from different companies but they fit together like they were designed as one system. That is either remarkable convergence or evidence that this is where computing is inevitably heading.
Either way, the next 18 months will tell us whether edge-native AI agents become the new browser — the universal client through which humans interact with digital services — or whether this is an architectural experiment that collapses under its own complexity. I am betting on the former, and I think the Cowork launch is the clearest signal yet that the people building these systems are betting the same way.
Leave a Reply