Google ADK 2.14 is the release where Google’s Agent Development Kit stops feeling like a fast-moving experiment and starts behaving like infrastructure you can build a business on. Published on 7 November 2026, version 2.14.0 graduates 42 components — execution environments, the A2A agent-to-agent protocol, evaluation tooling and the core runtime — from experimental to stable, and it adds the two integrations developers have been asking for most: a TeamsRunner that puts ADK agents inside Microsoft Teams, and a classifier built on the OpenAI Decisions API. A small patch, version 2.14.1, followed on 12 November 2026 with a single tracing fix.
The headline is not a long feature list. It is a promise. When a module is marked stable in Google ADK 2.14, Google is committing to its API surface: the code you write against it today should keep working in the next releases, without the experimental warnings that have followed ADK since its first public versions. For teams that have been prototyping agents in ADK and waiting for a signal before putting them in front of real users, that is the signal — with a few important conditions attached.
This guide explains what Google ADK 2.14 actually changes, which parts are now safe to build on, how the Microsoft Teams integration works, what the 23% speed claim really means, and the three breaking changes you must handle before you upgrade. Every performance figure and benchmark in this article is labelled as Google’s own claim where Google is the only source, because the release notes publish no independent verification for them.
Table of Contents

What Is Google ADK 2.14?
Google ADK 2.14 is version 2.14.0 of Google’s Agent Development Kit, the open-source, code-first framework for building multi-agent systems. The release is dated 4 November 2026 in its notes, and its tag was published on GitHub on 7 November 2026 — a distinction that matters if you pin versions, because the notes are three days older than the publication date. The Python package is google-adk, installable from PyPI, and the framework also has TypeScript, Java and Go ports for teams that do not work in Python.
ADK starts from one building block, the agent. In its simplest form an agent is a name, a model, a short description of what it is for, an instruction that acts as its system prompt, and a list of tools it may call. From that one class — formally LlmAgent — the framework builds everything else: deterministic multi-step workflows that run agents in sequence or in parallel, routers that hand a request to the right specialist agent, and callbacks that let you inspect or block behaviour before it happens. It is model-agnostic by design, working with Gemini first and with other providers through LiteLLM-style integrations, and it deploys to Google’s Agent Engine, Cloud Run or Google Kubernetes Engine.
The framework is also the engine behind Agent Builder on Vertex AI, which is why Google’s own cloud customers meet ADK even when they never type its name. That dual role — open-source toolkit on GitHub and the foundation of a managed Google Cloud product — explains why a stability release matters beyond the changelog. When ADK’s core surfaces go stable, the managed product built on top of them gets steadier too.
Google ADK 2.14 costs nothing as a framework. It is open source under the Apache 2.0 licence, and you pay only for what your agents consume: model calls through the Gemini API or Vertex AI, and any cloud services you run them on. That pricing shape is part of the appeal for small teams and solo developers in the United States, who can prototype on free-tier API keys and scale to paid usage only when traffic arrives.
What makes this release different from the dozen ADK releases before it is scope. Earlier versions added features; this one removes a label. Forty-two components leave experimental status in a single update, and the release notes frame the whole version around that graduation. The sections below go through each part of it, because “stable” means something slightly different for execution environments, for the A2A protocol and for evaluation — and the differences decide what you can rely on.
What Changed in Google ADK 2.14: The Stable Graduation
The core sentence in the Google ADK 2.14 release notes is short: the release “graduates execution environments, A2A, evaluation, and core runtime modules from experimental.” Behind that sentence sit 26 auth, environment, app, CLI and cache modules, plus 16 toolset and integration features — 42 components in total. Stable status means you can build on these surfaces without experimental warnings. It does not mean your application is production-ready on its own. It is an API commitment from Google, not a guarantee about your system, and the distinction is worth keeping in mind through the rest of this article.
Google ADK 2.14 Stable Modules: The Full List
The largest group in the Google ADK 2.14 graduation is the execution environment family. BaseEnvironment, LocalEnvironment, EnvironmentToolset, DaytonaEnvironment and E2BEnvironment are now stable, which means the sandboxes where agents run code have a fixed API. That matters because code execution is where agents stop being chatbots and start being workers: an agent that can run a script, read a file or test a change needs a sandbox with clear boundaries, and until now those boundaries were labelled experimental.
Alongside the environments, file handling improves in a practical way. BaseEnvironment.read_file_stream streams files in chunks across the local, E2B and Daytona environments, so the ReadFileTool can pull a range of lines from a large file without loading the whole file into memory. Anyone who has watched an agent try to read a 50-megabyte log file will recognise why that matters: the old behaviour turned a simple “show me the last 200 lines” request into a memory spike.
The second group is the agent-to-agent protocol, covered in detail below. The third is evaluation, also covered below. The fourth is the core runtime itself — the session handling, the runner loop and the app scaffolding that every ADK project touches. Twenty-six modules across auth, environment, app, CLI and cache move to stable alongside the 16 toolset features, which is why this release reads less like a feature drop and more like a line drawn under the framework’s first year of public development.
Execution Environments Go Stable in Google ADK 2.14
Execution environments are the sandboxes in which an ADK agent runs code on behalf of a user. Google ADK 2.14 makes five of them stable: the base class, the local environment for development, the environment toolset that exposes sandbox operations as agent tools, and the two hosted sandbox backends, Daytona and E2B. For a developer, the practical consequence is simple: the code you write to give an agent a sandbox today is the code that will still work in the next few releases, and the experimental warnings disappear from your logs.
The sandbox choice is also a deployment choice. A local environment is right for development on your own machine. Daytona and E2B are hosted sandboxes for production, where you want code execution isolated from your own infrastructure. Agent Engine, Google’s managed runtime, gets a related improvement in this release: it now reports commands that run longer than 570 seconds as timed out before the service deadline hits, instead of failing in a less diagnosable way. That is a small change with a large effect on debugging, because a timeout you can see is a problem you can fix, while a silent failure is a mystery.
There is one more reason the environment graduation matters, and it is the security story in the breaking-changes section below. The same release that makes sandboxes stable also closes a prompt-injection hole in how agents run scripts inside them. Stability and security arrived together in Google ADK 2.14, and that pairing is not a coincidence: you cannot credibly call a sandbox stable while a prompt-injected model can still escape its intended command.
A2A Goes Stable: Agents From Different Teams Can Talk
The A2A protocol — Agent-to-Agent — is the part of Google ADK 2.14 that matters most outside Google’s own ecosystem. A2A is an open protocol, hosted by the Linux Foundation, that lets one agent hand a task to another agent built by a different team, on a different framework, without either side needing to know how the other is implemented. The two agents discover each other through a standard “agent card”, a small document that describes what an agent can do, and then exchange tasks over a standard message format.
With Google ADK 2.14, the A2A integration is stable, and the release adds a command-line tool that makes the protocol concrete: adk generate_agent_card builds an A2A agent card for your agent from the command line. That single command is the difference between a protocol you read about and a protocol you can use. Before it, publishing an agent for other agents to find required hand-writing the card; now the framework generates it for you, and other A2A-compatible agents can discover and call your agent through the standard interface.
Why does that matter for a working developer? Because the agent world is fragmenting. One team builds a research agent, another builds a billing agent, a third builds a support agent, and the value of each one multiplies when they can call each other. Without a standard protocol, every pair of agents needs a custom integration, and the number of custom integrations grows with the square of the number of agents. A2A turns that into one integration per agent — publish a card, and any compatible agent can find you. Google ADK 2.14 is the release where Google says that mechanism is ready for production use.
It is worth noting the honest limit here. A stable protocol is not the same as a busy network. A2A needs other frameworks and other companies to adopt it before the discovery story pays off at scale, and adoption is still early. What Google ADK 2.14 gives you is a stable, documented way to publish your agents into that network — not a guarantee that anyone is already listening on the other end.
Evaluation Goes Stable: MultiRunConfig and ToolArgsMatcher
Evaluation is the part of agent development that separates a demo from a product. An agent that works once, in front of you, is not the same as an agent that works a thousand times, in front of strangers. Google ADK 2.14 graduates the evaluation modules to stable and adds two features that make evaluation meaningfully better.
The first is MultiRunConfig, which lets adk eval --num_runs run each evaluation case multiple times in parallel and combine the scores or pass rates across runs. That matters because agents are non-deterministic: the same agent, given the same task, can succeed on Monday and fail on Tuesday, and a single evaluation run cannot tell you whether you are looking at a good agent or a lucky one. Running each case several times and averaging the result turns a coin flip into a measurement. The config exposes the number of runs and the parallelism, so you can trade evaluation time against confidence.
The second is ToolArgsMatcher, which compares the arguments an agent passes to a tool against the expected arguments, using exact matching, numeric tolerance or LLM-backed semantic checks. The semantic option is the interesting one: it recognises that two different argument values can mean the same thing — a date written as “November 13, 2026” and one written as “2026-11-13” are the same date, and an evaluation that fails the agent for the difference is measuring formatting, not competence. Semantic matching lets the evaluation judge what the agent meant, not how it spelled it.
Together, these two features make Google ADK 2.14 the first ADK release where the evaluation story feels complete for a working team: run each case many times, judge the tool calls by meaning, and get a pass rate you can actually trust when you decide whether a new model or a new prompt is an improvement.
TeamsRunner: ADK Agents Inside Microsoft Teams
The most visible new feature in Google ADK 2.14 is TeamsRunner, a component that connects ADK agents directly to Microsoft Teams chats and channels. It is the headline addition in the release for a simple reason: Teams is where the work already happens. Hundreds of millions of people spend their working day in Teams, and an agent that lives there does not ask anyone to open a new app, learn a new interface or change a habit. It meets people where they already are.
Until this release, putting an ADK agent into Teams meant building the bridge yourself — handling Teams webhooks, mapping messages to agent sessions, and formatting replies for the Teams client. TeamsRunner does that plumbing for you. Your agent runs as it always has, and the runner carries its messages into Teams chats and channels and carries the replies back. The agent itself does not need to know that Teams exists, which means an agent you built for a web chat interface can move into Teams without being rewritten.
The practical uses write themselves. A support agent that answers questions in a Teams channel instead of a separate helpdesk portal. A research agent that a product manager can question in a chat thread, with the answer appearing where the whole team can see it. A reporting agent that posts a morning summary into a channel and answers follow-up questions in the thread below it. None of these is a new kind of agent — the new part is the room they work in.
There is also a strategic detail worth noticing: this is Google’s agent framework shipping a first-class integration for Microsoft’s collaboration platform. That tells you something about where the agent market is heading. The frameworks are competing on quality, not on lock-in, and the winners will be the ones whose agents work wherever the users are — including inside a rival’s product. For a developer choosing a framework, that is reassuring: choosing ADK does not mean choosing Google’s chat surface, and Google ADK 2.14 proves it by shipping the Microsoft integration in the same release as the stability graduation.
One caution applies. The release notes describe TeamsRunner as a new component, and the lead research for this article found no separate rollout note or availability date for it beyond the 2.14.0 release itself. Treat it as available with the release, but check the official ADK documentation before planning a production deployment around it, and confirm the Teams permissions and bot registration your organisation requires — Teams bots need an app registration and the right tenant permissions, and that administrative step is outside ADK’s control.

