Google's ADK 2.0 Gives Agents Deterministic Execution Graphs

ADK 2.0's core insight is that letting an LLM orchestrate every step of a business process wastes tokens and invites hallucinations—so Google added a deterministic graph engine that separates routing from reasoning.

If you run an autonomous agent on the same refund workflow 100 times, you get the right outcome maybe 95 times. The other five, the LLM skips a step because the context window got crowded or it decides a failed API call is irrelevant. That variance is unacceptable for production enterprise flows.

The Problem: LLMs as Orchestrators Are Slow and Unreliable

A common pattern in agent frameworks is dumping a 5-step instruction into the system prompt and letting the LLM pick tools one at a time. Each step forces the model to re-read the entire context, parse tool outputs, and decide the next action. That’s expensive, high-latency, and brittle. Google’s own engineers noted that business processes like A→B must always execute as A→B—there’s no room for an LLM to infer the sequence.

ADK v1 allowed basic parallel and serial sequences but limited control. You either wrote custom tools or offloaded to Cloud Workflows. For ADK 2.0, the team built a first-class workflow runtime directly into the SDK, available for Python since March and now live for Go.

ADK 2.0's Workflow Engine in Action

The refund-processing example drives the point home. Instead of a single agent with five tools and a prompt, you define a directed graph with five nodes:

• Node A: Fetch purchase history via fast API (tool, no LLM)
• Node B: Analyze customer email against policy exceptions (LLM agent, only here for ambiguity)
• Node C: Issue refund via Stripe API (tool)
• Node D: Draft confirmation email (LLM agent)
• Node E: Update CRM ticket (tool)

The graph engine executes A→B→C→D→E deterministically, invoking the LLM only where reasoning is required. Execution routing is handled by code, not model inference. That means zero token cost for step orchestration, no hallucinated steps, and clean error handling when a node fails.

Google’s blog includes the code: from google.adk import Workflow and a node-based definition that mixes Agent and Tool nodes in the same graph. The graph is compiled into a static DAG at construction time, so the runtime knows exactly what comes next.

Blending Agents and Graphs for Real-World Refunds

The key design decision is “spectrum of control.” You don’t have to choose between a fully autonomous agent and a rigid workflow. ADK 2.0 lets you compose deterministic steps (tool calls, human-in-the-loop) with open-ended LLM nodes. The framework provides clean signal separation: fast, cheap, predictable code for what’s known; expensive reasoning only for what’s ambiguous.

For anyone building customer service bots, document processors, or internal tooling that touches enterprise APIs, this pattern is immediately practical. You keep the flexibility of agents where it matters—parsing unstructured email, drafting replies—and lock down the rest with deterministic nodes.

What comes next is obvious: expect workflow templates for common enterprise patterns (order fulfillment, refunds, compliance checks) shipping as reusable graphs in ADK 2.0’s package registry by Q4.

Source: Why we built ADK 2.0
Domain: developers.googleblog.com