ADK Workflow Agents for the Professional Agentic Architect Exam

GCP Study Hub
November 16, 2026

ADK workflow agents control how sub-agents run using fixed control flow that does not depend on what a request says. On the Professional Agentic Architect exam, choosing the right multi-agent structure depends on whether execution follows a fixed pattern or changes based on user input. SequentialAgent, ParallelAgent, and LoopAgent handle predetermined execution patterns, while an LlmAgent coordinator or an ADK 2.0 graph-based Workflow handles input-dependent routing.

The three fixed workflow agents in ADK

Each workflow agent enforces a fixed execution structure over its sub-agents without reading the request to decide which branch should run.

  • SequentialAgent runs each sub-agent once, in one fixed order.
  • ParallelAgent runs its sub-agents at the same time. It fits independent work rather than dependent steps, and it has no built-in way to pick the best of several answers.
  • LoopAgent runs its sub-agents repeatedly in sequence until it reaches max_iterations or a sub-agent escalates to stop early.

When the right execution path depends on what the user wrote, none of these fixed workflow agents is the right tool.

Composing ParallelAgent and SequentialAgent

Workflow agents can be nested, and a common composition pairs these two. A ParallelAgent runs its sub-agents at the same time, so its total time is roughly that of its slowest branch rather than the sum of all branches. That benefit only applies to work that is truly independent. ParallelAgent is unsuitable whenever a later step depends on an earlier step's output, because the dependent branch would run before its input exists.

Parallel branches pass their results forward through session state. Each branch writes its result to state through its output_key. Placing the ParallelAgent inside an outer SequentialAgent, ahead of an agent that combines the results, ensures that every branch finishes first and that the combining agent runs afterward with access to everything the branches saved.

Execution order comes from the workflow agent, not from where a sub-agent runs. Moving a sub-agent behind A2A adds network overhead without changing whether it runs in sequence or alongside other sub-agents.

Iterative refinement with LoopAgent

The ADK documentation describes an iterative refinement pattern built on LoopAgent. One sub-agent produces output, another evaluates it, and on the next pass the producer revises its work using that feedback. The pattern depends on repetition: a LoopAgent returns to its first sub-agent after its last one finishes, which gives the evaluation a path back to the producer.

Two mechanisms control when the loop ends. max_iterations bounds the total number of passes, so execution stops automatically once that cap is reached. A sub-agent can also end the loop early by setting tool_context.actions.escalate to true, which is how an evaluating sub-agent signals that the output meets its standard.

That repetition is what sets LoopAgent apart from the other workflow agents. A structure that runs each sub-agent only once gives an evaluation nowhere to go, so output that falls short is never revised.

Routing based on input with LlmAgent and ADK 2.0 workflows

Fixed workflow agents run the sub-agents they contain according to their structure, whatever the request says. When the right branch depends on what the user wrote, that structure works against the design, because a fixed workflow agent has no step that reads the request and picks one branch. Input-dependent routing needs something that makes that decision for each request.

ADK provides two input-dependent routing patterns depending on whether the model or deterministic code should control the branch.

  • LlmAgent coordinator (coordinator and dispatcher pattern): An LlmAgent acts as the coordinator, the specialist agents are registered as its sub_agents, and the model hands each request off with transfer_to_agent. Because the coordinator is model-driven, it can interpret varied phrasing, and only the specialist it selects does the work and produces the final response.
  • Graph-based Workflow in ADK 2.0: When routing must be defined in code instead of in a prompt, a graph-based Workflow models each step as a node. A node can be an agent, a tool, or plain code such as a Python function that runs with no model call. A router node returns an Event with a route value, and an edge maps each route value to the node that handles it. ADK follows the graph, switching between AI-powered agents and deterministic code as needed.

The difference between the two patterns is who makes the decision. With a coordinator, and with any step exposed only as a tool, the model decides whether and where to go next, however the prompt is worded. In a Workflow, routes are edges and deterministic steps are plain Python nodes, so a step that must always run is enforced in code and needs no model call.

Choosing the right ADK control flow

When reviewing an ADK architecture, we would first determine whether control flow is fixed or input-dependent. Fixed execution maps to SequentialAgent for ordered single passes, ParallelAgent paired with output_key and an outer SequentialAgent for concurrent work followed by a combiner, and LoopAgent with max_iterations and escalation for iterative refinement. Input-dependent routing maps to an LlmAgent coordinator using transfer_to_agent when the model should interpret varied user phrasing, or an ADK 2.0 graph-based Workflow when edges and plain code nodes must enforce routing deterministically.

Our Professional Agentic Architect practice exams test ADK workflow agents alongside LlmAgent delegation and ADK 2.0 graph-based workflows, with detailed explanations that drill these distinctions.

Get tips and updates from GCP Study Hub

arrow