\n<\/p>\n
Last week, Google shipped Agent Development Kit (ADK) 2.0.0 stable, and the same week, a2a-sdk hit 1.0.3 stable. Together, they’re a statement: Google has a complete, production-ready agent framework and is willing to build it without OpenAI alignment.<\/p>\n
This matters more than it looks because of what it exposes: OpenAI and Google are building agent infrastructure for fundamentally different problems.<\/p>\n
The Release: ADK 2.0.0 Stable<\/p>\n
Google’s jump from 1.29 to 2.0 signals a defined breaking-change boundary. The API surface is stable enough to commit to. You can now build production agents on ADK without prerelease churn risk.<\/p>\n
What makes this significant isn’t the version bump \u2014 it’s the timing. ADK 2.0 stable and a2a-sdk 1.0.3 stable landed in the same week. That’s coordinated messaging. Google’s narrative is clear: “We have a complete, stable, production-ready multi-agent framework.”<\/p>\n
The Competitive Fault Line: A2A Rejection<\/p>\n
Here’s what changed the conversation: In March 2026, OpenAI received a 1,200-line pull request implementing Agent-to-Agent (A2A) protocol support in their agents SDK. They declined it.<\/p>\n
A2A is Google’s answer to multi-agent coordination. It’s a standardized protocol for agents to discover, call, and share context with each other. It solves a concrete problem: if you want to compose capabilities across multiple AI agents (and you do \u2014 no single agent model is good at everything), how do you do that without reinventing message protocols every time?<\/p>\n
OpenAI’s “no thanks” wasn’t hostile \u2014 it’s still an open community feature request. But it signals something fundamental: OpenAI and Google are optimizing for different things.<\/p>\n
Google is betting on agent-to-agent coordination \u2014 a protocol layer that lets you build systems where agents specialize and delegate to each other.<\/p>\n
OpenAI is betting on per-agent capability \u2014 Sandbox Agents (shipped in the same window) that let a single agent operate a filesystem, run arbitrary code, and persist snapshots.<\/p>\n
Both are real problems. They’re just orthogonal.<\/p>\n
The Framework Landscape: Where You Stand<\/p>\n
If you’re evaluating frameworks for a production AI agent system, here’s what stability means:<\/p>\n
Framework
\nStatus
\nMulti-Agent Story
\nInterop<\/p>\n
Google ADK 2.0.0
\nStable
\nA2A protocol (1.0.3 stable)
\nA2A-based; open protocol<\/p>\n
OpenAI Agents 0.17
\nStable
\nSandbox Agents + handoff-based
\nSDK-internal only<\/p>\n
LangChain 0.3
\nStable
\nLangGraph composition
\nAdapter-based for A2A<\/p>\n
Microsoft Semantic Kernel
\nStable
\nPlugin-based orchestration
\nNative A2A support<\/p>\n
ADK 2.0.0’s stability matters because it means you can adopt the A2A protocol without worrying about breaking changes. If interoperability across agent systems matters to your architecture (and it should \u2014 monolithic agents are a bottleneck), ADK gives you a stable foundation.<\/p>\n
OpenAI’s refusal of A2A doesn’t make OpenAI agents bad. Sandbox Agents are genuinely powerful \u2014 they let your agent run code, modify files, and operate an environment. For single-agent, high-autonomy workloads, that’s valuable. But if you need your agent to collaborate with specialized agents built by your team or third parties, you’re back to handoff-based coordination inside the SDK.<\/p>\n
What This Means for Your Architecture<\/p>\n
Three questions to ask yourself:<\/p>\n
1. Do you need single-agent or multi-agent?If a single agent with sandbox access solves your problem, OpenAI agents work great. If you’re building a system where agents specialize (e.g., one reads docs, one retrieves, one reasons, one executes), ADK + A2A gives you a protocol-based way to compose them.<\/p>\n
2. Do you need portability?A2A is a protocol. It means your agents can interoperate with frameworks that speak A2A (Google ADK, LangChain, Semantic Kernel). OpenAI’s handoff model is SDK-specific \u2014 your orchestration logic lives in OpenAI agent code, not in a portable protocol.<\/p>\n
3. Do you need capability stability?ADK 2.0.0 stable and a2a-sdk 1.0.3 stable mean you can depend on these APIs. OpenAI’s agent SDK is stable too, but multi-agent coordination still relies on feature requests and community pressure.<\/p>\n
The Code Difference: One Example<\/p>\n
Here’s how the approaches differ in practice:<\/p>\n
With OpenAI agents and handoff:<\/p>\n
from openai.agents import Agent<\/p>\n
agent_a = Agent(
\n model=”gpt-4-turbo”,
\n tools=(retrieve_docs),
\n)<\/p>\n
agent_b = Agent(
\n model=”gpt-4-turbo”,
\n tools=(reason_and_execute),
\n)<\/p>\n
# Coordination is SDK-internal
\nresponse = agent_a.run(“Get docs and ask agent_b to reason about them”)
\n# Agent A has to decide to hand off; agent B has no standard way to discover agent A<\/p>\n
Enter fullscreen mode<\/p>\n
Exit fullscreen mode<\/p>\n
With Google ADK + A2A:<\/p>\n
from google.genai.adk import Agent
\nfrom a2a_sdk import A2AClient<\/p>\n
agent_a = Agent(
\n name=”document_retriever”,
\n model=”gemini-2.0-pro”,
\n tools=(retrieve_docs),
\n)<\/p>\n
agent_b = Agent(
\n name=”reasoner”,
\n model=”gemini-2.0-pro”,
\n tools=(reason_and_execute),
\n)<\/p>\n
# A2A-based discovery and calling
\nclient = A2AClient()
\nagent_b = client.discover(“reasoner”)
\nresponse = agent_b.call(query=”Reason about these docs”, context=docs)<\/p>\n
Enter fullscreen mode<\/p>\n
Exit fullscreen mode<\/p>\n
The second approach is more portable \u2014 agent_b doesn’t have to live inside the same process or SDK context as agent_a. It’s a network boundary that frameworks can standardize around.<\/p>\n
The Strategic Question<\/p>\n
This is the moment where framework choice locks you into an architectural commitment. If you’re building:<\/p>\n
A single, high-autonomy agent: OpenAI agents with Sandbox Agents will give you more capability per agent.<\/p>\n
A system of specialized agents: ADK + A2A gives you a protocol layer.<\/p>\n
A hybrid approach: LangGraph (LangChain) and Semantic Kernel both support A2A, so you can start with composition and migrate capability where it matters.<\/p>\n
Google’s stability release says: “We’re committed to this direction.” OpenAI’s rejection of A2A says: “We’re optimizing for something else.” Both are valid bets. Your architecture decides which one wins for you.<\/p>\n
The real shift is that you now have two stable, competing visions for what agent infrastructure should be. ADK 2.0.0 stable didn’t change what’s possible \u2014 it changed what’s dependable.<\/p>\n
Next: If you’re upgrading to newer agent frameworks, watch for breaking changes. OpenAI’s 0.13 \u2192 0.17 window introduced two silent breaks that will bite you if you’re not careful.<\/p>\n