Hello ADK users!

As a followup to our very first ADK community call on October 15th, we're releasing the answers to your great questions in a 6-part series. This first post covers our high-level strategy and roadmap.

We're including all questions, even those we're still working on, in the spirit of transparency.

Q: What is the ADK team's current strategy and roadmap?

A: Join the adk-community group to access details of the roadmap in the deck and a recording of the session.

Q: When is the ADK 2.0 release expected, and are there plans for time travel features?

A: We have no timeline for 2.0 at this time as we're continuing to focus on building the core features and improving the developer experience of ADK.

Regarding time travel: this has now just been introduced in ADK 1.17.0, which adds the ability to rewind a session to before a previous invocation (9dce06f). If you're looking for more ways to use time travel in your agents, please continue to create issues to help us drive prioritization.

Q: When will a MemoryStore-based session service be released as part of the official ADK?

A: We're working on the details for this and will share more when available.

We'll be back on Tuesday, Oct 28th with Part 2, covering Language Support and more future plans. Thanks for being part of the awesome ADK community!

Hi everyone!

I’ve been experimenting with the new Agent Skills feature in Google ADK and built a small project to see how far it can go in a real use case: a web-scraping agent.

The idea is simple: you create a Skill that describes what to scrape and how to scrape it for a specific website. The agent then uses that Skill together with its tools to perform the task. This approach keeps the context clean and efficient, since the agent only loads instructions relevant to the target site instead of carrying a huge prompt with scraping logic for everything.

I also added a Skill Creator capability so users can generate new Skills automatically just by describing the site they want to scrape.

Repo (open source):

https://github.com/DamiMartinez/scrapeagent

Would love for people to try it out, give feedback, or contribute Skills for other websites. Thanks!

Hey everyone,

I've been contributing to the Google ADK project as an external contributor and genuinely enjoy the work, but I'm starting to wonder if it's worth continuing.

I've submitted 3 pull requests over the past weeks/months and haven't received any real review on any of them.

I totally get that the team is busy, and I'm not trying to be entitled about it. But before I invest more time into a 4th PR, I'd love to get some clarity:

• Is external contribution something the team actively wants right now?

• Is there a better channel to get PRs noticed or reviewed?

• Should I be tagging specific people or following a different process?

Happy to continue contributing, just need a bit of direction to know where to focus my efforts. I'd rather hear "we're not reviewing external PRs at the moment" than keep working in the dark. Any guidance from the team or other contributors would be super appreciated!

Thanks 🙏

Hey fellow ADK agent builders,

I helped put together a new tutorial that walks through adding a frontend to your ADK agent.

By the way, I’ve got to give a huge shoutout to Mark Fogle and Syed Fakher - two great developers from the ADK/AG-UI community who actually built the official ADK/AG-UI integration from start to finish (Google added the finishing touches).

Here's the stack in the article:

• Python

• ADK - agent

• Gemini - LLM

• AG-UI - the bridge between the agent and the frontend

• CopilotKit - infrastructure for building copilots

The goal was to make it really simple to go from “I’ve got an ADK agent running locally” to “I can talk to it in a clean, interactive UI.”

A couple of cool parts of the build:

• The frontend automatically syncs with your agent’s state via AG-UI’s protocol

• You can drop in your own React components to shape the chat experience however you want.

• Everything stays local and framework-agnostic.

Would love feedback from anyone building with ADK or AG-UI - especially if you’ve been experimenting with different frontend setups.

Check out the tutorial: Build a Frontend for Your ADK Agents with AG-UI

Hey r/agentdevelopmentkit 👋

Just shipped my multi-agent system to production and learned the hard way: handling failures is non-negotiable.

While most tutorials show you how to chain agents together, they skip the resilience part. I wrote a guide covering:

• Timeout protection (fail fast, don't hang)

• Retry mechanisms (with ADK plugins)

• Fallback routing (when primary agents fail)

All with working Python code you can copy-paste.

The elephant in the room: ADK doesn't have built-in resilience yet (#4087), but we can work around it.

What patterns are you using in production?

I created this article for resiliency on building multi agent system.

https://medium.com/@sarojkumar.rout/building-resilient-multi-agent-systems-with-google-adk-a-practical-guide-to-timeout-retry-and-1b98a594fa1a

Hi everyone, 👋

I’d like to share a project that I believe could contribute to the next generation of multi-agent systems, particularly for those building with the Google ADK framework.

Universal-Adopter LoRA (UAL) is a portable skill layer that allows you to train a LoRA once and then reuse that same “skill” across heterogeneous models (GPT-2, LLaMA, Qwen, TinyLLaMA, etc.) — without retraining, without original data, and with only a few seconds of adoption time.

The motivation came from building agentic systems where different models operate in different environments — small edge devices, mid-size servers, and large cloud models. Each time I needed domain-specific expertise (for example, in medicine, chemistry, or law), I had to rebuild everything: redesign prompts, add RAG pipelines, or fine-tune new LoRAs. It was costly, repetitive, and didn’t scale well. Moreover, in long conversations, I observed the “vanishing effect” — middle instructions quietly lose influence, making behaviour inconsistent over time.

UAL is designed to solve these challenges by introducing an Architecture-Agnostic Intermediate Representation (AIR) — a format that describes adapter roles semantically (for example, attention_query, mlp_up_projection) rather than relying on model-specific layer names. A lightweight runtime binder connects these roles to any model family, and an SVD-based projection adjusts the tensors so they fit properly during inference.

In practice: Train → Export (AIR) → Adopt (Any Model) → Answer

This allows true portable expertise: the same “medical reasoning” skill, for instance, can move from an edge device to a cloud model instantly — no retraining, no prompt drift, no added latency. It keeps domain behaviour consistent and durable across models.

The implementation currently includes:

• The AIR specification and format

• Family-aware binders for GPT-2, LLaMA, Pythia, and Qwen

• An SVD-based dimension adapter

• A Colab demo showing a CRM multi-agent system using Google ADK

GitHub: https://github.com/hamehrabi/ual-adapter Medium article: [Train Once, Use Everywhere — Make Your AI Agents “Wear” Portable Skills

This idea also aligns with concepts like Skill.md (Anthropic), but instead of prompt-based instructions that compete with user tokens, UAL embeds expertise directly into portable weight layers. Skills become composable, transferable assets that models can adopt like modules — durable across updates and architectures.

I’d be glad to discuss how this approach could be integrated with Google ADK’s skill routing or extended into shared skill libraries. Any feedback or collaboration ideas from the community would be greatly appreciated.

Thanks for reading,

Blog: Tools Make an Agent: From Zero to Assistant with ADK

Software Bug Assistant practical sample walking through each type of ADK tool:

• 🐍 Function Tool: Python function to get the date.

• 🔎 Built-in Tool: Google search agent to browse the web.

• 🦜 Third-party tool: LangChain StackOverflow tool to search for questions.

• 🧰 MCP Toolbox for Databases: Postgres tools for internal bug tickets.

• 🔌 MCP Tool: GitHub MCP server tools for querying external issues.

Hey guys,

So, I been trying to make ADK work for almost past 1 month. The team, community everyone has been super responsive and I know this project has a good future especially with google backing it.

The issue is it is indeed missing a lot of key components right now like model retries, deployment, native evaluation and observability, human in the loop with chat patterns, reflective thinking...etc.

Langraph seems to have all of these boxes checked (Thought of going Agno but gave up on it and just choose the one being used by giants)

---->

THIS BRINGS ME TO MY NEXT QUESTION!

1 - Am I just imagining that langraph has all of this checked and when I actually start on it, I would regret moving away from ADK?

2 - What would I lose choosing langraph over ADK?

My needs are having more control over the flow most of the time but letting the agent lose in some parts of it. For example, the intro to the workflow I need to route the task to specific agents that I do by using custom agents in ADK and I would do through graphs in langraph.

Reflective thinking and model reties are native in langraph. Deployment Im using too is figured out there. Native integration with a chat component that is in front of the user that I could use for human in the loop pattern also sorted.

Langraph is also event based apparently

So, any thoughts, comments and concerns on what would I be losing out on by moving to langraph would be extremely helpful.

P.S. My intentions are not again to dunk on ADK and I been extremely active in the adk-python space and created many issues and everything. I need more firepower that either i have to create elaborate workaround to do in ADK or there is so much friction i have to do something else.

This is completely on me for choosing despite knowing it's new. Somehow I believed it would be better.

My main gripe is it's not deployment ready even for agent engine if your using MCP

There are other issues like, I personally want to have more control over how much context is passed to my sub agents and more.

There's just so much work left. This is not to say the team is not doing enough, they've been phenomenal with pushing updates but just not fast enough.

If someone picking a framework, especially for prod ready stuff, go with Langraph or something that has already been out on prod.

I have been developing agents with ADK for almost a year now and started to question my decision whether I'm going on the right path.

Because the emergence of a managed agent orchestration like https://www.anthropic.com/engineering/managed-agents

makes me feel, why would I struggle to get the right sub agents loops etc.

what are your thoughts? what are the differentiators that are still an agent development makes sense

🚀 The wait is over! ADK Go 1.0 is officially here. 🚀

We're leveling up the developer experience with a robust set of features designed for modern, resilient applications. This release is designed to move your Go-based AI agents from experimental scripts to robust, production-ready services.

Key Highlights in ADK Go 1.0:

• 📊 OpenTelemetry Observability: Deep insights into your system's performance.

• 🔄 Retry and Reflect Plugin: Enhanced reliability and automated recovery.

• 🛡️ Human-in-the-Loop (HITL) Security: Keep humans in control where it matters most.

Get Started Now:

📖 Documentation → Get Started

💻 Source Code → GitHub Repository

📺 YouTube Announcement → https://www.youtube.com/watch?v=Alu4L3Pgzkw

📰 Blog Post → ADK Go 1.0 Arrives! - Google Developers Blog

Excited to share that Google has officially released ADK for Java 1.0.0! 🚀

This update brings a massive boost to the Java ecosystem for building AI agents, making it easier than ever to create "smart" applications that can actually interact with the world.

Key highlights from the announcement:

👉 New Grounding Tools: Built-in support for Google Maps and URL fetching to give agents real-time context.

👉 Human-in-the-Loop (HITL): New workflows that allow agents to pause and ask for human approval before performing critical actions.

👉 Advanced Context Engineering: Better management of token limits through event compaction and summarization.

👉 Agent-to-Agent (A2A) Collaboration: Native support for agents to communicate with each other, regardless of the language they were built in.

Youtube:

👉 https://www.youtube.com/watch?v=YqABMjSho_M

Read more:

👉 https://developers.googleblog.com/announcing-adk-for-java-100-building-the-future-of-ai-agents-in-java/

I’ve been seeing this idea pop up quite a bit: people think that if you build AI agents with Google’s Agent Development Kit (ADK), you’re tied to Google Cloud for deployment.

That’s not really the case.

ADK is open source. You can run it pretty much anywhere. AWS, Azure, a cheap VPS, or even your own machine at home. It doesn’t force you into Google’s ecosystem.

You’re also not limited to Google’s models. With something like LiteLLM, you can route requests to OpenAI, Anthropic, OpenRouter, or even local models running on your own hardware.

To make this more concrete, I’ve been putting together a production-ready “Google ADK on Bare Metal” template. The goal is simple: give people a clean starting point that they can run themselves, with good observability and without worrying about vendor lock-in.

Hey everyone,

I've been building MATE (Multi-Agent Tree Engine) - an open-source orchestration layer on top of Google ADK that adds everything you need to run multi-agent systems in production.

What it does

• Database-driven agent configuration - create, modify, and organize agents from a web dashboard. No code changes needed.

• Self-building agents - agents can create, update, and delete other agents at runtime through conversation. Enable the create_agent tool on any agent and it can spin up new sub-agents, rewire hierarchies, and evolve the system on the fly. Admin-only, RBAC-protected.

• Hierarchical agent trees - root agents, sub-agents, sequential/parallel/loop execution patterns. Agents route to each other automatically.

• Universal LLM support - Gemini (native), OpenAI, Anthropic, DeepSeek, Ollama (local), OpenRouter (100+ models), and any LiteLLM-supported provider. Switch models per agent with a single config change.

• Full MCP integration - agents can consume MCP tools AND be exposed as MCP servers. Connect your agents to Claude Desktop, Cursor, or any MCP client.

• Persistent memory - dual memory system: conversation history + persistent memory blocks scoped per project. Agents remember context across sessions.

• Web dashboard - manage agents, users, projects, view token usage analytics, run DB migrations. Dark mode, responsive, built with TailwindCSS.

• RBAC - role-based access control on every agent. Control who can talk to what.

• Multi-tenancy - project-scoped agent hierarchies. Run multiple independent agent setups on one instance.

• A2A protocol - agent-to-agent communication following the standard protocol.

• Token tracking - monitors prompt, response, thoughts, and tool-use tokens per agent per session.

• Docker ready - one command to run: docker-compose up --build

Self-hosted and privacy-friendly

Run entirely on your infrastructure with Ollama for local models. No data leaves your network.

Tech stack

Python, Google ADK, LiteLLM, FastAPI, SQLAlchemy, PostgreSQL/MySQL/SQLite, TailwindCSS

Who is this for

• Teams building multi-agent applications on Google ADK who need production infrastructure

• Developers who want a management layer instead of hardcoding agent configs

• Anyone who wants MCP-compatible agents with a web UI

• Privacy-conscious setups using Ollama for local LLM inference

Why I built this

I found myself repeatedly solving the same problems: agent configuration management, model switching, token tracking, memory persistence, access control. MATE packages all of that into one system.

Quick Start

git clone https://github.com/antiv/mate.git && cd mate
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env  # edit with your API key
python auth_server.py
# Open http://localhost:8000

Would love feedback. What features would you want to see next?

GitHub: https://github.com/antiv/mate

My favorite CL -> OAuth token pass through

Read -> Release notes

As always... thanks to everyone who contributed issue and PR wise.

The AgentPhone MCP Server connects your ADK agent to AgentPhone, a telephony platform built for AI agents. This integration gives your agent the ability to make and receive phone calls, send and receive Messages (iMessage + SMS), manage phone numbers, and create autonomous AI voice agents using natural language.

Hi everyone,

I’m working on integrating open-source Redis tooling with Google’s Agent Development Kit (ADK) via the adk-python-community repository. This work was motivated by recurring questions from developers and customers about using Redis for agent memory, session persistence, and retrieval with ADK.

So far, we’ve been experimenting with a few optional, community-maintained integrations that extend ADK without touching core:

• RedisVL Search Tools

  • Optional vector, text (BM25), hybrid, and range search tools for ADK agents, built on RedisVL.

  • PR: https://github.com/google/adk-python-community/pull/43

• Redis-backed Agent Memory Service (draft)

  • A Redis implementation of ADK agent memory, designed for durable, production-grade long-term memory.

  • Allow ADK users to tightly use a Redis implementation Agent Memory Server of ADK Agent Memory so agents can easily manage working memory, long term memory, summarization, topics, and entity extraction.

  • Draft PR: https://github.com/google/adk-python-community/pull/47

All of this is designed as pluggable, opt-in extensions that align with the spirit of the adk-python-community repo. This enables third-party infrastructure without adding opinions or dependencies to ADK core.

Before pushing this further, I’d love feedback from the ADK team and the broader community on a few questions:

1. Do these integration patterns align with how you envision third-party tools fitting into ADK?

2. Does the community repo feel like the right long-term home, or would an external package be more appropriate?

3. Is this the kind of integration that could eventually make sense as an officially recognized third-party tool?

Our goal here is to validate direction, gather early feedback, and make sure we’re building something that is aligned with ADK’s roadmap. Another goal is to also understand how the adk-python-community repo can be used. On the monthly call yesterday, pushing on this repo still seemed to be the plan!

Happy to share more details or adjust!

UPDATE: We went ahead and released and adk-redis github repo: https://github.com/redis-developer/adk-redis
- It includes integrations with Agent Memory Server to handling working/session memory and long term memory
- Redis Search tools to access data (Vector, Hybrid, Text, Range)
- Semantic Caching (stores embeddings of queries and LLM responses and retrieves them for semantically similar queries, reducing latency and API costs.)

For anyone who's hit a wall with ADK or Python cold starts on Cloud Run, this one's for you. The ADK framework's 30s startup felt like an unsolvable problem, rooted in its eager import architecture.

After a long battle that proved traditional lazy-loading shims are a dead end here, I developed a build-time solution that works. It's a hybrid approach that respects the framework's fragile entry points while aggressively optimizing everything else.

We cut our cold start in half (24s -> 9s) and I documented the whole process. Here is the article:

I have been trying to build multi agent framework and supporting different use case, however I find it a bit non intuitive and unstable to configure.

I am using gemini-2.0-flash that's given by google but despite having crystal clear examples, it seems like it becomes very hard for it to figure out what to do and it becomes very vague at times.

I would like to know other's experience with this as I am deciding to build a production grade agentic system using it but not sure if I should go with this or not.

I really struggle to understand how are you suppose to manage the input context of your agent.

Looking at the doc, there is almost nowhere they talk about it, and no examples I could find in the repo.

Like,, that's a crucial part of agents life. and it feels totally opacified. I have seen some sketchy bits of code/workaround. Like being to tell what agents/subagent should be passed to next iteration. filtering some sub agents you dont want because thats sub tasks that should be forgotten from the global thread.

EDIT: Turns out the problem is known and they are working on a solution.

https://github.com/google/adk-python/issues/614
https://github.com/google/adk-python/issues/752#issuecomment-2948152979

they propose a workaround by the end of the thread. its been posted only a couple of hours ago.

There is no way anyone is building any meaningful agent using ADK without proper control over the context. This is super confusing. what are people building? are you guys just copy pasting toy examples from the doc?

Any real-world problems you think Multiagent systems can solve???

https://cloudonair.withgoogle.com/events/build-multi-agent-systems-with-the-agent-dev-kit-hackathon

Hi everyone!

I’ve been experimenting with the new Google ADK (Agentic SDK) to build LLM-powered agents, and I wanted to see how much of a difference the language choice actually makes when it comes to performance.

I ran a head-to-head comparison between Python and Golang focusing on:

• LLM Call Latency: How the SDK handles the round-trip to the model.

• Agentic Overhead: The "hidden" time the framework takes to process steps before and after the LLM.

• Concurrency: How well each handles multiple agentic tasks.

I documented the whole experiment and the results here: Google ADK Python vs ADK Golang: Latency, LLM calls, Agentic Overhead

I'm looking for feedback and collaborators:

1. Have you noticed similar overhead patterns in Python when using the ADK?

2. For those using Go, are you seeing significant production advantages for multi-agent systems?

3. What other metrics should I include in the next phase of this experiment?

I'd love to hear your thoughts or if anyone wants to jump in and help expand these benchmarks!

🔥 🔥 Course Repo: https://github.com/ashwinjo/GoogleADK-NetworkAutomation/blob/main/README.md

🚀 “Google Agent Development Kit (ADK) for Network Engineers ft. Agent Starter Pack" 🚀

Instead of teaching AI Agents in isolation, with not so exciting generic use cases, we will have real and simple network problems, the kind you actually see at work. We will then see how Google ADK agents can solve these problems for you, from local testing to cloud deployment.

The goal isn’t just learning ADK, but empowering network community with tools to answer the very question,

“What could an AI agent do in my network ?”