OpenAI Decisions Integration: A Classifier for Tool Gating
The second integration in Google ADK 2.14 is quieter, but it may matter more to experienced agent builders. OpenAIDecisionsClassifier classifies workflow and tool-gating questions using the OpenAI Decisions API — the same family of decision models that Google itself entered this week with Gemini Decision 1, which we covered in our earlier guide to Google’s own decision model.
To understand why a classifier belongs in an agent framework, think about what an agent does all day. It is not only generating answers. It is constantly making small judgements: should I call this tool or that one, does this message break a policy, is this retrieved document actually relevant, is this draft good enough to send. In most frameworks those judgements are made by asking a chat model to generate text and then parsing the reply — slow, expensive and fragile, because the answer arrives as prose that code must interpret.
A decision model replaces that with a number. You ask a closed question — “which tool should handle this request?” or “does this input violate the policy?” — and you get back a probability you can branch on directly. The OpenAI Decisions API provides that as a service, and the new ADK classifier wires it into the agent’s workflow: before the agent calls a tool, the classifier can score whether the call is appropriate, and the workflow can route, block or escalate based on the score.
The pairing with the TeamsRunner is not accidental. An agent inside a company chat channel will be asked to do things it should not do, by people testing its limits, and a fast, cheap gating decision on every tool call is the difference between an agent that stays useful and an agent that becomes a liability. Google ADK 2.14 gives you that gate as a built-in component rather than a piece of code you have to write and maintain yourself.
There is a cost detail to keep straight. The classifier calls the OpenAI Decisions API, which is billed by OpenAI on its own terms — it is not part of the free ADK framework, and it is not a Google service. If your organisation standardises on Google’s stack, the natural counterpart is Gemini Decision 1, Google’s own decision model, which costs $0.10 per million input tokens with free output and is available through the Gemini API.
The two models solve the same problem from opposite vendors, and ADK now supports the OpenAI route natively while the Gemini route is available through Google’s own API. Which one you choose is a vendor decision, not a framework decision — and that is exactly the point of a model-agnostic toolkit.
Performance: The 23% Faster Claim, Examined
Google ADK 2.14 carries one headline performance number: a 30-node workflow executing 200 turns runs 23% faster, with 9% lower peak memory, in this release. It is a striking figure, and it is also the figure in this article that most needs a careful reading.
The number comes from Google’s own release notes, and the notes publish no baseline hardware, no named prior version for comparison, and no second benchmark to validate the claim across different workflow patterns. That does not make the number false. It makes it unverifiable from the outside. A 23% improvement on a 30-node, 200-turn workflow — a long, complex, multi-agent run — is plausible for a release that reworked the runtime and the execution environments, and long multi-turn workflows are exactly where runtime overhead accumulates. But without knowing the machine, the model or the version it was compared against, you cannot translate that 23% into a number for your own workload.
That matters because your workload is probably not a 30-node workflow with 200 turns. Most production agents are smaller: a handful of agents, tens of turns, short tool calls. The speedup on a small workflow may be larger or smaller than the headline figure, and the only way to know is to measure it yourself after upgrading. Treat the 23% as a signal — Google invested real engineering effort in runtime performance in this release — not as a guarantee of what your bill or your latency will look like.
The 9% lower peak memory claim deserves the same treatment, with one additional note: memory matters most where it is scarcest. If you run agents on a small Cloud Run instance or a local machine, a 9% reduction in peak memory can be the difference between a run that fits and a run that crashes. If you run on a large Vertex AI deployment, it is a cost saving rather than a capability change. Either way, the direction is good; the magnitude is something to verify in your own environment.

