Google’s agent framework just grew up. On November 7, 2026, Google shipped Agent Development Kit 2.14.0, and the headline is not a new model or a flashy demo. It is stability. Execution environments, agent-to-agent communication, evaluation and the core runtime all graduate from experimental to stable in a single release, which is Google’s way of saying ADK is ready for production workloads — not just prototypes.
That matters because ADK has quietly become one of the most-used ways to build AI agents. The google-adk package on PyPI has been downloaded more than 133 million times in total, including over 10 million downloads in the last 30 days. When a framework at that scale promotes its core to stable, every team building on it has to pay attention.
What “stable” actually means here
Experimental APIs can change without warning. Stable APIs come with a compatibility promise, so code written against them keeps working in future releases. ADK 2.14.0 moves 26 modules covering auth, environments, the app layer, the CLI and caching to stable, alongside 16 toolset features.
The graduated pieces are the ones agent builders touch every day. BaseEnvironment and LocalEnvironment are now stable, along with platform-specific environments for Daytona and E2B, the sandbox providers that let agents run code safely away from your own machines. The evaluation classes are stable too, which means the way you test agents is now a supported contract rather than a moving target. The same goes for the core runtime that ties agents, tools and sessions together.
If you have been holding off on ADK because its core felt unfinished, that excuse is gone. If you already built on it, this release is mostly good news: the APIs you rely on are now promised to stay put.
Agent-to-agent communication is now a first-class feature
The most consequential graduation is A2A, the Agent-to-Agent protocol. A2A lets one agent call another agent over HTTP as if it were a local tool, so a research agent, a booking agent and a reporting agent can work as a team instead of living in separate silos. In ADK, the RemoteA2aAgent class is the client side of that conversation, and the protocol now includes native task mode support, request interceptors and file-based agent cards.
There is also a practical new tool for it: the adk generate_agent_card command builds an A2A agent card from the CLI, so publishing an agent for other agents to discover takes one command instead of hand-writing a manifest. That small piece of plumbing is what turns a protocol into an ecosystem — agents can advertise what they do, and other agents can find them.
For background on why this layer matters, read our explainer on how agent protocols work. The short version is that A2A and its cousin MCP are the wiring that lets agents cooperate, and Google making A2A stable in ADK is a vote that multi-agent systems are the future, not a side experiment.
Your agents can now live inside Microsoft Teams
The headline feature of 2.14.0 is TeamsRunner, a new component that embeds ADK agents directly inside Microsoft Teams. Instead of asking employees to open a separate dashboard or chatbot, the agent shows up where the work already happens: in a Teams channel or chat.
This is a bigger deal than it sounds. Most enterprise AI agents fail not because the model is weak but because nobody opens the app. Meeting people inside Teams removes that adoption barrier entirely. A support agent can answer questions in the channel where the question was asked. A reporting agent can drop a summary into the morning stand-up chat. And because ADK agents run with the same tools and memory wherever they are hosted, the Teams version is the same agent, not a watered-down copy.
The release also adds an OpenAI Decisions integration, widening the set of external services ADK agents can plug into without custom glue code.
Evaluation grows up: multi-run tests and semantic checks
Agents are non-deterministic, which makes testing them awkward. Run the same eval once and you might get lucky; run it ten times and the real picture emerges. ADK 2.14.0 adds MultiRunConfig, which runs each evaluation case multiple times concurrently, so flaky behaviour shows up in the results instead of hiding behind a single pass.
It also adds ToolArgsMatcher, which uses a language model to check whether the arguments an agent passed to a tool are semantically correct, not just syntactically valid. An agent can call a function with the right types and the wrong meaning — booking a flight to the wrong city, for example — and a plain schema check would miss it. Semantic matching catches that class of mistake.
On the memory side, MongoDbMemoryService arrives with vector-search retrieval and TTL expiration, giving agents long-term memory that can be searched by meaning and that cleans itself up when entries expire. Combined with chunked file streaming for large files, the release is clearly aimed at agents that run long, multi-turn workflows in production.
A security fix that closes a real prompt-injection hole
Not every change in 2.14.0 is additive. One is a deliberate breaking change, and it is the most important one for security. RunSkillScriptTool, used when ADK runs skill scripts in environment mode, no longer accepts a free-form shell command string. Callers must now pass structured arguments instead: args, short_options and positional_args. Scripts run from the skill directory through validated paths, and only .py, .sh and .bash files are allowed. Anything else returns an error.
The release notes are unusually blunt about why: this “closes a hole that let a prompt-injected model run arbitrary shell commands.” In other words, a malicious prompt smuggled into an agent’s input could previously have tricked the model into running any shell command through the skill tool. That path is now closed by design. If your code still passes a command parameter, it will fail with an INVALID_ARGUMENTS error, and unsupported script types return UNSUPPORTED_SCRIPT_TYPE. Update your calls before upgrading.
This is the kind of fix that rarely makes headlines but should. It is also a reminder that agent frameworks are security boundaries now, not just developer conveniences — a lesson the whole industry keeps relearning, from the Android November security bulletin that fixed a zero-click remote code execution flaw to the Claude Code 2.1.319 update that added deny-instead-of-prompting for unattended runs.
The performance claim, with a caveat
Google says a 30-node workflow running 200 turns is 23% faster with 9% lower peak memory in ADK 2.14.0. That is a meaningful improvement if it holds, because long multi-turn workflows are exactly where agent frameworks usually bog down.
But treat it as a vendor claim, not a benchmark. The release notes publish no baseline hardware, no comparison against a named prior version, and no second measurement to validate the figure across different workflow shapes. Your mileage will vary with your model, your tools and your workload. The honest way to read it is that Google has been optimising the runtime, and the direction of travel is good — not that your workflow will be exactly 23% faster tomorrow.
What to do if you build with ADK
If you are already running ADK in production, the upgrade path is straightforward: update to 2.14.0, replace any RunSkillScriptTool calls that pass a free-form command with the new structured arguments, and lean on the newly stable APIs instead of pinning to experimental behaviour. The TeamsRunner is worth a pilot if your organisation lives in Microsoft Teams, and MultiRunConfig is worth turning on for any eval suite that has ever passed once and failed in production.
If you are choosing a framework, ADK 2.14.0 is the release that makes the decision easier. The A2A graduation, the Teams integration and the security hardening all point the same way: Google is treating agents as production software now, with stable contracts, real deployment surfaces and security fixes that close holes rather than paper over them. The agent wars of the last few months have been fought over models, but the next phase will be won on plumbing like this. ADK just laid a lot of new pipe.
For the full technical detail, see the official ADK 2.14.0 release notes and Google’s ADK documentation, and check the google-adk on PyPI page for the latest package version. And if you want to see how far agent tooling has come on the phone side, read how you can approve an AI agent’s next move from your phone — the control plane for agents is becoming as important as the agents themselves.
