Google Releases ADK Go 2.0 with Graph-Based Workflow Engine
Google's Agent Development Kit for Go 2.0 introduces a graph-based workflow engine, unified node runtime, and built-in human-in-the-loop orchestration.
Visual representation of graph-based node routing in multi-agent workflows.
- ADK Go 2.0 transitions multi-agent orchestration to a graph-based workflow engine.
- Human-in-the-loop (HITL) support is now a built-in primitive with durable state resumption.
- The update unifies the execution runtime, merging ToolContext and CallbackContext into a single agent.Context.
- LLMs can act as programmatic routers to steer control flow across dynamic node graphs.
On June 30, 2026, Google announced the release of the Agent Development Kit (ADK) for Go 2.0. The update focuses on providing a structured approach to building multi-agent applications, moving away from ad-hoc control flows to a formal graph-based workflow engine. The release addresses the complexities of production agent systems, such as classification, branching, human approvals, and retry loops, by expressing them as interconnected nodes and edges.
Graph-Based Architecture
The core structural change in ADK 2.0 is the introduction of a graph-first execution model, aligning the Go framework with recent updates to the Python ADK. Applications are defined as a series of nodes connected by conditional edges. Execution is managed by a scheduler that handles concurrency, state persistence, and pauses.
The framework provides multiple typed node constructors to handle different units of work:
- Function nodes: Wrap typed Go functions, utilizing generics to infer input and output schemas.
- Emitting function nodes: Function nodes equipped with an emit callback for streaming events or pausing execution without requiring a dynamic node.
- Agent nodes: Allow developers to embed entire agents, such as an
LlmAgent, directly into the graph. - Tool and Join nodes: Tool nodes integrate
tool.Toolinstances into steps, while Join nodes act as fan-in barriers that wait for multiple predecessors to complete before proceeding. - State-bound nodes: Extract selected session-state values directly into typed structs using
state:"<key>"tags, automating state plumbing.
Edges govern the flow between these nodes. Nodes emit routing values, and the engine triggers matching edges. Standard routes include StringRoute, IntRoute, BoolRoute, and MultiRoute. This edge-based routing natively supports sequential chains, conditional branching, fan-out/fan-in patterns, nested sub-graphs, and loops.
LLM Steering and Dynamic Orchestration
ADK 2.0 facilitates using large language models as the primary decision engine for workflow routing. An LLM agent can classify a user's input, and a connecting function can emit a corresponding route. The graph then dispatches the execution to the appropriate handler node.
For scenarios where execution order is determined at runtime, the framework provides dynamic nodes. These nodes allow orchestration logic to be written in standard Go code by calling RunNode(...) for each child component. Options like WithRunID, WithUseSubBranch, and WithIsolationScope allow developers to control child identity, isolate history, and delegate outputs.
Built-In Human-in-the-Loop (HITL)
Human-in-the-loop workflows are supported natively in ADK 2.0. Any node can halt workflow execution to request human input via workflow.NewRequestInputEvent. The state is durably persisted in the session. Once the required input is supplied, the workflow resumes using one of two methods:
- Handoff: The user's answer is passed directly to the subsequent node.
- Re-entry: The paused node re-runs with the user's response injected via
ctx.ResumedInput(...).
Because the state is saved within the session history, workflows can be reconstructed and resumed even after process restarts. The interrupt format is shared with Python ADK, providing interoperability.
Resilience and Agent Modes
Workflow resilience is managed through configurable node settings. Developers can assign a retry policy to any node using workflow.DefaultRetryConfig(), which includes parameters for exponential backoff and jitter. Global graph settings permit concurrency capping via WithMaxConcurrency(n) and provide isolated memory scopes for parallel branches to prevent prompt history contamination.
ADK 2.0 introduces three distinct execution modes for LLM agents: Chat, Task, and SingleTurn. Depending on the assigned mode, specific helper tools (such as finish_task or single_turn) are automatically provisioned. A unified runner drives plain agents and full workflow graphs through the exact same execution model.
Migration Path
The transition from 1.0 to 2.0 includes several breaking changes centered around API unification. The legacy ToolContext and CallbackContext interfaces have been consolidated into a single agent.Context. Consequently, custom InvocationContext implementations must now support two new methods: IsolationScope() and ResumedInput(id string). Additionally, event streams contain new fields, and session.NewEvent now requires a standard context.Context as its first parameter.
The framework updates are available via the standard Go toolchain, and Google has provided a detailed migration guide for existing users.
Enjoyed this?
Get more posts like this delivered to your inbox.
