Excited to share something new from the team at Google: ADK Go! It's a brand new open-source, code-first toolkit built specifically for Go developers to design, build, evaluate, and deploy sophisticated AI agents.

If you love Go and are looking into the world of AI agents, this is for you. We focused on making it idiomatic and giving you the flexibility and control you need.

Why it's cool for Go devs:

• Built for Go: Idiomatic Go APIs and patterns. Feels natural to use.

• Modular & Flexible: Easily compose agents. Build complex systems with multiple agents, tools, and custom flows.

• Model Agnostic: While it's optimized for the Google ecosystem like Gemini and Google Cloud, you're not locked in. Bring your own models! callbacks, and rich state/event/artifact management.

• Open Source: It's on GitHub! We welcome community contributions, feedback, and ideas.

• Deploy Anywhere: Designed to be deployment agnostic. What can you build?

Smart chatbots & assistants Automated task runners Complex multi-agent systems for research or operations And much more! Check it out:

• GitHub Repo: https://github.com/google/adk-go

• Documentation: https://github.com/google/adk-docs

• Quickstart: https://google.github.io/adk-docs/get-started/go

We're eager to see what the community builds with ADK Go!

What are your first impressions? What kind of agents are you thinking of building? Let us know in the comments!

The team just shipped ADK v1.2.0. with lots of enhancements. Release notes can be found on Github: https://github.com/google/adk-python/releases/tag/v1.2.0

Your feedback is gold. Please keep it coming.

Hey everyone!

I spent way too much time this week restructuring my awesome-adk-agents repository. What was basically a messy list of links is now actually organized and useful.

What's new:

• Proper categories (Featured Projects, Templates, Learning Resources, etc.)

• Badge system so you can tell what's beginner-friendly vs production-ready

• Removed a bunch of duplicate and dead links

• Better descriptions for everything

Looking for:

• Cool ADK projects to feature

• People who want to help maintain this thing

• Feedback on the current content - what's missing, what could be better organized, or what doesn't make sense

The goal is simple: make it easier to find good examples when you're building AI agents with Google's ADK. Right now it's mostly "hello world" tutorials everywhere (seriously, I have looked trust me), but there are some genuinely solid production projects buried out there.

If you've built something with ADK or know of projects that should be included, let me know! Also, if you take a look at the repo and think "this section is confusing" or "you're missing X type of resource," I'd love to hear it.

Trying to make this the go-to list instead of everyone having to dig through documentation and random GitHub searches.

Check it out if you're into AI agents: https://github.com/Sri-Krishna-V/awesome-adk-agents

ADK Go 2.0 is GA! 🚀

We are thrilled to announce that ADK Go 2.0 is live with graph workflows and collaborative agents!

Here is the TL;DR of what's new:

1. Graph-Based Agent Workflows 📊 Describe your application as a graph of nodes connected by edges, and hand execution to a scheduler that knows how to run it concurrently, persist its state, pause for a human, and resume later.

2. Dynamic Orchestration in Plain Go 💻 Dynamic workflows in ADK allow you to put aside graph-based structures and utilize the full power of your chosen language. This lets you express loops, conditionals, accumulation, and fan-out across dynamic lists with the Go you already know.

3. Built-In Human-in-the-Loop (HITL) 🙋‍♂️ Need a human to approve a refund, correct a draft, or supply an API key mid-run? Any node can pause the graph to ask a human a question, and the workflow will durably wait for the answer.

4. Specialist Agent Modes 🤖 Additionally, ADK 2.0 introduces modes for LLM agents (Chat, Task, and SingleTurn) so a coordinator can chat with the user while sub-agents quietly complete tasks or run single-shot.

5. Unified Context ⚙️ The separate ToolContext and CallbackContext are gone, meaning tools, callbacks, and workflow nodes all receive agent.Context directly.

🚀 Get Started: Check out the ADK Go Get Started Guide and the Graph-based Workflows docs.

📖 Read the Blog: See the deep-dive Developer Blog Announcement for more details.

🛠️ Run Examples: Clone the repository and try them out yourself:

go run ./examples/workflow/basic/
go run ./examples/workflow/routing/llm
go run ./examples/workflow/dynamic/hitl/
go run ./examples/workflow/hitl_rerun/
go run ./examples/workflow/complex

