
The Agent Development Kit (ADK) is Google's open-source framework for building agents. It is used mostly in Python, and it also supports other languages such as TypeScript. Its primary building block is LlmAgent, which combines a model, an instruction, and a list of tools. On the Professional Agentic Architect exam, ADK appears across tool schema design, execution limits, workflow orchestration, latency tracing, and runtime deployment on Google Cloud.
Alongside LlmAgent, ADK provides several capabilities for composing and operating agents:
When you attach a function to an LlmAgent, ADK builds the tool's schema from the function's name, docstring, type hints, and default values, with the docstring becoming the tool's description. Descriptive function names and typed parameters tell the model when to call the tool and what value to pass, while a docstring explaining the tool and each argument removes ambiguity.
Because the schema comes straight from the function definition, the definition is the place to make a tool clear. Guidance in the agent's instruction can add context, but the model still receives whatever schema the function produces. ADK can also wrap a whole agent with AgentTool so that another agent can call it as a tool, which is a different job from exposing a plain function.
ADK recommends returning a dict from tools, and it wraps any other return type in a result field. Because the model, not code, has to understand the output, ADK recommends making return values as descriptive as possible, including a status key (such as success or error) and a human-readable error_message when an operation fails.
A tool result is the model's only view of what a call did. An empty dictionary gives the model no signal about what happened, so it has nothing to base its next step on. ADK's RunConfig sets limits on each run, including max_llm_calls, which defaults to 500. That limit caps how long a run can continue, and it acts as a guardrail rather than a way to give the model better information about each tool call.
ADK provides workflow agents for predictable execution patterns and, since ADK 2.0, graph-based workflows for processes that need precise routing control.
SequentialAgent runs its sub-agents once each, in one fixed order.ParallelAgent runs its sub-agents at the same time, which suits independent work.LoopAgent runs its sub-agents repeatedly until it reaches max_iterations or a sub-agent escalates, so it is meant for deliberate repetition.All three have control flow that does not depend on what a request says. A graph-based Workflow adds routing that is defined in code. Each step becomes a node, and a node can be an agent, a tool, or plain code, allowing deterministic logic to run as a Python function with no model call. A router node returns an Event with a route value, and edges map each route value to the node that handles it. ADK follows the graph, switching between AI-powered agents and deterministic code as needed. This is the difference between code-driven and prompt-driven routing: a node runs whenever the graph reaches it, while a step exposed only as a tool runs when the model decides to call it.
ADK is already instrumented with OpenTelemetry and emits spans such as invoke_agent, execute_tool for each tool call, and generate_content for each model call. Exporting these spans to Cloud Trace, for example with get_gcp_exporters(enable_cloud_tracing=True), shows a waterfall of where each request's time went, with each tool call and model call appearing as its own span. Because the instrumentation uses OpenTelemetry, traces stay portable if a team later exports them to another backend.
Each observability signal answers a different question. A trace breaks a single request into its steps, so it is the signal that shows where time went inside that request. Request-level metrics in Cloud Monitoring describe whole requests rather than the steps within them, logs cover only the steps that write entries, and the Gen AI evaluation service measures response quality rather than latency.
ADK agents can run on several Google Cloud platforms, and each one trades managed convenience for flexibility in a different way:
A useful habit is to start from the most managed option that fits and move to a lower-level platform only when a specific technical constraint calls for it, since each step down adds platform work for the team.
Our Professional Agentic Architect practice exams test Agent Development Kit (ADK) architecture alongside workflow orchestration and Cloud Run deployment choices, with detailed explanations that drill these distinctions.