Reading an Agent Trace on the Professional Agentic Architect Exam

GCP Study Hub
November 19, 2026

In ADK traces viewed in Cloud Trace, generate_content spans represent model calls and execute_tool spans represent tool calls. Reading the overall shape of those spans shows where time is actually spent during an agent run. On the Professional Agentic Architect exam, observability scenarios test whether you can match a specific trace pattern to the right fix instead of tuning a layer that is not causing the slowdown or failure.

One long span points to a slow step

The first thing to read in a trace is which span holds the time. Each span measures one step, so when one span runs far longer than the others, the delay belongs to that step rather than to the request as a whole. An execute_tool span covers the entire tool call, including whatever the tool calls in turn, so a long execute_tool span usually traces back to the tool's backend, such as a slow database query or an external API. Investigating and optimizing that query or API call is what shortens the request.

The general rule is to fix the layer that owns the time. Model choices change generate_content spans, and startup delays appear before the first span rather than inside one, so neither a different model nor different instance settings shortens a tool call once it is running.

Delay before the first span indicates a cold start

Time that passes before the first agent span begins is not spent in the agent's code, a model call, or a tool call. When that gap appears only on requests that follow a period without traffic, it is the signature of a cold start. Google documents cold requests on Agent Runtime at several seconds, compared with well under a second for warm requests.

Setting the minimum instance count (min_instances) for the Agent Runtime deployment above zero keeps at least one instance ready, so the first request after a quiet period no longer waits for startup. Startup is a property of the deployment's capacity rather than of the agent's logic, which is why it is separate from everything the agent does once it runs, from model calls and tool calls to loading context from Memory Bank.

Time spent between two services shows transit or serialization

Elapsed time between spans across two services points to network transit or serialization rather than to work inside either agent. In multi-agent architectures where one agent on Agent Runtime calls another over A2A, the distance between the two runtimes is part of every call, and a cross-region hop can account for most of a call's duration.

Placing both Agent Runtime deployments in the same region shortens that network path without changing how the agents communicate. The called agent keeps its own deployment and its A2A interface, so any other clients that use it continue to work. Running the called agent as a local sub-agent removes the network hop entirely, but a sub-agent runs in the same process as its parent, so that option only fits an agent that nothing else depends on.

Repeated identical tool spans reveal a retry loop

A trace containing many execute_tool spans for the same tool with the same arguments indicates a loop. The model is repeating a call because nothing in the result told it what happened. An empty result with no status is the usual cause, because the model cannot tell an empty answer from a failure and tries again.

ADK recommends making tool return values as descriptive as possible, with a status key such as success or error and a human-readable error_message, including an explicit status for outcomes such as a record that was not found. Because the model, rather than application code, has to understand the tool result, the information it needs has to be in the result itself. An explicit status and readable message let the model recognize the failure and respond, for example by asking the user for corrected input.

ADK also caps each run through max_llm_calls, which defaults to 500. That cap is a safety limit that ends a runaway run rather than a fix for one, so the cause of a loop is addressed in what the tool returns.

Matching trace patterns on the exam

When a Professional Agentic Architect scenario describes slow or runaway agent requests, we would read where the delay or repetition appears in the trace before choosing a fix:

  • One long execute_tool span with fast model calls points to a slow backend query or external API behind that tool.
  • Delay before the first agent span after idle periods points to an Agent Runtime cold start, which is addressed by setting min_instances above zero.
  • Time spent between two services in different regions points to network transit, which is addressed by placing both Agent Runtime deployments in the same region while preserving independent A2A services where needed.
  • Many identical execute_tool spans with the same arguments point to a retry loop, which is addressed by returning a descriptive status and human-readable error_message from the tool.

Our Professional Agentic Architect practice exams test reading agent traces alongside Agent Runtime scaling and ADK tool design, with detailed explanations that drill these distinctions.

Get tips and updates from GCP Study Hub

arrow