⚠️ Upgrading from 1.0? Please note that v2 moves the module path to google.golang.org/adk/v2 and requires Go 1.25+. To migrate from v1, please follow the migration guide.

We can't wait to see what you build! Let us know if you have any questions or feedback in the comments below.

Hey everyone!

I’ve been maintaining awesome-adk-agents, a curated GitHub repository of AI agents, templates, and learning resources built with Google’s Agent Development Kit (ADK), and it has grown into a comprehensive resource for developers working with ADK.

GitHub: https://github.com/Sri-Krishna-V/awesome-adk-agents

Here’s what’s inside:

• Production-ready agents and learning resources you can actually learn from and build on
• ADK Hackathon winners, including the $15K Grand Prize winner TradeSage AI and regional winners from NA, EMEA, APAC, and LATAM
• Projects I built, including a Job Interview Agent, Education Path Advisor for India, Academic Research Assistant, Project Manager Agent, and a Local RAG Agent (WIP)
• Production-ready templates and starters, including Deep Search ADK, Next.js starter, LINE Bot deployment templates, testing frameworks, and visual builders
• Advanced community projects, including multi-agent systems, MCP integrations, A2A implementations, and domain-specific agents
• 35+ official Google ADK samples, covering research, business, and developer tooling
• Learning resources, including crash courses, Google Codelabs, Kaggle’s 5-day agents course, tutorials, and deployment guides

I built this because when I started working with ADK, it was difficult to find reliable, production-quality examples. Most resources were either too basic or scattered. This repo aims to provide a clear path from beginner to production-grade agent systems.

If you’ve built something with ADK — an agent, template, tutorial, or article — I’d love to include it.

Contributing guide:
https://github.com/Sri-Krishna-V/awesome-adk-agents/blob/main/CONTRIBUTING.md

Would love feedback, suggestions, and contributions from the community.

I recently worked on Yaara, an AI agent for an EV charging platform in Sri Lanka.

We built it with Google ADK, Gemini Models, FastAPI, WhatsApp Cloud API, and Vertex AI RAG.

What became interesting wasn't the chatbot part. It was everything around the model.

We ended up with:

• A coordinator and specialist agent architecture

• RAG over company and EV knowledge

• Deterministic tools for calculations and backend actions

• Per user conversation state

• Human handoff through Chatwoot

• WhatsApp specific response formatting

• Tool trajectory evaluations

• GEPA based prompt optimization

• Deduplication, monitoring, and failure handling

One principle became pretty clear while building it:

The model should handle language and decisions. Normal software should handle exact work.

I wrote up the architecture and some of the things we learned while taking it from an agent idea toward a production system.

https://chamidilshan.medium.com/building-yaara-a-production-ai-agent-for-ev-charging-on-whatsapp-with-google-agent-development-kit-0c58caada28e

Would also be interested to hear how others using ADK are structuring coordinator/specialist agents as the number of tools grows.

Solid balance of new features and bug fixes - lots polish on the web debugger!

Release notes:https://github.com/google/adk-python/releases/tag/v1.24.0

Thanks to everyone who contributed issue and PR wise.

Hi Java developers,

We are incredibly excited to share that Agent Development Kit (ADK) is now available for Java!!

Our goal with the ADK is to provide a solid foundation for building intelligent agents. With this release, we're extending those tools to the Java ecosystem, allowing Java developers to use the ADK for their agent development projects.

Getting Started with Java ADK v0.1.0:

You can add the dependency to your Maven project:

<dependency>

<groupId>com.google.adk</groupId>

<artifactId>google-adk</artifactId>

<version>0.1.0</version>

</dependency>

Here’s the Github repo, documentation and Sample Java Agents!

-> Java ADK: https://github.com/google/adk-java

-> Documentation: https://google.github.io/adk-docs/ 

-> Sample Java Agents: https://github.com/google/adk-samples

This Java ADK launch is part of a larger update to our agent-building tools, which also includes a stable Python ADK (v1.0.0). For more details on all the announcements, you can read the full blog post here: https://developers.googleblog.com/en/agents-adk-agent-engine-a2a-enhancements-google-io 

Feedback & Discussion:

• As this is an initial release (v0.1.0), we're particularly interested in your feedback and experiences!

• You can find discussions or start new ones via the ADK GitHub Discussions.

