I've been dissecting this split all week — Anthropic's managed harness, the missing hallway between vendors, Google's pricing gravity, the three-way cost fork. You know the punchline already: the model swaps out easily, the orchestration layer doesn't.
Anthropic shipped Managed Agents on April 8. OpenAI pushed its Agents SDK update on April 3. Google dropped ADK changes today, April 11 — nine days, three lifecycle APIs. Now I can finally show you why the differences matter, in the only language that doesn't lie: code.
Google played their hand
Google dropped two blog posts today — an appetizer for Cloud Next on April 22. The Agent Development Kit now supports Gemini 3 Pro/Flash and TypeScript. Open-source. Code-first. All the right buzzwords.
But "open-source" describes the on-ramp, not the highway. Deploying means Vertex Agent Engine. State means Vertex Sessions. Tool governance means Cloud API Registry. Six months of "convenient" integrations later, migrating off Google means rewriting your entire agent architecture. Not a single decision locks you in — a hundred small ones do, each too trivial to fight individually.
With today's announcement, all three vendors have shown their cards. Time for the comparison nobody will enjoy.
Three create() calls, three prisons
# Anthropic (April 8): they own your state, you rent access
client = anthropic.Anthropic()
agent = client.agents.create(model="claude-sonnet-4-20250514", tools=[mcp_tool])
session = client.sessions.create(environment_id=env.id)
# Append-only event log on their servers. Recovery: wake(session_id).
# They handle containers, scaling, persistence. You handle the invoice.
# OpenAI (April 3 update): you own everything, including the 3 AM pages
from agents import Agent, Runner
agent = Agent(name="reviewer", model="gpt-4.1", tools=[my_tool])
result = Runner.run_sync(agent, "Review this PR")
# State: your SQLite. Recovery: your code. Scaling: also your code.
# Supports 100+ models via AnyLLM. Freedom has a very specific smell: ops sweat.
# Google ADK (April 11): open-source lobby, proprietary elevator
from google.adk import Agent
agent = Agent(model="gemini-3-pro", tools=[vertex_tool])
# State: Vertex Sessions. Tools: Cloud API Registry. Deploy: Agent Engine.
# "Portable" the way a tree is portable — technically possible, practically a funeral.
Three snippets, three incompatible answers to every question that matters in production:
Where does state live? Anthropic's append-only log on their servers. Whatever SQLite file OpenAI's SDK left on your laptop. Google's Vertex Sessions. Your debugging story, audit trail, and disaster recovery all follow this choice off a cliff — and you make it on day one.
How do agents hand off work? Anthropic spawns child agents from sessions (still "research preview," which translates to "blame yourself when it breaks"). OpenAI uses local handoffs — agent A passes a baton to agent B in your own process, like a relay race in your basement. Google routes through ADK orchestration plus A2A for cross-vendor calls, which sounds great until you realize A2A handles communication, not state synchronization.
What happens at 3 AM? Anthropic: wake(session_id), the platform resumes from its event log. OpenAI: you wrote recovery logic, right? You did write recovery logic? Google: Vertex handles it. You are on Vertex. Of course you're on Vertex.
What's actually missing
Every time I write about this split, someone replies "but MCP solves this" or "A2A fixes it." No. MCP standardizes tool connections — done, works beautifully. A2A standardizes how agents talk to each other across vendors — the Linux Foundation adopted it in December, and 150+ organizations now back it. Neither standard touches how agents spawn, how they persist state, how they delegate tasks, or how they recover from failure.
I wrote about this structural gap two days ago in Every Vendor Built a Room. Nobody Built the Hallway. The code-level comparison here only sharpens the point: the gap isn't philosophical, it's mechanical. That's the layer that generates the lock-in. And no one is building a neutral standard for it, because all three vendors profit from the void. Standardizing agent lifecycles would mean commoditizing the exact layer each company uses to keep you on their platform. Don't hold your breath.
The honest cheat sheet
Anthropic: Best-engineered managed platform. That 60% TTFT reduction from their April 8 engineering blog — decoupling brain and hands — is real engineering, not slideware. You pay with vendor dependency and session-hours that bill even while your agent sits idle waiting for a human to reply.
OpenAI: Maximum portability, 100+ models as of the April 3 release, zero managed infrastructure. Perfect for teams with strong ops culture. A slow-motion disaster for everyone else.
Google: If you're already on Google Cloud, the gravitational pull is rational. Just count your Vertex dependencies every quarter so the eventual "should we migrate?" conversation starts with data, not panic.
The punchline you already know
The model wars were the trailer. The orchestration wars are the feature film. And the admission ticket is session.create() — a function call that gets more expensive to undo every day you run it in production.
Choose carefully. Or don't — all three vendors are counting on "don't."
