← Back to blog
AiAbout 6 min read

Google Put a Freeze on Agent-to-Agent Talk. The Date Matters More Than the Feature.

Published Nov 8, 2026
Google Put a Freeze on Agent-to-Agent Talk. The Date Matters More Than the Feature.

Google shipped google-adk 2.14.0 on 7 November. There is no new model in it, and the release notes read like a filing rather than an announcement. Execution environments, the A2A protocol, the evaluation modules and the core runtime all moved from experimental to stable. Alongside them, 26 auth, environment and app modules and 16 toolset features came out of preview.

Most weeks, a version bump like this gets a paragraph. This one deserves more, because of a single word in it: stable.

What stable means to a team that is not Google

An experimental label is a warning. It says the shape of these calls can change, so build something disposable on top of them. Stable means the opposite commitment. Someone at Google has decided that the function signatures, the request and response objects and the lifecycle of a session are not going to be rearranged in the next point release.

For a team writing agents that talk to other agents, that changes what is worth building. A retry policy built against an experimental interface is a bet. The same policy against a stable one is an asset you can put in a library and forget about.

A2A is the piece that leaves the building. Agent-to-agent messaging has a reputation problem: every framework has an implementation, and no two of them quite match, because the spec kept moving while the implementations shipped. A vendor declaring its own implementation stable is a narrow claim, but it is the kind of claim other teams can quote in a design review when someone asks why the integration will still work in March.

Nine percent of memory and twenty-three percent of time

Google puts two numbers on the release: 23% faster on long multi-turn workflows and 9% lower peak memory. Both are Google's own measurements, published without a harness, a dataset or a reproduction script. Treat them as direction rather than result. The direction is plausible, since a runtime that spends less effort re-establishing state on every turn should get faster as the turn count rises, and the gain should shrink on short tasks.

The interesting part is that these numbers were reported at all for a graduation release. Usually the pitch for a stabilization is reliability, not speed.

Four additions, and what each one is for

**MultiRunConfig** handles concurrent multi-run evaluation. Running the same evaluation suite against several configurations has been the tedious part of agent work: you either serialize the runs and wait, or you write your own harness that drifts from the framework's. Putting the concurrency in the config means the pass rate you report comes from the same code path you ship.

**ToolArgsMatcher** compares tool arguments by meaning rather than string equality. This is a small-sounding change with a large effect on pass rates. If an agent calls a search tool with {"q": "nvidia q3 revenue"} and the golden answer says {"query": "NVIDIA Q3 revenue"}, an exact matcher records a failure and a human spends ten minutes deciding it was fine. Semantic comparison moves those cases out of the false-negative bucket, which also means your evaluation numbers will move when you upgrade. Expect a step change in scores that is not a capability improvement.

**TeamsRunner** puts Microsoft Teams in the runner list. Agent frameworks have been good at Slack and uneven at everything else, so this is the least glamorous entry and possibly the most consequential for enterprises that live in Teams.

**OpenAIDecisionsClassifier** is the odd one: a classifier for OpenAI's Decisions API inside Google's agent toolkit. Cross-vendor support in a first-party SDK is worth noting because it tells you where the teams expect their users to be running things.

Languages, and the surface that got frozen

ADK 2.14.0 covers Python, TypeScript, Go, Java and Kotlin. That breadth is the other half of the stability story. A protocol that is stable in Python and still experimental in Go is stable in name only, because the cross-language clients are the ones that have to agree with each other.

Google's own framing, in the factsheet and the docs, is that A2A now has an API shape teams can build against. Read that as a promise about the wire format and the lifecycle, not about the roadmap. Stable does not mean finished. It means changes from here are supposed to arrive as additions, with the old calls still working.

The awkward question underneath

An agent protocol is only as useful as the number of parties speaking it. Google controls one end. The other end is whoever else decides to implement A2A rather than expose an MCP server, an OpenAPI spec or a proprietary endpoint.

MCP already won the tool-calling argument, in the sense that most agent runtimes now speak it and most tool vendors publish one. A2A is asking a different question: how does one agent hand a task to a different agent, run by a different company, with its own permissions and its own billing. That question is harder, and the answer is more political than technical. A stable spec from one vendor is a starting position in that negotiation, not the outcome.

The practical difference shows up in the shape of the payload. An MCP call says "run this tool with these arguments". An A2A exchange has to say "here is a job, here is who I am, here is what I am allowed to spend, tell me when it is done and send me the artifact". That is a contract between organisations, which is why every conversation about agent interoperability eventually becomes a conversation about identity and authorisation.

A brass cotter pin threaded through two overlapping steel links.

There is also a quieter risk in stabilizing the core runtime. Teams that pinned to experimental builds, which was the only option until last week, now have to migrate to interfaces that are close but not identical. The migration is usually mechanical and always untimely, and it lands on whoever owns the least interesting service in the stack.

What to do with this release

If you are running ADK in production, the first useful step is to diff the four stabilized surfaces against what you import today. The second is to re-run your evaluation suite, because ToolArgsMatcher will change the numbers and you want to know by how much before your own dashboards do.

If you are not on ADK, the release still tells you something about the calendar. Agent interop stopped being a research demo this month and started being a compatibility matrix. That shift is usually followed by procurement questions, then by a standard nobody loves and everybody implements.

Google's 23% and 9% may or may not survive independent testing. The stable label will be quoted far more often than either number, and for longer.

Related articles