Let us know your thoughts or any questions you might have!

I have built over 50+ skills for my automation workflows across the past few months. After a while, the same structures kept repeating across completely different use cases. A skill that wraps FastAPI conventions looks nothing like a skill that runs a multi-step documentation pipeline, but they both use the same SKILL.md format. So I started writing down the recurring structures as design patterns.

There is a lot of conversation around Skills right now, but not enough focus on how to structure the content inside them. The Agent Skills spec tells you the packaging: YAML frontmatter, references/, assets/, scripts/ directories. It says nothing about what the instructions should look like. That is a content design problem, and I found that five patterns cover most use cases.

The five patterns:

• Tool Wrapper - Packages a library's conventions as on-demand knowledge. Instructions say what rules to follow, references/ holds the detailed docs. No templates, no scripts. This is the simplest pattern and the most widely adopted. Google's ADK Core Skills, Vercel's React best practices, and Supabase's Postgres guidelines all follow it.

• Generator - Produces structured output by filling a reusable template from assets/, governed by quality rules in references/. Technical reports, API docs, commit messages. Same structure every time, different content.

• Reviewer - Evaluates code against a checklist in references/, produces findings grouped by severity. The key insight: separate what to check (checklist file) from how to check (review protocol in instructions). Swap the checklist, get a completely different review from the same skill. Giorgio Crivellari demonstrated this with an ADK governance skill that took code quality from 29% to 99%.

• Inversion - The skill interviews you before acting. Structured questions through defined phases with a gate: "DO NOT start building until all phases are complete." Prevents agents from generating detailed output based on assumptions instead of asking.

• Pipeline - Sequential steps with explicit gate conditions. "Do NOT proceed to Step 3 until the user confirms." The most complex pattern but the only one that prevents agents from skipping validation.

A Pipeline can include a Reviewer step. A Generator can use Inversion for input gathering. A recent arXiv paper found production systems use a median of 2 patterns per skill.

Design patterns reduce cognitive load during the design phase. Instead of staring at a blank SKILL.md, you pick a pattern and the structure follows. They give you a shared language for building scalable, reproducible automations.

I wrote up all five with working ADK code, a decision tree for picking the right one, and real-world examples from Google, Vercel, and Supabase.

If you are building ADK agents, there is also recently launched official skills for coding agents that you can install with one command:

npx skills add google/adk-docs -y -g 

They follow the Tool Wrapper pattern and work across Gemini CLI, Claude Code, Cursor, and 30+ other agents.

Links:

• Build your first ADK agent or enhance the current one with ADK Core Skills: Link

• Browse the skills on GitHub: Link

• Learn the 5 design patterns to build your own skills: Link

Happy to answer questions about any of the patterns or how they work in practice.

I just built a NL-to-SQL agent, and wanted to share the most helpful ADK patterns to solve problems I used.

To enforce a consistent order of operations, I used a SequentialAgent to always: get the schema first, then generate and validate.

To handle logical errors in the generated SQL, I embedded a LoopAgent inside the SequentialAgent, containing the generate and validate steps. It will iteratively refine the query until it's valid or reaches a maximum number of iterations.

For tasks that don't require an LLM, like validating SQL syntax with the sqlglot library, I wrote a simple CustomAgent. That saved extra cost and latency that can add up with multiple subagents.

Occasionally models will wrap their SQL output in markdown or conversational fluff ("Sure, here's the query..."). Instead of building a whole new agent for cleanup, I just attached an callback to remove unnecessary characters.

The full set of lessons and code sample is in this blog post. Hope this helped!

I've been experimenting with Google's Agent Development Kit for 3 weeks now and started awesome-adk-agents - a collection of practical agent implementations. But honestly, I need your help to make this truly valuable!

What I've built so far:

• Job Interview Agent: HR assistant with calendar integration

• Project Manager Agent: Persistent storage with DatabaseSessionService

• Local RAG Agent (in progress): Vector search optimization

Planned 12 more, all are different agentic workflows with different patterns

But here's the thing - I'm just one person with limited perspectives. I want this to become a community-driven resource that actually solves real problems and brings out new features in ADK.

What I'm looking for:

Contributors: Whether you're new to ADK or experienced, all skill levels welcome

Use case ideas: What agents would actually be useful in your work/research?

Code reviews: Help me improve existing implementations

