Final Response vs. Trajectory Evaluation for the Professional Agentic Architect Exam

GCP Study Hub
November 19, 2026

Evaluating an agent requires looking at two separate things because an agent can reach the right answer the wrong way, or call the right tools and still answer badly. Final response evaluation checks whether the answer the agent delivers is right and good. Trajectory evaluation checks which tools the agent chose, which arguments it passed, and the order in which it called them.

This split matters on the Professional Agentic Architect exam because accurate answers often hide process problems. An agent that usually returns the right final answer can still call the wrong tool first, pass unneeded parameters, or run its steps in an inefficient order. Metrics that grade only the final response will not surface those defects, and only a trajectory metric catches them.

Why unit tests and traces do not replace agent evaluation

Standard software testing and observability techniques answer different questions than agent evaluation, and they do not cover either half of the final response and trajectory split on their own.

  • Unit tests on individual tool functions verify how each tool behaves in isolation. Because they call the tool functions directly, they cannot show whether the agent chooses the right tools or supplies the right arguments during execution.
  • Traces and comparisons of trace spans against a baseline measure timing and structure, not correctness. They do not verify whether an agent's final response matches a reference answer.

Local and CI evaluation with ADK evalsets

ADK evaluation lets you check both tool trajectories and final responses locally on a developer machine or inside a CI pipeline, without deploying the agent first. You create an evalset that records the expected tool calls and reference responses, then run adk eval against it. The same tests can also run through pytest with AgentEvaluator.

A test_config.json file sets the evaluation criteria, such as tool_trajectory_avg_score for tool calls and response_match_score for the final response. By contrast, running the Gen AI evaluation service against a staging environment requires deploying the agent. When the goal is local or CI regression testing without a deployment step, we would lean toward ADK evalsets.

Reference trajectory matching in EvalTask

When comparing an agent's tool calls against a reference trajectory using EvalTask in the Gen AI evaluation SDK, several metrics enforce different rules around step order and extra tool calls. Note that EvalTask is the older evaluation interface in the SDK. It remains generally available, though it is no longer under active development.

  • trajectory_in_order_match passes when every call in the reference trajectory appears in the agent's trajectory in the same order, while allowing extra tool calls without causing a failure. This fits cases where required steps must stay in sequence but additional calls are acceptable.
  • The exact match metric requires the same calls in the same order with nothing extra. Any additional tool call causes the check to fail.
  • Trajectory recall measures how many calls from the reference trajectory appear in the agent's trajectory regardless of order. Because it ignores sequence, it will not catch a required step that runs out of order.
  • The any order metric allows extra calls and ignores order, so it also misses cases where one reference call happens before another call that was required to run first.

Choosing among these four metrics comes down to two constraints: whether the relative order of the reference calls must be enforced, and whether extra tool calls beyond the reference list are allowed.

Automated rubric metrics in the Gen AI evaluation service

In the Gen AI evaluation service, automated rubric metrics separate tool usage from answer quality and distinguish single-turn requests from multi-turn conversations.

For single-turn tasks consisting of one question and one response, types.RubricMetric.TOOL_USE_QUALITY grades how the agent uses its tools. It is an adaptive rubric metric that evaluates the selection of appropriate tools, correct parameter usage, and adherence to the expected sequence of operations. Because TOOL_USE_QUALITY does not take the final response as an input and does not grade the final answer, correct answers cannot mask unnecessary parameters, wrong initial tool calls, or inefficient ordering.

When an evaluation covers conversations with many turns rather than single-turn cases, single-turn TOOL_USE_QUALITY is not the right fit. For multi-turn conversations, MULTI_TURN_TOOL_USE_QUALITY applies tool-use grading across the conversation, while MULTI_TURN_TRAJECTORY_QUALITY judges the logic and efficiency of a conversation with many turns.

Several other Gen AI evaluation service rubric metrics focus on the response rather than tool selection, parameter usage, or step sequence:

  • FINAL_RESPONSE_QUALITY judges the agent's overall answer.
  • GENERAL_QUALITY grades overall response quality, which will already look strong when the agent returns accurate answers despite flawed tool calls.
  • INSTRUCTION_FOLLOWING checks how well a response follows the constraints and instructions it was given, rather than how tools were called.
  • HALLUCINATION checks whether claims in the response are supported by the tool results, rather than inspecting unnecessary parameters or an inefficient order of steps.

Matching the metric to the evaluation goal

On the Professional Agentic Architect exam, picking the right evaluation method starts with identifying both where the check runs and what failure mode it needs to catch. Local and CI regression tests without deployment point to ADK evalsets with adk eval or pytest and AgentEvaluator. Reference-based trajectory checks in EvalTask turn on order enforcement and tolerance for extra calls. Automated Gen AI evaluation service checks turn on whether the target is tool use or final response quality, and whether each case is single-turn or multi-turn.

Our Professional Agentic Architect practice exams test final response and trajectory evaluation alongside ADK evalsets and Gen AI evaluation service metrics, with detailed explanations that drill these distinctions.

Get tips and updates from GCP Study Hub

arrow