Contents
- Verdict
- What is Google Agent Development Kit (ADK)?
- Best for, and not for
- Strengths and limits
- Pricing
- What people actually build with it
- What Google ADK actually costs at small-business volume
- The gotcha: Gemini stopped being the cheap one
- What breaks in production, and how you find out
- What it connects to that you already run
- Google ADK alternatives: what to pick instead, and when
- Migration and lock-in: can you get your work out?
- FAQ
Google's Agent Development Kit is a free, Apache-licensed, code-first Python toolkit that is more genuinely provider-neutral than its reputation suggests and more Google-shaped in practice than its documentation admits. It is actively developed, with 21,013 stars and a commit on the day we checked. Two things should temper enthusiasm. Gemini is no longer the cheap option it was, with the cheapest current tier at $0.30 per million input tokens against a rival's $0.05. And we still could not find published vCPU-hour rates for managed Agent Runtime deployment across four Google pricing URLs. Self-hosted, this is a good framework with a clear cost model. Managed, you are budgeting for a number Google does not publish where you can find it.
What is Google Agent Development Kit (ADK)?
The Agent Development Kit is Google's open-source framework for building agents and multi-agent systems in Python and Java, the same framework that powers agents inside Google's own products. It treats multi-agent composition as a first-class concept, with specialized agents delegating to each other, ships a built-in web UI for local debugging, and supports the A2A protocol and MCP for interoperability. It is model-agnostic in principle but pairs most naturally with Gemini and deploys most smoothly to Vertex AI Agent Engine, Google's managed agent runtime, now part of the Gemini Enterprise agent platform.
Best for
Teams building multi-agent systems, especially those already on Google Cloud and Gemini.
Not for
Anyone who needs a stable API to build against once and leave alone. Google renamed the product, moved the documentation to a new domain and superseded ADK's own workflow agents in version 2.0, all within roughly a year.
Strengths
- Free and Apache 2.0 licensed, with no licence, seat or execution fee at any scale
- Actively developed: the GitHub API showed 21,013 stars and a push on 6 August 2026, the day we checked
- Genuinely multi-provider rather than Gemini-only, with direct support for Claude alongside Gemini and connectors for LiteLLM, Ollama, vLLM, Apigee and LiteRT-LM
- Model routing with automatic failover is built in, so a provider outage does not have to be an outage for your agent
- Deploys to managed Agent Runtime, Cloud Run, GKE or any container host, including disconnected environments with no Google Cloud connectivity
- Evaluation tooling ships with the toolkit rather than being assembled, which is the discipline most agent projects skip and most need
- Deterministic workflow structures exist alongside LLM-driven delegation, so you can specify control flow instead of hoping the model chooses it
Limitations
- Managed Agent Runtime deployment rates were not published on any of the four Google pricing pages we checked on 6 August 2026
- Gemini is no longer the price leader it was: the cheapest listed tier is $0.30 per million input tokens against OpenAI's gpt-5-nano at $0.05
- ADK 2.0 supersedes SequentialAgent, ParallelAgent and LoopAgent in favour of graph-based and dynamic workflows, so existing tutorials teach a deprecated shape
- Documentation moved from google.github.io/adk-docs to adk.dev, and Vertex AI Agent Engine is now Agent Runtime on Agent Platform, so much published guidance uses names that no longer exist
- Non-Gemini models require instantiating a connector class rather than naming a model string, which is a small but persistent asymmetry
- The free Gemini API tier states that content is used to improve Google's products, which rules it out for business data
- Developer-only, with no non-technical route to a working agent
Google Agent Development Kit (ADK) pricing
The ADK framework is free Apache 2.0 open-source software with no licence fee, seat cost or execution meter, so your bill is model tokens plus wherever the agent runs. Token pricing is published and easy to forecast: the billing unit is a token, priced per million, with separate input, cached input and output rates that differ between the direct Gemini API and Google Cloud's Agent Platform. Deployment is where the unit changes and the transparency stops. Managed Agent Runtime bills infrastructure separately from tokens, and as of 6 August 2026 we could not locate its vCPU-hour and GiB-hour rates on any of the four Google pricing pages we checked. Self-hosting on Cloud Run, GKE or your own container host bills at ordinary compute rates you can look up in advance.
| Plan | Price | What you get |
|---|---|---|
| ADK framework | $0 | Free, Apache 2.0, code-first Python toolkit. Runs anywhere, including offline containers with no Google Cloud connection |
| Gemini 3.5 Flash-Lite | $0.30 / $2.50 | Per 1M input / output tokens on the paid Gemini API tier, as of 6 Aug 2026. The cheapest Gemini listed |
| Gemini 3.5 Flash | $1.50 / $9.00 | Per 1M input / output on the paid API tier; the same rates appear on Agent Platform, with cached input at $0.15 |
| Gemini 3.1 Pro Preview | $2.00 / $12.00 | Per 1M input / output at 200K context or below; rises to $4.00 / $18.00 above 200K tokens |
| Self-hosted agent | ~$5-$20/mo | Cloud Run, GKE or any container host. Tokens plus ordinary compute, and the only route with a fully forecastable bill |
| Managed Agent Runtime | Not published where we could find it | Billed separately from tokens. We checked four Google pricing URLs on 6 Aug 2026 and found no vCPU-hour or GiB-hour rate. Confirm before budgeting |
Pricing reflects public plans as of August 6, 2026 and can change. Check Google Agent Development Kit (ADK) for the latest.
What people actually build with it
ADK describes itself as a code-first toolkit for building, evaluating and deploying agents, and the projects that suit it best are the ones where the business already keeps its data inside Google and the agent is being asked to act on that data rather than fetch it from elsewhere.
Workflows that live inside Workspace
Inbox triage is our reference workload and the natural fit. A Gmail push notification acts as the webhook, the agent classifies the message against the categories the business actually uses, calls a function tool to look up the sender in the CRM, and either drafts a reply or applies a label and assigns it. At 1,000 items a month this is a few dollars of tokens and a Cloud Run service that spends most of its life scaled to zero. The identity story is the quiet advantage: the agent runs as a service account inside the same Google project that already holds the mailbox, so there is no third-party OAuth grant to justify to anyone.
Quote preparation for a trades or professional services business is the second. A form submission lands in a spreadsheet, the agent reads the job description, retrieves the firm's rate card and three comparable past jobs from Drive, drafts into a Docs template, and emails the owner for approval before anything reaches the customer. For an HVAC or plumbing company the approval step is the design rather than a caveat: a quote is a number a customer will hold you to, so the agent prepares it and a person sends it.
Documents, knowledge and the honest bad fit
Document processing against Drive is the third and the quietly valuable one. Supplier invoices arrive in a watched folder, the agent extracts supplier, date, net, tax and total, validates that line items sum to the stated total, and writes a row to Sheets or a record in the accounting system. Bad extractions go to an exceptions folder with the reason attached. It is unglamorous and it removes a genuinely tedious hour a week.
Internal knowledge answering is the fourth: a Chat message asks a policy question and the agent answers from documents in Drive with a link to the source. This is RAG, and it wants a vector database and a retrieval step you configure rather than assume. It is also the case where ADK's built-in evaluation tooling earns its place, because the failure mode is a confident answer drawn from a superseded document rather than an error anyone can see.
What ADK is not the right tool for is a scheduled, branching, multi-approval business process. It has deterministic workflow structures, but you are still writing the scheduler, the audit trail and the approvals interface, and a workflow platform such as n8n or Make will have delivered that in a fraction of the time.
Bottom line: Google ADK suits agents acting on data already inside Workspace, such as Gmail triage, Drive invoice extraction and Docs quote drafting, because the agent runs as a service account in the same project rather than through a third-party OAuth grant.
What Google ADK actually costs at small-business volume
The framework is free under Apache 2.0 and contributes nothing to the bill. Tokens are published and straightforward. Deployment is where the arithmetic stops being complete, and it stops for a reason we could not resolve.
On the paid Gemini API tier as of 6 August 2026, Gemini 3.5 Flash-Lite is $0.30 per million input and $2.50 output, Gemini 3.5 Flash is $1.50 and $9.00, and Gemini 3.1 Pro Preview is $2.00 and $12.00 at 200K context or below, rising to $4.00 and $18.00 above that. Google Cloud's Agent Platform lists slightly different numbers for slightly different model versions, with Gemini 3.1 Flash-Lite at $0.25 input and $1.50 output on the global endpoint and cached input at $0.025, plus a non-global endpoint premium effective 1 July 2026 that puts the same model at $0.275 and $1.65 in a specific region.
| Model or line item | Input per 1M | Output per 1M | Monthly at reference workload |
|---|---|---|---|
| Gemini 3.5 Flash-Lite (API) | $0.30 | $2.50 | ~$1.90 |
| Gemini 3.1 Flash-Lite (Agent Platform, global) | $0.25 | $1.50 | ~$1.35 |
| Gemini 3.5 Flash | $1.50 | $9.00 | ~$8.10 |
| Gemini 3.1 Pro Preview (under 200K) | $2.00 | $12.00 | ~$10.80 |
| ADK framework | $0 | $0 | $0 |
| Cloud Run, self-hosted | n/a | n/a | ~$5 to $20 |
| Managed Agent Runtime | not published | not published | not published |
Multiply for tool calls, then add deployment
Those monthly figures assume one model call per item. A real agent that looks up a contact, checks a calendar and then writes lands between two and four times the input figure, because each call carries the accumulated conversation. On Flash-Lite that turns $1.90 into perhaps $4 to $7, which changes nothing. On Pro it turns $10.80 into $25 to $40, which is worth a decision.
Deployment is the other half. Self-hosted on Cloud Run, an agent handling a thousand webhook-triggered runs a month is scaled to zero for most of the month and costs a few dollars, and the rates are published so you can price it before you build. Managed Agent Runtime is the alternative and the gap: on 6 August 2026 we checked the Vertex AI pricing page, the generative AI pricing page, the Agent Platform pricing page and the Agent Engine pricing documentation, and none gave a vCPU-hour or GiB-hour rate. We are not going to invent one.
So the honest all-in figure is between five and thirty dollars a month self-hosted, and unknown managed. If a supplier cannot tell you what the managed option costs, the self-hosted option is not merely cheaper, it is the one you can put in a budget. Our AI automation cost page frames the same trade-off across the wider tool market.
Bottom line: At 1,000 triage runs a month an ADK agent costs about $1.90 in Gemini 3.5 Flash-Lite tokens plus $5 to $20 for Cloud Run, while managed Agent Runtime deployment had no published vCPU-hour rate on any of four Google pricing pages we checked on 6 August 2026.
The gotcha: Gemini stopped being the cheap one
The received wisdom about Google's models is that they are the budget choice, and for a while that was straightforwardly true. It is no longer. As of 6 August 2026 the cheapest Gemini tier listed on the API pricing page is 3.5 Flash-Lite at $0.30 per million input and $2.50 output. On the same day OpenAI listed gpt-5-nano at $0.05 input and $0.40 output. That is six times cheaper on both sides, for exactly the classification and routing work that makes up most agent traffic.
This matters because the price gap was doing real argumentative work. Choosing ADK because Gemini tokens were cheapest was a defensible reason to accept the ecosystem gravity. Now the reason has to be the ecosystem itself: your documents are in Drive, your identity is in Google Cloud, your mail is in Gmail, and running the agent beside all three genuinely reduces integration work. That is a good reason. It is a different reason, and anyone whose business case rested on token price should redo the sum.
No meter means no brake
The second gotcha spans this whole batch of free frameworks. There is no meter and therefore no stop. An agent that loops keeps calling the model until something you built halts it. Set step limits, and set a budget alert on the Google Cloud project, because a project-level alert is the last line of defence that does not depend on your code being correct.
The free tier is a data problem, not a cost one
Google's pricing page states that free-tier content is used to improve its products while paid-tier content is not. Nobody decides to put customer data through a free key. What happens is that a prototype works, gets scheduled, and quietly becomes production on the key it was written against. If data residency or zero data retention matter to your clients, this is the first thing to check and the easiest to get wrong.
Bottom line: Gemini 3.5 Flash-Lite at $0.30 per million input tokens is six times the price of OpenAI's gpt-5-nano as of 6 August 2026, so ADK now has to be chosen for its Google ecosystem fit rather than for cheap tokens.
What breaks in production, and how you find out
Product churn is the ADK-specific failure and it is broader than models. Within roughly a year the documentation moved from google.github.io/adk-docs to adk.dev, which now returns a permanent redirect. Vertex AI Agent Engine became Agent Runtime on Agent Platform. And ADK 2.0 supersedes the toolkit's own SequentialAgent, ParallelAgent and LoopAgent in favour of graph-based and dynamic workflows, with the documentation recommending the newer structures for production. None of this stops a running agent, but it means a substantial share of published tutorials, including ones written this year, teach names and abstractions that have moved. Budget reading time into every upgrade.
The project itself is genuinely active
The GitHub API on 6 August 2026 reported 21,013 stars, 599 open issues and a push that same day, under an Apache 2.0 licence. Compare that with AutoGen elsewhere in this directory, where sixty thousand stars sit above a repository last pushed in April. Star counts do not tell you whether anyone is working on something. The push date does, and it is the first thing to check before adopting any framework.
Model deprecation, and the evaluation habit that survives it
Google's lineup turns over quickly enough that the 2.5-generation models named in guidance from last year no longer appear on the current pricing page. An agent pinned to a retired model will fail, on a date Google chooses. Keep the model name in configuration rather than in code, keep an evaluation set of real cases with known-correct answers, and use ADK's built-in evaluation tooling to confirm that a forced model change did not quietly degrade behaviour. This is the strongest practical argument for the evaluation support the toolkit ships with, and it is the difference between a model swap being a Tuesday and being a crisis.
The ordinary failures that still do the damage
Unbounded loops with no step limit. Tool arguments that are plausible and wrong, accepted by a downstream system that does not validate. Prompt injection arriving through the very documents the agent was built to read. And silent stoppage, where the agent stops running and nothing goes red because there is no platform watching. A heartbeat that alerts a person when successful runs stop arriving is the highest-value code in the project and it is almost never in the first version.
One structural note in ADK's favour: it offers deterministic workflow structures alongside LLM-driven delegation, and the documentation is explicit that the former produce predictable execution without asking a model to decide the order of operations. Where your process has a known order, specify it. Every step you take away from the model is a step that cannot fail creatively.
Bottom line: ADK's characteristic production problem is churn rather than instability: the docs domain, the hosting product name and the toolkit's own workflow agents all changed within about a year, so upgrades need reading time even though the repository is actively maintained.
What it connects to that you already run
The genuine advantage is Google itself. If your business runs on Workspace, the agent reaches Gmail, Drive, Sheets, Docs and Calendar through service account credentials inside the same project, which means no separate OAuth relationship, no third-party app holding a token in someone's browser, and access controls your administrator already manages. For a business whose documents and mail live in Google, that removes most of what integration work usually consists of.
On the model side ADK is more open than its reputation. Gemini and Claude are directly supported, and connectors cover LiteLLM, Ollama, vLLM, Apigee and LiteRT-LM, which between them reach essentially every hosted provider and every open-weight model worth naming. Model routing with automatic failover is built in, so a provider incident can degrade to a second model rather than to an outage. The asymmetry is real but small: Gemini is a string, everything else is a class you instantiate.
For business systems outside Google it is function tools and your own code, the same as every SDK here. There is no connector catalogue for your CRM, your accounting package or your booking system. Where those systems expose an MCP server or a clean REST API the work is modest; where they do not, it is the bulk of the project.
Deployment integrates in both directions, which is worth noting. Managed Agent Runtime, Cloud Run and GKE are all documented, and so is packaging the agent into a plain container for any environment that runs one, explicitly including offline and disconnected systems with no Google Cloud connectivity. That last option is what keeps the framework honest about being portable.
Bottom line: ADK's real integration advantage is service-account access to Gmail, Drive, Sheets and Calendar inside your own Google project, while every non-Google business system is still a tool function you write yourself.
Google ADK alternatives: what to pick instead, and when
Every framework below is free, so the table separates them on shape, ecosystem and cost of the model behind them rather than on licence price. The cost column uses the same reference workload throughout so the numbers are comparable.
| Option | Billing unit | Cost at reference workload | Who it suits | The one thing it does better |
|---|---|---|---|---|
| Google ADK | Model tokens plus deployment | ~$1.90 tokens plus $5 to $20 Cloud Run | Businesses already on Workspace and Google Cloud | Service-account access to Google data with evaluation tooling built in |
| OpenAI Agents SDK | Model tokens only | ~$0.31 on gpt-5-nano plus hosting | Python teams building against OpenAI | Cheapest tokens available and the smallest readable API |
| LangGraph | Model tokens; LangSmith priced separately | Same tokens, any provider | Unattended processes needing repeatability | Explicit graph control flow with checkpoints and approval gates |
| CrewAI | Model tokens only | Higher, because role delegation multiplies calls | Role-based agent teams | Expressing work as a crew with named responsibilities |
| Pydantic AI | Model tokens only | Same tokens plus hosting | Teams who want validated output above all | Type-safe structured outputs enforced at the boundary |
| Autonoly | Quoted per build, no per-seat licence | Quoted after a free automation audit | Businesses with the process and no developer | A running, documented workflow you own rather than a toolkit |
When to pick the alternative
Pick the OpenAI Agents SDK if token cost is the deciding factor, because gpt-5-nano is six times cheaper than the cheapest Gemini as of 6 August 2026 and the framework is smaller. That flips only if your data lives in Google, in which case the integration saving outweighs the token gap at these volumes, since the whole bill is a few dollars either way.
Pick LangGraph if the agent must behave the same every run and you want a more settled API to build against. ADK's churn is real, and a process nobody is going to babysit is better served by a framework that is not renaming its abstractions. LangGraph also runs perfectly well against Gemini, so choosing it does not mean leaving Google's models. Pick Pydantic AI when a valid record matters more than a good sentence, and CrewAI when the work genuinely benefits from several roles.
Pick a done-for-you build over any of them if nobody on your side will own the code in eighteen months. That is a more common answer than framework comparisons suggest, and the honest test is not which toolkit is best but who reads the alert when the agent stops.
Bottom line: Choose Google ADK when your data already lives in Workspace, the OpenAI Agents SDK when token cost decides it, and LangGraph when an unattended process needs a more settled API than ADK's rate of change provides.
Migration and lock-in: can you get your work out?
On the framework, the position is good. ADK is Apache 2.0, the code is yours, and Google cannot change a price or retire a plan out from under it. It is model-agnostic in a way that is demonstrably real rather than aspirational, and the documented deployment options include container-friendly infrastructure with no Google Cloud connection at all. If you self-host, you can leave.
The gravity comes from three places, in ascending order of stickiness. Model choice is mildest, since swapping Gemini for Claude or an open-weight model through a connector is a configuration change plus prompt tuning and an evaluation run. Managed Agent Runtime is next, because a deployment depending on Google's runtime, its session handling and its operational tooling is a redeployment rather than a redeploy. And Workspace integration is strongest, because if the agent's value comes from reaching Gmail, Drive and Calendar with Google identity, moving it means moving the business, which nobody does to escape a framework.
The framework's own churn is the migration you are more likely to face first. ADK 2.0 superseded the template workflow agents a lot of existing code uses, and the toolkit's names and hosting products have moved more than once in a year. That is not vendor lock-in, but it carries the same practical cost: engineering time spent standing still. Read the release notes before upgrading, and pin your version so the timing is your decision.
The habits that keep your position comfortable are cheap. Keep the model name in configuration. Keep Google API access behind your own thin interface rather than scattered through agent code. Keep an evaluation set of real cases with known-correct answers, because it turns every migration from an argument into a measurement. And prefer Cloud Run or a plain container over managed runtime until you have its price in writing, because that is the one dependency here you would be taking on without knowing what it costs.
Bottom line: ADK itself is Apache 2.0 and portable down to an offline container, so the real stickiness is Workspace data access and managed Agent Runtime, and self-hosting on Cloud Run keeps the exit genuinely open.
Google Agent Development Kit (ADK) FAQ
What does Google ADK cost?
The framework is free and Apache 2.0 licensed. Your model costs are published: as of 6 August 2026 the cheapest listed Gemini tier is 3.5 Flash-Lite at $0.30 per million input and $2.50 output on the paid API tier, with 3.5 Flash at $1.50 and $9.00. Self-host the agent on Cloud Run or your own container and add ordinary compute costs. If you deploy on managed Agent Runtime, infrastructure bills separately and we could not find those rates published anywhere on Google's pricing pages.
Is Gemini still the cheapest option for agents?
No, and this is a change worth knowing if you last looked a year ago. Gemini 3.5 Flash-Lite lists at $0.30 per million input and $2.50 output as of 6 August 2026. OpenAI's gpt-5-nano lists at $0.05 input and $0.40 output on the same day, which is six times cheaper on both sides for the classification and routing work that makes up most agent traffic. Gemini remains competitive on capability per dollar in the middle tiers, but the automatic assumption that Google is the budget choice no longer holds.
Why can you not tell us what Agent Engine deployment costs?
Because Google does not publish it anywhere we could find it. On 6 August 2026 we checked the Vertex AI pricing page, the generative AI pricing page, the Agent Platform pricing page and the Agent Engine pricing documentation. All four covered model tokens; none gave a vCPU-hour or GiB-hour rate for running a deployed agent. Rather than repeat a figure from a third-party blog, we are flagging the gap. Managed compute for a long-running agent can exceed token cost, so get the rate before you commit.
Is ADK really model-agnostic or is it a Gemini funnel?
Genuinely multi-provider, with an asymmetry. Gemini and Claude are directly supported, and other providers arrive through connector classes including LiteLLM, Ollama, vLLM, Apigee and LiteRT-LM. There is also built-in model routing with automatic failover between models. The asymmetry is that Gemini is a model string while everything else is a wrapper you instantiate, and the documentation examples default to Google. That is friction rather than a fence, and it is a fair distance from the Gemini-only reputation the toolkit carries.
Is the free Gemini tier safe for business use?
No, and this is the single most important warning for anyone prototyping on Google's models. The Gemini API pricing page states that free-tier content is used to improve Google's products, while the paid tier explicitly says it is not. The common failure is not a decision but a drift: a prototype built on a free key quietly becomes production. Attach billing and confirm you are on the paid tier before a single real customer record passes through, and check the key your deployed agent actually uses rather than the one you meant it to use.
What breaks with ADK in production?
Churn is the Google-specific one and it is not only about models. In roughly a year the docs moved from google.github.io/adk-docs to adk.dev, Vertex AI Agent Engine became Agent Runtime on Agent Platform, and ADK 2.0 superseded SequentialAgent, ParallelAgent and LoopAgent in favour of graph-based workflows. None of that breaks a running agent, but it invalidates tutorials and makes upgrades a reading exercise. Beyond that: unbounded loops without step limits, wrong tool arguments accepted downstream, and silent failure nobody notices.
Where should we deploy an ADK agent?
ADK documents four routes: managed Agent Runtime on Agent Platform, Cloud Run, GKE, and any container-friendly infrastructure including fully disconnected environments. For most businesses Cloud Run is the right answer, because an agent triggered a few hundred times a month is exactly the scale-to-zero shape Cloud Run bills well, and its rates are published. GKE is for teams already running Kubernetes or serving open models. Managed Agent Runtime removes operational work at a price we could not verify.
ADK or LangGraph for a Google-based business?
ADK if you want the shortest path onto Google Cloud, tight fits with Google identity and data, and built-in evaluation tooling. LangGraph if you want the larger ecosystem, a more stable API surface and explicit graph control flow you define yourself, and it runs perfectly well against Gemini models. The honest tiebreaker in 2026 is churn tolerance: ADK moves quickly, which brings capability and maintenance in equal measure. For a process that must run unattended for years with minimal attention, the more settled option usually wins.
Can you build an agent on the Google stack for us?
Yes, and for a business already on Google Workspace it is often the simplest route, because the data, the identity and the deployment sit in one place. We scope it on a free automation audit, confirm you are on paid API terms before any real data moves, deploy somewhere with published pricing unless you have a rate for managed runtime in writing, and build with evaluation cases and step limits from the start. You get the code, the accounts and the documentation outright, plus a recurring plain-language report of what ran and what it cost.
Looking at alternatives? ADK is a capable framework and the natural pick if your business already lives in Google Workspace and Google Cloud, where the data, the identity and the deployment sit in one place. We would push back on two received ideas. The first is that Gemini is the cheap option: at $0.30 per million input tokens the cheapest current Gemini is six times OpenAI's cheapest, so choose it for the ecosystem fit rather than the price list. The second is that managed deployment is a solved cost question. It is not published where we could find it, so if Agent Runtime is your plan, get the rate in writing before you design around it. Self-hosted on Cloud Run the economics are clean and the lock-in is mild. Autonoly exists for the business with the process and no developer; if you have one and you are on Google, this is a reasonable place to start. See the Autonoly review.