There is a useful way to think about performance claims in framework releases generally. A framework version that makes long workflows faster is valuable even if the exact percentage does not reproduce on your machine, because long workflows are where agents spend most of their time and money. The multi-turn loop — agent thinks, calls a tool, reads the result, thinks again — is the unit of work, and every millisecond of framework overhead in that loop is multiplied by the number of turns. Google ADK 2.14’s performance work targets that loop, and that is the right place to optimise. Just measure before you celebrate.
Breaking Changes: What to Fix Before You Upgrade
Google ADK 2.14 is a stability release, but it is not a free upgrade. The release carries three breaking changes, and one of them is a security fix wearing a breaking-change label. Read this section before you run pip install --upgrade google-adk, because two of these changes will break existing code silently rather than loudly.
RunSkillScriptTool: The Prompt-Injection Hole Gets Closed
The most important change in Google ADK 2.14 is also the easiest to miss. RunSkillScriptTool no longer accepts a free-form shell command in environment mode. Instead, callers pass validated arguments — structured args, short_options and positional_args — scripts run from a validated skill directory, and only .py, .sh and .bash scripts are supported.
The reason is a security hole the release notes describe plainly: the old behaviour let a prompt-injected model run arbitrary shell commands. Here is how that worked. An agent reads untrusted text — a web page, a document, an email — and that text contains an instruction disguised as content. The model follows it and asks the tool to run a shell command. Under the old design, the tool obeyed, because it accepted any command string.
Under the new design, the model can only pass arguments to a script that already exists in a directory you approved, and only scripts with the three approved extensions will run. The attack surface shrinks from “any shell command” to “arguments to a script you wrote”.
This is a genuine improvement, and it is the kind of change that should make you upgrade sooner rather than later — but it will break any agent that relies on the old free-form command parameter. If your code passes a command string to RunSkillScriptTool, it will stop working, and you will need to restructure it around validated scripts and arguments. That is real migration work, not a version bump, and you should budget for it. The silver lining is that the migration makes your agent safer by construction: every script your agent can run is one you placed in the skill directory yourself.
Enum Arguments and Firestore Sessions: The Quiet Breaks
The other two breaking changes in Google ADK 2.14 are quieter, which makes them more dangerous. First, enum tool arguments now arrive as enum members instead of raw strings. If your code compares a tool argument to a string, or dumps it straight into JSON, it will break or behave differently, because an enum member is not a string even when it looks like one. Search your codebase for string comparisons against tool arguments before upgrading, and convert enum members explicitly where you need their values.
Second, sessions written by Google ADK 2.14 cannot be read by 2.13.0 or earlier after a rollback, because Firestore session payloads are now stored as JSON strings. That is a one-way door: once you upgrade and your agents write sessions in the new format, rolling back to the old version will not restore those sessions. Plan your upgrade accordingly — test in a staging environment first, and do not upgrade production on a Friday afternoon with no rollback plan that accounts for session loss. Relatedly, VertexAiSessionService.create_session now accepts only a short list of session config options, so code that passed extra options will need trimming.
The MongoDB side of the release is additive rather than breaking, and it is worth a mention here. MongoDbMemoryService gains vector-search retrieval and optional TTL expiration for agent memory, which means long-running agents can now retrieve relevant memories by meaning rather than by exact match, and can let old memories expire automatically instead of accumulating forever. For agents that run for weeks or months, that is the difference between a memory that stays useful and a memory that becomes a swamp.
Google ADK 2.14.1: The 12 November Patch
Five days after 2.14.0, Google shipped a patch: Google ADK 2.14.1, published on 12 November 2026. It contains exactly one change — a bug fix that turns off FastAPI’s native tracing on Agent Engine. That is the whole release, and its smallness is informative.
A patch with a single tracing fix, five days after a major stability release, is what a healthy release process looks like. It means the 2.14.0 release was tested well enough that the first follow-up was a narrow operational fix rather than a rollback or a security emergency, and it means the team is watching the release in production rather than shipping it and moving on. If you are installing ADK for the first time, install 2.14.1, not 2.14.0 — it is the latest stable release, and there is no reason to start on the version with the known tracing issue.
The patch also carries a small lesson about version pinning. The 2.14.0 release notes are dated 4 November but the tag went up on 7 November, and 2.14.1 followed on 12 November. In a framework that ships this quickly, pinning to an exact version — google-adk==2.14.1 — is safer than pinning to a range, because a range can silently pull in a patch that changes session formats or tracing behaviour. Pin the exact version in production, and let your staging environment test the next one first.
How to Install Google ADK 2.14 and Build Your First Agent
Getting started with Google ADK 2.14 takes three commands and a few minutes, provided you already have Python 3.11 or higher installed. The framework is free; the only cost is the model usage behind your agent, which you pay to Google through the Gemini API or Vertex AI — or to another provider if you connect a different model.
First, create a virtual environment and install the package:
python3 -m venv .venv
source .venv/bin/activate
pip install google-adk
Second, scaffold a new agent. The ADK command-line tool generates the project structure for you:
adk create my_agent
Third, start the built-in web interface and talk to your agent in the browser:
adk web --port 8000
Before your agent can answer anything, it needs a model key. The simplest path is a Gemini API key from Google AI Studio, which has a free tier for prototyping. Set it as an environment variable, and the agent will use Gemini as its reasoning model. For production, the same agent can run on Vertex AI with your Google Cloud project, where billing, quotas and access control are managed centrally.

