2026-04-25
Between April 22 and 23, Anthropic added a switch inside its own desktop app, Claude Cowork. Flip it, and what runs behind Cowork is no longer Claude. It can be GPT-5.5, Gemini 3.1 Pro, DeepSeek V4, or a local model deployed inside your company’s intranet. There was no launch event, no official blog post. The first person to bring it into public view was Paweł Huryn of The Product Compass, in an early-morning X post:
Anthropic shipped it quietly. No announcement. No blog post. Just technical docs. I discovered it by accident. (The Product Compass, 2026-04-23)
Read literally, this looks like a frontier model company belittling itself. Anthropic’s core asset is the Claude model, and yet its own client lets you run GPT and Gemini. That sounds no different from leasing your storefront to a competitor. The reality is the opposite. The actual direction of Anthropic’s move runs counter to the surface reading, and when you read it together with what AWS, Google, and Microsoft each did within the same window, it lays out the single most trackable storyline for agent infrastructure over the next one to two years.
A timing call first: this has little impact on your work today, and it will matter twelve to twenty-four months from now. In the short term, Cowork’s user base is still small, and a fair number of features get downgraded once you swap the model out for GPT (no voice, no Computer use, no cross-user shared projects). Within the 72-hour window, every positive signal you can find essentially comes from vendors themselves and a handful of early adopters. There is no full migration story yet, no independent benchmark. If you are writing code today with Cursor or Claude Code, this news doesn’t change your toolchain.
But it provides a new coordinate for judgment. Read alongside the AWS, Google, and Microsoft moves from the same window, it clarifies the question of where the moat for agent infrastructure actually lands. That is its real value.
To see this map clearly, we need a shared coordinate system. I divide today’s agent infrastructure into four layers, bottom to top:
The model layer is the large model itself. Claude, GPT, Gemini, DeepSeek, and the rest. It sets the upper bound on task capability.
The protocol layer is how you call models. OpenAI’s Chat Completions, Anthropic’s Messages API, and MCP (Model Context Protocol, proposed by Anthropic in late 2024 and now a cross-vendor de facto standard) for calling external tools all sit at this layer. It is characterized by simplicity — text in, text out — and it is where vendors most easily reach consensus.
The runtime layer is the code that actually puts the model to work. Claude Code, Cursor, OpenAI Codex, and the protagonist of this story, Claude Cowork, are all runtimes. The runtime decides how to break a task into steps, which tool to call, how to compress context, how to keep a long-running task from drifting after several hours. Same Claude Opus, Matt Mayer benchmarked it at 77% on SWE-bench inside Claude Code and 93% inside Cursor, a 16-point spread. Whether the runtime is well-built can absorb or amplify the difference of an entire model generation.
The control plane layer is the infrastructure an enterprise needs to deploy a fleet of agents. Which agents are registered, what identity each agent uses when calling external resources, how invocations are audited, how blame is assigned, how budgets are deducted. Developers rarely touch this layer directly. Enterprise IT and the CIO are its primary users. AWS Bedrock AgentCore, Google Vertex AI Agent Builder, and Microsoft Entra Agent ID are all products at this layer.
Across these four layers, one thing is happening: a single model no longer covers all tasks, so users must inevitably go cross-vendor. The “one model takes all” story is no longer true. Frontier models have already specialized into clear strengths and weaknesses. For coding, Opus 4.7 beats GPT-5.5; for long-document retrieval, GPT-5.5 decisively beats Opus 4.7; for multimodal, Gemini is first; for Chinese and high-throughput, DeepSeek is first (see a comparison organized by task dispatch). This fact alone has already pushed every team that uses LLMs seriously into cross-model workflows.
A related but easily confused fact is the talent flow among model companies. NVIDIA paid $20B to take 90% of Groq’s people, Google paid $2.4B to take Windsurf’s core team, SpaceX gave Cursor a $60B acquisition option (the acqui-hire wave). This is not “model companies don’t matter anymore.” Quite the opposite: model teams matter so much, and corporate moats are so unreliable, that buyers are buying the people directly. Capital is betting that core capability flows with the team rather than settling at the company level. Put together, today’s state is: model capability is critical, but it travels with teams, and no single house covers every scenario.
That leaves a clear question for players at the client layer: users will dispatch across models no matter what; the only question is whose client they dispatch from. Anthropic’s move is a response to that question.
Move the lens back one month. On March 21, Anthropic cut off the path that let third-party clients call its API using Claude subscription tokens (HN discussion). Previously, third-party IDE clients like OpenCode, Cline, and Aider could let users run Claude on an Anthropic subscription. After that day, the path was closed; third-party clients could only have users pay-per-token through the API. At the same time, Anthropic added a full anti-impersonation stack inside its own Claude Code: native client identity verification, deliberately planted decoy tools to defeat distillation, inference signatures bound to the API key. The whole stack is designed to make “Claude Code is Anthropic’s official client” verifiable at the protocol level.
Place those two moves alongside the April 22 Cowork 3P launch, and the direction becomes clear.
March: shut the door on other people’s clients freeloading on my subscription.
April: open the door for my client to plug into other people’s models.
Read directly, the two moves have a two-faced logic: nobody else gets to freeload on my subscription subsidy; I get to freeload on theirs. But the underlying judgment is singular: the client is the sticky asset; the model is a passing good. The model can be swapped, but the client running the model has to be Anthropic’s own; the subscription has to be tied to Anthropic’s own account system; the MCP tool whitelist, permission policies, audit, and telemetry are all defined by the Anthropic client layer. Anthropic essentially said this themselves in the April 21 blog post on Managed Agents:
We’re opinionated about the shape of these interfaces, not about what runs behind them.
Translation: our product decides what the interface looks like, not what model runs behind it. Read alone, the line is unremarkable. Read together with Cowork 3P, it is two faces of the same strategy.
Why is Anthropic taking this path now? Because the differentiation window at the model layer is shrinking, and they must be seeing it internally. This spring, Claude Opus jumped from 4.6 to 4.7, and the community produced a wave of “Opus 4.7 is dogshit” complaints. There are already users on Substack writing I Replaced Claude Code With a $45/Month Multi-Model Stack. Anthropic cannot block this momentum. Better to ride it: if you want to dispatch across models, dispatch inside my client; don’t jump to someone else’s.
The detail most directly tied to the business model is that Anthropic earns no subscription fee on the 3P path. The docs state plainly: “Third-party deployments have no seat-based licensing from Anthropic.” If you take this path and run GPT-5.5, the money goes to OpenAI. Run Gemini, the money goes to Google Cloud. Anthropic’s revenue on this path is zero.
Revenue is just the surface, though. The deeper anomaly is this: Anthropic isn’t getting the data either.
On the Bedrock and Vertex paths, prompts and completions never pass through Anthropic infrastructure; data sits inside the customer cloud. The gateway path is the same. The client telemetry contains no prompt or completion content, only usage and debug metrics, and admins can fully disable telemetry through MDM. Which means if an enterprise deploys Cowork on the Bedrock+GPT path, what Anthropic gets is: a logo on the user’s desktop, and almost nothing else.
Why is this strange? One of a frontier lab’s core assets is user behavior data. Data feeds RLHF (reinforcement learning from human feedback for alignment), data clarifies how agents work in real settings, data trains the next model. OpenAI made the Responses API stateful on the server side, partly so that session state and reasoning traces stay in their hands. That is the standard playbook for a leading model company. Anthropic’s choice here runs the other way. They actively give that data up, effectively betting that client brand plus enterprise-grade governance controls are more worth defending than a model-layer data flywheel and subscription fee.
This is a big bet. If it lands, Anthropic occupies a cross-cloud, cross-model client entry point in the post-agent landscape, equivalent to being the Chrome or VS Code of the LLM era. If it loses, they capture neither money nor data, leaving only brand placement. The fact that Anthropic chose this path actively, and shipped it without a launch, says they themselves recognize how unconventional the bet is: unwilling to let the market read it as “the model company conceding,” and unwilling to make it a big news event that misaligns expectations with investors and partners.
Within the same window as Anthropic, AWS, Google, and Microsoft were all moving. SiliconAngle called it the agent control plane race hits overdrive at Next 2026. The three vendors took completely different shapes.
AWS bet on runtime plus registry. Bedrock AgentCore is the runtime where the agent runs, and Agent Registry is the directory enterprises use to manage “which agents do we have.” It sounds reasonable, but in InfoWorld’s coverage, Forrester’s Charlie Dai called out a key constraint: the registry has to run inside an AWS account. His phrase was “strategic limitation.” Registered agents can call external systems, but the registry itself does not leave AWS. Thoughtworks Tech Radar Vol 34 makes the implementation guidance even blunter: use only the runtime portion of AgentCore and put the agent’s core logic outside (e.g., in LangGraph). Two independent sources arriving at the same direction.
Google bet on tool governance. Vertex AI Agent Builder plus ADK (the dev framework) plus Apigee (the enterprise API gateway) form a supply chain. The pivotal piece is Apigee: it auto-converts an enterprise’s existing thousands or tens of thousands of APIs into MCP tools, feeding them into its own API Registry. Developers do not need to wrap them again; agents can use them off the shelf. The bet on this path is: the enterprise’s API gateway is already on Google Cloud, so the entry point for agents calling external systems is taken over by extension.
Microsoft bet on identity. It registers each agent as a service principal (the standard enterprise IT term for an “automation account”) inside Entra (formerly Azure AD), so each agent has its own identity, permissions, and lifecycle, just like an employee. Agent 365 is the governance layer on top, GA in May 2026, priced at $15 per user per month, gated by a Microsoft 365 Copilot license prerequisite (Forbes 4-10 detailed comparison). The bet is: the enterprise’s identity system is already anchored in Active Directory, so folding agent identity into the same system is the most natural extension.
Looking at all four side by side:
| Who | Main bet | Which layer |
|---|---|---|
| Anthropic | Cowork, Claude Code, Managed Agents | Client + runtime |
| AWS | Bedrock AgentCore + Agent Registry | Control plane (runtime-leaning) |
| Vertex Agent Builder + ADK + Apigee | Control plane (tool-governance-leaning) | |
| Microsoft | Foundry + Entra Agent ID + Agent 365 | Control plane (identity-leaning) |
One thing is worth calling out about Anthropic’s position. Multi-model clients are not a Cowork invention. Cursor, GitHub Copilot, and Google Antigravity have supported multiple model vendors for a while. But those clients are either product companies (Cursor, Anysphere) or cloud/platform companies (Copilot is Microsoft, Antigravity is Google). Anthropic is the first vendor that is itself a frontier model company, ships its own client, and lets you run other people’s models inside that client. The combination has no precedent in the industry, and the direction runs against the standard posture of frontier labs.
The three cloud vendors share a common problem with their bets: the control plane is harder than the client at building developer stickiness. Developers spend their day in IDEs, CLIs, and code review, not in IAM consoles. Registries, observability, and audit are must-haves for enterprise admins, but low-frequency surfaces for the people actually writing code. The cloud vendors’ bets sit closer to the CIO; Anthropic’s bet sits closer to the developer. Which weight carries more depends on the industry and the company. In compliance-driven sectors like finance, healthcare, and government, the CIO weighs more, and the cloud vendors win. In startups and R&D-driven companies, the developer weighs more, and Anthropic wins. The middle ground is the most interesting battlefield over the next one to two years.
The map is laid out. Back to where you sit. How does this land for you? Three scenarios cover the next one to two years:
Scenario one: you are the technical lead at a startup, choosing an agent toolchain. If you bet on Cowork, you are betting on Anthropic’s client-stickiness wager, and what you get back is model-layer flexibility (you can swap among GPT, Gemini, and Claude at any time). If you bet on Cursor, the model-layer flexibility is similar, but the toolchain is locked into Cursor’s own product direction. If you bet entirely on OpenAI Codex, you get tight integration with the Responses API, at the price of locking in model choice and almost no path to self-hosting. There is no absolute winner among the three, but each path has something it is explicitly giving up. Seeing what you are giving up matters more than seeing which house is hottest today.
Scenario two: you are in enterprise IT, and your CIO recently asked you to draft an agent governance plan. The three cloud paths (AWS Registry, Google Apigee, Microsoft Entra Agent ID) all sell you “how to manage a fleet of agents,” but each draws the governance boundary inside its own product line. The AWS registry only covers agents running on AWS; Microsoft’s identity governance only covers agents enrolled in Entra. If you are heavy on Azure, Microsoft’s identity path is the most natural. If you are heavy on AWS, AgentCore is the convenient pick. If you are multi-cloud, you will find that no one provides a cross-cloud governance plane, and you will have to stitch it yourself. That is not a product bug. It is commercial intent.
Scenario three: you are on the investing side, looking at agent infra companies. The single most useful question is: “If the model layer commoditizes and the protocol layer fully opens, what does this company have left.” Anthropic’s answer is Cowork, Claude Code, the MCP ecosystem, and enterprise-grade governance controls. OpenAI’s answer is Codex, the Responses API, and the Microsoft channel. Cursor’s answer is the IDE experience plus its own team. A company that cannot answer this question takes a discount on its long-term position. Protocol-layer openness in the MCP family is accelerating, and cross-vendor unification is the trend, but plugging into open protocols does not equal escaping platform lock-in. The governance flow (registration, identity, audit, billing) still falls inside each vendor’s private control plane. When reading a prospectus or product doc, ask about protocol interoperability and governance interoperability separately.
This Cowork 3P launch has little impact on engineering practice today, but it is one concrete signal in a cluster of moves happening at once. Anthropic cut third-party clients in March and opened third-party models in April; AWS shipped AgentCore Registry; Google plugged Apigee into Vertex; Microsoft shipped Entra Agent ID plus Agent 365; OpenAI made the Responses API a stateful private control plane. Every house is reinforcing its strongest layer, and every house is also waiting for the others to give ground at some layer first. There is no winner today, but the directions of the bets are already drawn on the map.
Treat the model layer as a commodity over the next one to two years, and treat the client, runtime, and control plane as parallel sets of moats. Anthropic’s strange concession is the move on this map most worth remembering: trade the subscription fee and data at the model layer for retention at the client layer. Whether they win, we will know in a couple of years.