You're picking an agent framework this month. OpenAI open-sourced theirs. Anthropic locked theirs to Claude. And Google shipped ADK — Agent Development Kit — a toolkit for building AI agents that do things on your behalf. You stopped tracking Google's naming after the third acronym, which is fair.

But here's what matters: ADK is the only major framework that natively speaks both A2A and MCP — the two protocols the rest of the industry treats as someone else's problem. A2A (Agent-to-Agent) lets AI agents talk to each other. MCP (Model Context Protocol) lets agents plug into external tools and data — like USB ports for AI. OpenAI's SDK ships MCP support but ignores A2A. Anthropic's SDK ships MCP (they invented it) and treats A2A as optional. Google ships both out of the box.

That's a genuine technical advantage. It's also the opening move in the most carefully designed lock-in play in the current AI infrastructure war.

Three Lock-In Strategies

Every major AI company captures developers differently. This is the taxonomy nobody's drawing on whiteboards yet, and it explains why ADK's protocol advantage isn't charity.

OpenAI captures at the SDK layer. pip install openai, follow the quickstart, build something in an afternoon. The API is clean, the docs are good, the ecosystem is massive. By the time you realize you're locked in, you've got 40,000 lines of code calling OpenAI-specific endpoints. Switching means rewriting. The SDK is the moat.

Anthropic captures at the model layer. You stay because Claude is good at the things you need — long context, instruction following, code. The SDK is secondary. The model quality is the gravity. If a better model shows up, you leave. If it doesn't, you don't. Simple physics.

Google captures at the infrastructure layer. ADK is free. The protocols are open. The production path runs through Vertex AI Agent Engine — Google's managed runtime — and infrastructure lock-in is the hardest kind to leave. You don't notice the walls going up because each individual brick looks like a convenience.

This isn't speculation. It's architecture.

What "Native A2A" Actually Looks Like

Most framework comparisons stop at "supports A2A." Nobody explains what that means when you open a terminal.

When you build an ADK agent, you expose it as an A2A-compliant server with a single decorator. The framework generates the required Agent Card — a JSON manifest that tells other agents what yours can do, what inputs it accepts, what outputs it returns. Other A2A-compliant agents discover yours by hitting /.well-known/agent.json, read the card, and start a Task — A2A's unit of work.

On April 3, Google shipped ADK v1.24.0 with workflow graph orchestration, auto-rendering UIs, and an integrations ecosystem — AgentOps, Arize, MLflow, n8n, 200+ SaaS connectors via StackOne. Four languages: Python, TypeScript, Go, Java. Over 200 models through Model Garden — Gemini, Claude, GPT, Llama, Mistral.

The framework handles A2A task lifecycle (submitted → working → completed/failed), streams partial results via Server-Sent Events, and manages artifact exchange between agents. MCP runs alongside: your agent calls external tools through MCP while coordinating with peer agents through A2A. Two protocols, one runtime, zero glue code.

On paper, this is exactly what multi-agent systems need. In practice, it's the first layer of a very specific funnel.

How the Trap Closes

ADK runs open-source locally. You can develop, test, and prototype without touching Google Cloud. This is by design — the on-ramp has zero friction.

Production means Vertex AI Agent Engine — where Google bills $0.00994/vCPU-hour with LLM tokens charged separately, pricing active since February 2026. Reasonable rates. Nothing alarming on the invoice.

But the pricing isn't the real trap. The protocol gravity is.

Here's how it works: if your multi-agent system depends on A2A for coordination, and ADK agents speak A2A natively, every new agent you add to the system pulls toward ADK. Not because ADK is better at the task — because ADK is better at the protocol. You pick ADK for Agent #3 because Agents #1 and #2 already speak A2A. You pick it for Agent #4 for the same reason. Each agent strengthens the network effect.

Every ADK agent in development works fine on your laptop. Every ADK agent in production pulls toward Vertex. Google Cloud manages your A2A task routing, your artifact storage, your agent discovery. The more agents you deploy, the deeper the integration. The deeper the integration, the higher the switching cost.

This is classic platform economics dressed in open-source clothing. The framework is free. The protocol is open. The production runtime is Google's, and by the time you're running fifteen agents coordinating via A2A on Vertex, "just switch to AWS" is a six-month migration project.

Google didn't build an open protocol for interoperability. Google built an open protocol for adoption, and a proprietary runtime for revenue.

The Interop Gap

ADK's A2A advantage has a practical ceiling: the protocol mostly connects ADK agents to other ADK agents. Neither Anthropic's nor OpenAI's agent SDKs expose A2A endpoints natively. Wiring a cross-vendor agent mesh still requires custom middleware — the exact glue code that native protocol support promised to eliminate.

This doesn't invalidate ADK's architecture. It contextualizes it. The protocol advantage is real within Google's ecosystem. Cross-ecosystem, you're still writing adapters. The gravity pulls inward, not outward.

What This Means

Google Cloud Next starts April 22. Session BRK3-022 promises ADK's roadmap and claims Google "relies on ADK for its own internal engineering." The slide to watch isn't the feature list — it's whether they demo a non-Google agent speaking A2A to an ADK agent without custom middleware. That demo either exists or it doesn't.

ADK's protocol support is genuinely ahead of OpenAI's and Anthropic's offerings. The technical architecture is sound. Four-language support, 200+ model compatibility, SSE streaming, and artifact exchange are real capabilities, not vaporware.

But the question was never "is ADK good?" The question is "where does ADK-good take you?" And the answer is Vertex AI Agent Engine, billed per vCPU-hour, with switching costs that compound with every agent you deploy.

Three companies. Three lock-in strategies. OpenAI bets you won't rewrite your code. Anthropic bets you won't find a better model. Google bets you won't migrate your infrastructure.

Google's bet is the most patient. It's also the hardest to escape — if anyone ever arrives.