A minimal agent in code is only a few lines. You define an LlmAgent with a name, a model, an instruction and a list of tools — for example, a function that returns the weather for a city — and the framework handles the conversation loop, the tool calls and the session state. To put that agent in front of users, you drive it with a Runner and a session service, then call runner.run_async() for each message. To evaluate it, you write test cases and run adk eval, and in Google ADK 2.14 you can add --num_runs to run each case several times and get a pass rate instead of a single result.
Two practical tips for new users. First, use adk web for development and debugging — the chat interface shows you the agent’s reasoning, its tool calls and its errors in one place, which is far faster than reading logs. Second, write your evaluation cases before you write your agent’s instruction. It sounds backwards, but an agent without evaluation cases is an agent you cannot improve: every change to the prompt is a guess, and the evaluation is the only thing that tells you whether the guess helped.
Google ADK 2.14 vs LangGraph, CrewAI and Semantic Kernel
No framework decision happens in a vacuum, and Google ADK 2.14 arrives in a crowded field. The three alternatives most developers compare it against are LangGraph, CrewAI and Microsoft’s Semantic Kernel, and each one leads with a different strength.
LangGraph, from LangChain, is the most flexible of the four. It models agents as graphs, which gives you precise control over state, branching and retries, and it has the largest community and the most examples. Its weakness is complexity: a graph is a powerful abstraction, but it is also a lot of machinery for a simple agent, and debugging a graph is harder than debugging a straight-line workflow. ADK’s workflow agents — sequential and parallel — cover the common patterns with less code, and its evaluation tooling in 2.14 is more built-in than LangGraph’s. If your system is a complex state machine, LangGraph still wins. If it is a team of agents with tools, ADK is the simpler choice.
CrewAI leads with role-playing: you define agents with roles, goals and backstories, and the framework orchestrates them as a crew. It is the fastest way to prototype a multi-agent demo, and its community is enthusiastic. Its weakness is the same as its strength: the role metaphor is charming for demos but can obscure what the system is actually doing, and production teams often find themselves fighting the abstraction when they need deterministic control. ADK’s approach is more explicit — you wire the workflow yourself — which is more work up front and less work when something goes wrong at 2 a.m.
Semantic Kernel, from Microsoft, is the natural choice if your organisation is already deep in the Microsoft stack: .NET, Azure, Teams, Copilot. It is mature, well-documented and enterprise-friendly. The irony of Google ADK 2.14 is that it now competes directly on Microsoft’s home ground, because TeamsRunner puts ADK agents into Teams — the surface where Semantic Kernel has its biggest advantage. For a Microsoft-first shop, Semantic Kernel is still the safer default. For a team that wants Google’s models, Google’s cloud and a Teams presence, ADK 2.14 is now a credible alternative where it was not one before.
The honest summary is that there is no best framework, only a best fit. Choose ADK if you want a code-first, model-agnostic toolkit with strong evaluation, Google’s cloud behind it, and now a stable API surface and a Teams presence. Choose LangGraph if you need graph-level control. Choose CrewAI if you want the fastest prototype. Choose Semantic Kernel if you live in Microsoft’s world.
If you are weighing open-weight models to run inside any of these frameworks, our Meta Muse Spark Open guide covers the 816-billion-parameter open model Meta released for agent workloads. And whichever framework you choose, the A2A protocol in Google ADK 2.14 is a reminder that the frameworks are converging on shared standards — your agents may one day talk to agents built on a rival framework, and that is a future worth building toward.
Who Should Upgrade — and Who Should Wait
Google ADK 2.14 is the right upgrade for most teams, but not for all of them, and not on the same schedule. Here is the honest split.
Upgrade now if you are building a new agent project, or if you are running agents in production on an ADK version that still labels its core modules experimental. The stable API surface is the main benefit, and starting a new project on 2.14.1 means you never have to migrate away from experimental APIs later. Also upgrade promptly if your agents run untrusted content through scripts — the RunSkillScriptTool fix closes a real prompt-injection hole, and that alone justifies the migration work.
Upgrade this week if you have been waiting for a Teams integration, or if your evaluation process is thin. TeamsRunner is the fastest path to putting an agent where your colleagues already work, and MultiRunConfig plus ToolArgsMatcher will make your evaluation numbers trustworthy for the first time. Both are worth a planned upgrade with a staging test.
Wait, or upgrade carefully, if you have long-running production sessions stored in Firestore, or if your code depends heavily on free-form shell commands through RunSkillScriptTool. The session-format change is a one-way door, and the script change is real migration work. Neither is a reason to stay on an old version forever — the security fix alone argues against that — but both are reasons to plan the upgrade, test it in staging, and check the breaking-changes list against your own codebase before you touch production.
Do not upgrade blindly if your agents are part of a regulated workflow — finance, healthcare, legal — without re-running your full evaluation suite. Stable APIs do not change what your agent does, but the enum-argument change and the script-execution change can change how it behaves in edge cases, and regulated systems need evidence, not assumptions. Run the suite, compare the pass rates, and only then deploy.
Frequently Asked Questions
Is Google ADK 2.14 free to use?
Yes. Google ADK 2.14 is open source under the Apache 2.0 licence, and the framework itself costs nothing. You pay only for the model calls your agents make — through the Gemini API, Vertex AI or another provider — and for any cloud infrastructure you run them on. The Gemini API has a free tier for prototyping, so a small project can start at zero cost.
What is the difference between Google ADK 2.14.0 and 2.14.1?
Version 2.14.0, published 7 November 2026, is the release with the stable graduation, TeamsRunner and the new integrations. Version 2.14.1, published 12 November 2026, is a patch with a single bug fix: it turns off FastAPI’s native tracing on Agent Engine. New installations should use 2.14.1.
Does Google ADK 2.14 work with models other than Gemini?
Yes. ADK is model-agnostic by design and works with other providers through integrations, including OpenAI, Anthropic’s Claude and Mistral models via LiteLLM-style connectors. Gemini is the first-class, best-tested path, and the framework is built by Google, but nothing in the architecture locks you to a Google model. Our guide to Gemini 4 Hydrogen covers the newest Gemini model you can pair with ADK.
What is A2A, and why does its stable status matter?
A2A is the Agent-to-Agent protocol, an open standard hosted by the Linux Foundation that lets agents built by different teams on different frameworks discover each other and hand off tasks. Its stable status in Google ADK 2.14 means you can publish your agent’s card with adk generate_agent_card and rely on the protocol’s API. The network of A2A agents is still young, so the practical benefit today is readiness, not an existing marketplace of agents to call.
Can I put my ADK agent in Microsoft Teams now?
Yes, with the TeamsRunner added in Google ADK 2.14. It connects your agent to Teams chats and channels without rewriting the agent. You will still need the Teams-side setup — a bot app registration and the right tenant permissions — which is an administrative step outside ADK, so confirm those with your Teams administrator before promising a launch date.
Will upgrading to Google ADK 2.14 break my existing agents?
Possibly, in three specific ways. The RunSkillScriptTool no longer accepts free-form shell commands, enum tool arguments now arrive as enum members instead of strings, and Firestore sessions written by 2.14.0 cannot be read by 2.13.0 or earlier. Read the breaking-changes section above, search your code for those patterns, and test in staging before upgrading production.
Is Google ADK 2.14 production-ready?
The framework’s core surfaces are now stable, which is Google’s commitment to their APIs — but “stable APIs” and “production-ready application” are different things. Your application still needs its own testing, evaluation, monitoring, guardrails and incident plan. Google ADK 2.14 gives you better tools for all of those, including multi-run evaluation and semantic tool-argument matching, but it does not do the work for you.
The Bottom Line
Google ADK 2.14 is not the most exciting ADK release, and that is precisely why it matters. Exciting releases add features; important releases remove risk. By graduating 42 components to stable, closing a prompt-injection hole, adding a Teams presence and a decision-model classifier, and shipping a small, clean patch five days later, Google has turned ADK from a framework you prototype with into a framework you can plan a product around.
The release is not without its caveats. The 23% speed claim is Google’s own number with no published baseline, the A2A network is still young, and the breaking changes demand real migration work — especially the script-execution fix and the one-way session format change. None of those caveats is a reason to skip the upgrade. They are reasons to upgrade deliberately: read the breaking changes, test in staging, re-run your evaluations, and then deploy.
If you have been waiting for a sign that ADK is ready for serious work, Google ADK 2.14 is that sign. Install 2.14.1, build your first agent in an afternoon, put it in a Teams channel, and let the evaluation numbers — run several times, judged by meaning — tell you whether it is good enough to keep. That is the workflow this release was built for.
Sources
- Google ADK Python v2.14.0 release notes (GitHub)
- Google ADK Python v2.14.1 release notes (GitHub)
- google-adk 2.14.0 on PyPI
- Google ADK official documentation
- Agent Intelligence: Google’s agent-to-agent protocol is stable now
- Undeniable Progress: ADK 2.14.0 graduates environments, A2A and eval
- Emergent: Google ADK 2.14 adds Teams integration and multi-run evals
