ADK Go 2.0: Graph-based workflows with human-in-the-loop

Key points

• 1

  Graph-based workflow engine: ADK Go 2.0 replaces ad-hoc control flow with a graph of nodes connected by edges, where each node implements the Node interface. This allows complex agent applications to classify, branch, fan out to specialists, gather results, ask for human approval, retry on failure, and loop until completion—all in a single, resilient workflow. For example, a simple sequence workflow chains nodes using workflow.Chain() to create a graph that runs in the same Go runner as single agents. The scheduler handles concurrency, state persistence, and human pauses without requiring external dependencies. This means developers can build production-grade multi-agent applications without writing brittle control flow logic, as the graph structure ensures reliability and observability across process restarts.

• 2

  Human-in-the-loop built-in: Any node in an ADK Go 2.0 workflow can pause and request human approval using workflow.NewRequestInputEvent(), which sends a prompt to the user with validation against a schema. The workflow then waits for a response, which can be passed to the next node (handoff) or re-run with the input (re-entry). Crucially, this human interaction is durable—resumes work even after process restarts or across different runtimes, thanks to session history. For instance, when approving a $200 refund, the workflow pauses, validates the response against a schema, and resumes seamlessly. This eliminates the need for external tools or custom hooks, making human input a first-class feature in the workflow engine.

• 3

  Dynamic orchestration in plain Go: ADK Go 2.0 enables runtime-controlled execution using dynamic nodes written in standard Go. These nodes use workflow.RunNode() to orchestrate child nodes with Go code, supporting loops, conditionals, and parallel processing. For example, a dynamic node can iterate over a list of users and send personalized greetings, handling retries and state isolation without additional boilerplate. This approach gives developers the flexibility to write orchestration logic in familiar Go syntax while maintaining the same reliability as static graphs—critical for scenarios where execution order depends on runtime data, such as user input or model responses.

• 4

  Unified node runtime: All nodes—whether single agents or full workflows—run under a single execution model, eliminating the need for separate runtimes. This includes LLM agents in Chat, Task, and SingleTurn modes, which share the same node runtime. For example, a workflow node can use an LLM agent to route user queries, and the human-in-the-loop feature works seamlessly with both static and dynamic nodes. This unification simplifies debugging, monitoring, and scaling, as telemetry spans and event streams are consistent across all node types, providing end-to-end visibility into agent behavior.

What changed