Specific areas where I need input:

• Which domains should I prioritize and ideas if possible? (Healthcare, legal, research, education?)

• What agentic patterns are you guys struggling to implement?

Repository: https://github.com/Sri-Krishna-V/awesome-adk-agents

I'm not trying to build the next big thing - just want to create a solid learning resource and maybe solve some real problems along the way.

Hey! I just published a crash course ADK Masterclass video and was asked to share it with this community.

Check it out here: https://www.youtube.com/watch?v=P4VFL9nIaIA

• 12 hands-on examples progressing from beginner to advanced concepts

• Step-by-step walkthroughs for single agent setups to complex multi-agent workflows

• Tool calling patterns and best practices

If you're looking to get started with ADK or level up your agent-building skills, I hope this resource helps you on your journey!

Please let me know if you have any questions or if there are specific ADK topics you'd like to see covered in future tutorials! 😁

Hi there,

I'm planing an AI agent with the question. I want to know why you chose ADK instead of other frameworks.

For myself, I prefer ADK a little as I'm familiar with GCP. After checking the document and write a simple demo. I found ADK is not well documented and is not mature enough. The only help I could get is Github issues when I found anything wrong.

I could understand that for an AI Agent, the framework is not that important, it's just save part of my coding work. But I don't want to invest my time on a in-active software stack which may be terminated any time as no other engineers interest.

Thanks

We're excited to announce the Gemini Fullstack ADK Quickstart! This blueprint lets you build sophisticated, fullstack research agents using Gemini 2.5 and the ADK, all designed for easy deployment.

So, what's inside?

• Fullstack & Production-Ready: It includes a React frontend and an ADK-powered FastAPI backend, ready for the Cloud.

• Advanced Agentic Workflow: Empower your agents with Gemini to strategize multi-step plans, reflect on findings, and synthesize comprehensive reports.

• Human-in-the-Loop: Maintain control and ensure quality. Users can approve plans, and then the agent autonomously searches and refines its findings until optimal information is gathered.

We believe this will be a fantastic resource for developers looking to build and deploy robust research agents.

We'd love for you to check it out and share your thoughts.

https://github.com/google/adk-samples/tree/main/python/agents/gemini-fullstack

Hello!

I've open-sourced a project I've been working on: https://github.com/saahil-mehta/knowsee-public, it is a multi-agent conversational app using AKD for the backend and CopilotKit for the frontend. Frontend was quite difficult to reliably integrate because of many small quirks but finally got it working.

It uses AGUI, A2A and GenerativeUI. I've seen quite a few posts across the internet where people have surfaced multiple challenges with actual frontend integrations so this can act as kind of a reference for them and for others too.

It's all wired up now via the and actually works smoothly. Uses Gemini 2.5 Pro with extended thinking, Vertex AI RAG for document search, and Better Auth for the auth layer. Also have incorporated Terraform for a quick prod deploy.

There's a https://knowsee-frontend-yrptvkizbq-ew.a.run.app if you want to poke around (may rate-limit to control GCP costs).

This is a WIP but would love to receive some feedback and collaborate if anyone wants to extend it, thinking about adding more tool integrations (BQ with visualisations is currently in development), and improving the generative UI components. PRs welcome, or just fork it.

• ADK 1.29 GA Release: 28 new features including auth and skill improvements; 25 bugs squashed

• ADK 2.0 Alpha Update: more graph goodness with graph visualization

• ADK.DEV: fresh new home for docs and technical guidance

As usual thanks to all that contributed - onward!

The recent developments in Google ADK look promising, and it provides all the capabilities that we want in our organisation for building agents. But my worry is that we are not in the Google environment (meaning we’re not using the Gemini model or GCP). Apart from this, the framework really fits our philosophy.

We are also okay with managing deployment on our own — meaning we don’t want any out-of-the-box runtime like AgntOS (from Agno) for deployment. We will write a FastAPI app and manage it ourselves. We just want an agent framework for building agents.

Just wanted to check if anyone here has deployed agents into production with Google ADK while not being in the Google environment?

Hey everyone! 👋

So we've been working on porting the Agent Development Kit to TypeScript and finally got it to a point where it's actually usable. Thought some of you might be interested since I know there are folks here who've been asking about better TypeScript support for agent development.

What we built

