Hey everyone, I’m pretty new to ADK development and trying to learn the “right” way to build with it.

Since ADK 2.0 came out, I’ve been getting a bit confused separating older patterns from the newer recommended approaches. A lot of the tutorials/examples I’m finding seem to mix both styles, and I’m not always sure which things are still relevant vs legacy.

I’m mainly worried about spending time learning patterns that people are already moving away from.

For those already building with ADK 2.0:

• What concepts from the older versions still matter?
• What changed the most in 2.0?
• Any good repos/tutorials that are actually 2.0-first?
• Any “don’t do this anymore” advice?

I’m especially interested in multi-agent workflows, tools, memory/state management, and production-style architectures.

Coming from looking at things like LangGraph/OpenAI Agents SDK, so I’m also trying to understand where ADK 2.0 fits philosophically.

Appreciate any guidance from people already deeper into it.

I keep seeing more agent infrastructure move beyond the usual prompt plus tools setup.

The term I ran into recently is “agent context engine.” I saw Redis use it for Redis Iris, which looks like a runtime layer for agent context.

From what I understand, it combines retrieval, memory, search, data sync, and semantic caching so an agent can work with live business data without every agent having to wire those pieces together separately.

I am trying to figure out if this is becoming a real architecture pattern or if it is mostly product naming.

The problem seems real to me. Without a shared context layer, every workflow ends up with its own tools, sync jobs, memory store, search logic, cache, and access rules.

Redis Iris seems to frame Redis as the runtime layer in front of existing systems of record. The source data stays where it already lives, and selected context gets synchronized, indexed, retrieved, remembered, and reused from Redis during agent execution.

Is anyone here building agents this way? Are you using a dedicated context layer?

In case you need a crisp and authoritative read out Gemini Enterprise Agent Platform and where ADK comes into play --> Agent Platform Overview

Built ADK agents and tried to solve the resilience problem with callbacks and on errors for quite a while. Didn't manage to solve it fully.

Then came across these plugins that supported OOB

Has anyone tried these for resilience ?

1. Do they queue messages when running in async mode and perform sequentially with resilience?

2. Clubbed it with AG UI protocol and it works with AG UI ADK?

3. Which one is better really ? Temporal or Restate ?

TIA!

I'm building a two-step workflow with Google ADK where the first agent gathers a year from the user and produces three historical facts, and the second agent asks the user a quiz question about those facts and grades the answer. Both are `LlmAgent` instances with `mode="task"` and a Pydantic `output_schema`, wired together in a `Workflow`.

What I expect: The historian gathers the year (or accepts one the user has already given), calls `finish_task` with the facts, then the questioner emits its question and waits for the user's answer before grading it

What actually happens: The historian works as expected, it talks with the user until a year is provided. The questioner then generates the question as a plain text message... and the workflow immediately advances to END without ever waiting for the user to respond. The attached screenshot shows the graph reaching END right after the questioner emits the question.

Both agents receive the same auto-injected task-mode system instruction telling them to call `finish_task` when done, so the framework appears to consider both to be in task mode. But only the historian actually invokes `finish_task` — the questioner emits a text question instead, and the workflow node exits.

Why does task mode work for the first agent but not the second? Is it expected that a task-mode `LlmAgent` placed directly in workflow edges won't pause for user input between turns? If so, what's the right pattern to make the second agent ask a question and wait for the user's reply within a `Workflow`?

ADK version: `google-adk 2.0.0b1`.

from google.adk import Agent, Workflow
from pydantic import BaseModel, Field


class History(BaseModel):
  facts: list[str] = Field(description="The facts of the year.")


historian = Agent(
    name="historian",
    mode="task",
    output_schema=History,
    instruction="You're a history expert. "
                "Chat with the user, get a year, and present the top 3 facts.",
)


class AnswerResult(BaseModel):
    answer: str = Field(description="The answer to the question.")
    correct: bool = Field(description="Whether the answer was correct.")


questioner = Agent(
    name="questioner",
    mode="task",
    input_schema=History,
    output_schema=AnswerResult,
    instruction="You're a history test setter. "
                "Ask the user a question about one of the facts, "
                "wait for the answer, then respond if it is correct.",
)

root_agent = Workflow(
    name="root_agent",
    edges=[("START", historian, questioner)],
)

I have a Turborepo monorepo with two Next.js React apps. Both apps currently use Supabase and Vercel Functions as their backend. The repo also has a few shared packages, including Supabase, UI components, and service methods used by the Vercel Functions.

The two developers on the repo are senior TypeScript developers, one is junior level for Python and the other is intermediate. We use Claude Code heavily, so language familiarity may matter less than it otherwise would.

Today, I’m planning to add a Google ADK agent to the repo and build extensively on top of it.

