Agent Development Kit (ADK): Building Agents on Google Cloud

GCP Study Hub
November 16, 2026

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:

  • Workflow agents and, since ADK 2.0, graph-based workflows for composing agents and code
  • Toolsets for connecting to MCP servers and APIs
  • Callbacks for running your own code at points in the agent's loop
  • Session, state, and memory services
  • Built-in OpenTelemetry instrumentation and built-in evaluation

Designing tools and return values for LlmAgent

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.

Orchestrating steps with workflow agents and graph-based workflows

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.

Tracing latency with OpenTelemetry and Cloud Trace

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.

Deploying ADK agents and MCP servers on Google Cloud

ADK agents can run on several Google Cloud platforms, and each one trades managed convenience for flexibility in a different way:

  • Agent Runtime is the managed platform built for Python agents, and it does not support hosting custom MCP servers.
  • Cloud Run is recommended by Google for containerized applications that need serverless, event-driven scaling with language flexibility, supporting TypeScript agents as well as Python agents. Cloud Run can host MCP clients and servers that use the streamable HTTP transport, each running as its own service. It scales instances with traffic and down to zero when traffic drops. Because Cloud Run services are stateless, session and memory data belong in an external service such as Agent Platform Sessions or Firestore.
  • GKE gives fine-grained control for complex, stateful systems, and it needs people who can operate Kubernetes.
  • Managed instance groups leave patching, scaling, and container management to the team.

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.

Get tips and updates from GCP Study Hub

arrow