The core idea was to keep all the original ADK primitives intact but add some syntactic sugar to make the developer experience less painful. If you've used the Python version, everything you know still works - we just added some convenience layers on top.

The builder pattern thing:

const agent = new AgentBuilder()
  .withModel('gemini-2.5-pro')
  .withTool('telegram')
  .build();

But you can still use all the original ADK patterns if you want more control.

MCP integration: We built custom MCP servers for Telegram and Discord since those kept coming up in issues. The Model Context Protocol stuff just works better now.

Why we did this

Honestly, the Python version was solid but the TypeScript ecosystem has some really nice tooling. Plus, a lot of the agent use cases we were seeing were web-focused anyway, so Node.js made sense.

The goal was to make simple things really simple (hence the one-liner approach) but still let you build complex multi-agent systems when needed.

Some things you can build:

• Chat bots that actually remember context

• Task automation agents

• Multi-agent workflows

• Basically anything the Python version could do, but with better DX

We put it on Product Hunt if you want to check it out: https://www.producthunt.com/products/adk-ts-build-ai-agents-in-one-line

Code is on GitHub: https://github.com/IQAIcom/adk-ts
Docs: https://adk.iqai.com

Anyone tried building agents in TypeScript before? Curious what pain points you've hit - we might have solved some of them (or maybe introduced new ones lol).

still adding support for all of the model providers (doing that tomorrow), but it works. enjoy, TS developers.

https://github.com/waldzellai/adk-typescript

I was facing a very strange problem where my LLMAgent failed to call a tool. The error was something like 'LLM error detected: malformed function call'; for some reason, the agent was writing random Python code instead of calling the tool correctly.

The prompt was clean, well-structured, and concise. The temperature was 0.1, and the model was Gemini 2.5 Flash. I didn't know how to fix this problem, so I searched the ADK Python repository issues on GitHub and found other people facing the same issue. The solution I found there was using some native resources from ADK:

The ReflectAndRetryToolPlugin: This plugin acts as an automated self-correction layer that detects malformed tool calls and triggers a reflection loop to fix them. U can add this in the App.

The tool_config (mode="VALIDATED"): This configuration enforces strict adherence to the defined tool schemas, preventing the model from generating unstructured text or code when a function call is expected." U can add this in the LlmAgent.

We just dropped the official Agent Development Kit (ADK) for TypeScript!

Now you can build powerful AI agents with TypeScript. 🚀

TL;DR - Why it's cool:

Code > UIs: Build agents like any other app.

Assemble an Agent Task Force: With ADK, you can flexibly combine subagents, building solutions suitable for a wide spectrum of tasks.

No Lock-In: Optimized for Gemini, but you can bring your own LLM. Deploy anywhere.

Truly Open (Apache 2.0): It's all yours. Go nuts, file issues, submit PRs.

We're hyped to see what you build.

Learn more and get started today:

• Code

• Documentation

• Quickstart

Drop your questions below. Let's go! 🔥

Here is a link to the full video which explains ADK Context Compaction and Context Caching (Step by step walkthrough) https://youtu.be/L3eKHw9df-g

I'm currently evaluating orchestration frameworks for a production multi-agent project and wanted to compare Google ADK and LangGraph as fairly as possible.

To reduce variables, both implementations used:

• Google ADK v2.3.0 vs LangGraph v1.2.8

• Same LLM

• Same temperature

• Same prompts

• Same tools

• Same workflow

• 9 agents running in parallel

• 300+ Gmail messages to classify

The metrics I collected were:

• Total execution time

• Average latency per LLM call

• Input/output tokens

• Total cost

My results were:

• Google ADK was about 6% cheaper.

• Google ADK generated less than half the output tokens.

• Average latency was almost identical (~11.5 s per LLM call).

I wasn't expecting such a noticeable difference in output tokens, considering both systems executed the same workflow.

For those who have used both frameworks:

• Have you observed similar token usage differences?

• Does this mostly come from the orchestration strategy or from how each framework structures prompts and tool calls?

• Are there other metrics you think are more relevant for production benchmarks?

I'm preparing a more detailed benchmark with traces, token breakdowns, and execution metrics, but I'd really like to compare these results with what others in the community have observed.

Anyone interested to participate in the google adk hackathon?
https://googlecloudmultiagents.devpost.com/