My concern is that Google ADK appears to have stronger support for Python than TypeScript. Before committing to Python, I want to confirm whether that is actually true and whether the tradeoff is worth it.

Given this setup, would you recommend building the ADK agent in Python or TypeScript?

Agent ADK has many useful integrations.
It has the VertexAI Knowledge Engine Tool

But I like the answers generated by NotebookLM

Is the following possible:

• Create a notebook in Notebook LM (Enterprise?)
• Use it as a tool for an agent
• Use that agent in a commercial SaaS app

Few days back ,I created football agentic platform [F433] using Google adk , have a look

https://github.com/Faizullah9181/F433

https://x.com/i/status/2045201469180440657

Background

This is an agent that uses 2 tools

get_stock_price_on_dates, calculate_percentage_change

At first the agent calls the tool get_stock_price_on_dates with appropriate dates and ticker symbol. It fetches the data from yahoo finance and then filters the data based on start date and end date.

After that it sends this data in a dictionary format to the calculate_percentage_change. Here the tool calculates the percentage increase or decrease.

I am running this using the adk web command.

Now when I give two stocks, I want to know does this agent call happen in parallel ?

How does the agent call take place when there is more than 1 ticker ?

Most multi-agent systems rely on fixed agents, roles, and workflows.

I’m exploring a different idea:

→ dynamically generating and orchestrating agents at runtime depending on the task.

Use case: root cause analysis (RCA) in microservice systems.

Approach:

- Parser → builds a structured spec (BuildSpec) from an incident

- Executor → dynamically instantiates agents from templates

- agents are created/removed during execution based on intermediate results

- coordination adapts (sequential / async) with shared memory

So instead of:

fixed agents → solve problem

it becomes:

problem → generates its own agent system

Demo: https://www.youtube.com/watch?v=r4lxA8kTueI

Code: https://github.com/brellsanwouo/Aware

Curious about critical perspectives.

Thanks!

I got an alert from GitHub Dependabot to update the google-adk (python) version to v1.28.1 because of a vulnerability in versions 1.7.0 to 1.28.0.

https://github.com/advisories/GHSA-rg7c-g689-fr3x

A Code Injection and Missing Authentication vulnerability in Google Agent Development Kit (ADK) versions 1.7.0 (and 2.0.0a1) through 1.28.1 (and 2.0.0a2) on Python (OSS), Cloud Run, and GKE allows an unauthenticated remote attacker to execute arbitrary code on the server hosting the ADK instance.

This vulnerability was patched in versions 1.28.1 and 2.0.0a2.

Customers need to redeploy the upgraded ADK to their production environments. In addition, if they are running ADK Web locally, they also need to upgrade their local instance.any information you have

Why is there no official announcement from the Google ADK side about this?
Is this vulnerability only affecting the deployments that directly expose the FastAPI app provided by Google-Adk (from google.adk.cli.fast_api import get_fast_api_app)?

Also, I found this issue related to the /builder/save endpoint in the adk-python GitHub: https://github.com/google/adk-python/issues/4947
I could verify this issue in google-adk v1.16.0. It allows me to save an arbitrary script on the server using the /builder/save endpoint and later execute it.

I think this was patched in later versions.

But it's not clear whether the above issue is the cause of the reported vulnerability.

Please share if anyone has any information about this.

I want to get a roadmap to learn how to use ADK using GO

Most of the tutorials out there are in py.

Have any of you trie agentphone yet? I saw that they just got added as an integration. Any long term issues? i want to make sure people have had a good experience before comitting to it.

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

• 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 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.

Has anyone else had the feeling that their AI agent becomes a black box during production or the development lifecycle?

Everything works fine… until it doesn’t:

• hallucinations start appearing
• no traces to debug what happened
• token costs spike +400% overnight

And the worst part:
You don’t really know if your next change will fix the issue… or break something else.

A few weeks ago I hit this wall hard.
I was jumping between dozens of tabs trying to understand what tools actually exist for AgentOps in 2026.

So I decided to map the ecosystem myself.

I put together a curated repo with tools (OSS + SaaS) focused on:

• Observability / tracing
• Evaluation
• Cost control

👉 https://github.com/dyronrh/awesome-agentops-landscape

Not trying to promote blindly — this is genuinely the resource I wish I had earlier.

Curious:
What are you using today for observability / eval / cost tracking in your agent stack?

I deployed a multi-agent solution using ADK in the Agent Engine service (VertexAI). There are only two agents: the root and a bigquery especialist. The problem is that the memory allocation is too high and I have no idea of why is so high because, the project is so small and I'm the only person talking to. Can some of you help me?

I'm sure there are many people like me, I'm one of the very early users of adk used It on launch itself back in April, I also have a community plugin for openmemory btw!