AI Engineer Summit 2025

Ensure AI Agents Work: Evaluation Frameworks for Scaling Success

Loading slides…

Read the talk

Ensure AI Agents Work: Evaluation Frameworks for Scaling Success

A production agent needs checks for routing, tool arguments, skill execution, and the path to completion; voice adds audio quality and conversation behavior to that list.

From a talk by Aparna Dhinakaran

Before you start: Familiarity with LLM calls and APIs is helpful; the article introduces agent routing, skills, memory, and traces.

What does it mean for a voice travel agent to work?

How do you know an agent works once customers depend on it? Building an agent establishes that it can perform a task; evaluating it in production reveals how it behaves with real requests. That distinction matters both to the engineers troubleshooting the application and to the leaders responsible for putting it into service.

Arize cofounder Aparna introduces voice assistants as an expansion of this problem beyond text chat. In discussing call centers and voice APIs, she cites over one billion calls worldwide, without specifying a measurement period or defining which calls use AI. The concrete example is Priceline Penny, which she describes as allowing hands-free booking of an entire vacation. Priceline’s October 2024 announcement established voice-driven hotel search and recommendations, while describing broader travel services as future expansion; complete voice-only vacation booking is the speaker’s description here. A spoken interaction adds another requirement: evaluate the agent’s decisions and the voice experience through which the customer encounters them. Other modalities likewise need their own checks.

Slide titled “The new Travel Agent” with a Priceline chat screenshot and three callouts describing voice-driven interaction, conversational replies, and real-time responses.Open full source frame
A travel assistant example highlights voice interaction, spoken replies, and real-time responses.
0:441:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:44 · section reference included

Separate routing, execution, and memory

Before defining evaluations, separate the agent into three responsibilities: a router decides what happens next, skills contain the logic that performs the work, and memory preserves state. These responsibilities recur across LangGraph, CrewAI, LlamaIndex Workflows, and applications built without an agent framework. The implementation may differ, but recognizing the responsibilities gives each evaluation a specific target.

Consider an e-commerce assistant. Its router receives the customer’s request and chooses which skill should handle it.

Customer requestIntended skill
Make a returnCustomer service
Find available discountsDiscounts and deals
Recommend leggingsProduct search

A routing decision commits the application to a particular execution path. For the leggings request, the product-search skill then does the work. The illustrated skill connects product search, conversion from unstructured to structured data, a Search API, and product comparison. A skill can therefore contain a mixture of LLM calls, ordinary API calls, and application code.

Components of an Agent slide highlighting skills and execution, with connected product-search, unstructured-to-structured, Search API, and Compare Products blocks and a legend for LLM calls, API calls, and application code.Open full source frame
An agent skill combines product search, data transformation, a search API, and product comparison.

Memory becomes necessary as the interaction continues. A customer should not have to repeat everything they said on the previous turn. The application needs to retain prior requests and conversational state so that later decisions remain connected to the ongoing task. This is a distinct responsibility from choosing a skill or executing its logic.

2:513:01
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:51 · section reference included

Follow a latency question through the trace

A trace exposes the internal execution that engineers inspect when building and troubleshooting an agent. In the open-source tracing demonstration, the user asks, “What trends do you see in my trace latency?” The task is to investigate what is making the application slow. Opening the trace reveals the routing decisions behind that request, including multiple calls to the router within the same task.

The demonstrated sequence is:

  1. The router selects a tool that runs a SQL query to collect the application’s traces.
  2. Execution returns to the router after retrieval.
  3. The router selects a data-analyzer skill and passes the retrieved traces and application data to it for analysis.

Memory retains what happens during execution. The router is therefore more than an initial intent classifier: it can decide repeatedly what the agent needs to do next, using the state accumulated by earlier steps. The trace makes those transitions visible.

5:435:52
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:43 · section reference included

Check the selected skill and its arguments

Every step in that execution is a possible failure location. At the router, the first question is whether the agent selected the right skill. Sending a request for leggings to customer service or to a discounts skill is a routing error, even if that downstream skill operates correctly. Start by identifying the application’s actual control flow: where does it choose among skills, and what should each choice accomplish? Those decision points need their own evaluations.

Correct skill selection is only half of a correct routing decision. The router must also pass the user’s constraints into the selected skill. A product search may be the right action, yet still fail the request if its arguments omit the requested material or use the wrong price range. Evaluate these separately:

  • Skill selection: Did the router choose the operation appropriate to the request?
  • Argument correctness: Did it supply the values needed to carry out that request, including the customer’s constraints?

Separating these checks distinguishes choosing the wrong work from asking the right skill to do the wrong thing.

7:427:57
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:42 · section reference included

Evaluate the work inside a skill

A skill is itself a chain of operations, so its evaluation cannot always be reduced to one result. In the retrieval-augmented generation, or RAG, example, the chain embeds the input query, performs a vector-database lookup, and calls an LLM with the retrieved context. Two separate questions follow: were the retrieved chunks relevant, and was the generated answer correct?

Slide defining a skill as a chain of logic blocks, with three RAG blocks labeled Embed input query, Vector DB lookup, and LLM call with retrieved context.Open full source frame
A RAG skill contains separate embedding, retrieval, and generation steps.
Evaluation targetQuestion
Retrieved chunksIs the retrieved context relevant to the request?
Generated answerIs the answer correct?

A skill can have multiple LLM-as-a-judge evaluations, code-based checks, or both. Attach each check to the component whose behavior it assesses. Keeping retrieval relevance distinct from answer correctness makes the skill’s internal stages visible in the evaluation results, just as the trace makes them visible during execution.

9:309:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

9:30 · section reference included

Measure whether execution converges

The next evaluation target is the path the agent takes to finish. Aparna calls this convergence: the agent should reliably reach completion through a succinct sequence of steps. Her illustration is a skill run hundreds of times that consistently completes in roughly five or six steps; this is a desired pattern, not a measured benchmark. The steps still need to perform the necessary work: interpret the request, supply the right parameters, execute the relevant components, and generate the correct answer.

Execution length can change with the underlying model. Aparna reports seeing substantially different step counts for the same skill implemented with OpenAI versus Anthropic, but gives no model names or measured distributions. The useful comparison is therefore the behavior of a particular skill under repeated execution, rather than a general ranking of providers. Count the steps, examine how much the count varies, and check whether the task actually completes correctly. A short path is useful only when it reaches the intended result. Convergence combines that concern for reliable completion with the desire to avoid unnecessarily long execution, making it one of the harder evaluation problems in the talk.

10:0910:20
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:09 · section reference included

Evaluate the audio the user experiences

The film Her provides a fictional bridge to the complexity of voice applications: Aparna recalls Samantha revealing that she is conversing with thousands of other people simultaneously. For a real voice agent, however, the evaluation problem begins with a more immediate distinction. The transcript is only one representation of the interaction; the user hears audio chunks, and those chunks need evaluation too.

In the voice assistant APIs Aparna describes, generated transcripts can arrive after the audio has already been sent. That is her account of the systems discussed in the recording, not a universal ordering guarantee for current APIs. It explains why inspecting the text alone cannot cover the spoken experience. The additional evaluation targets include:

  • Sentiment and intent: What is the user expressing, and what do they want to accomplish?
  • Speech-to-text accuracy: Does the transcription correctly capture the speech?
  • Speech quality: Is the audio itself satisfactory?
  • Tone consistency: Does the assistant maintain an appropriate, consistent tone throughout the conversation?

These checks apply at different scopes: some concern individual audio chunks, while others require the conversation as a whole. They supplement evaluations of conversation flow and the underlying agent’s routing and skills. A voice interface adds evaluation work to the application; it does not remove the need to inspect its internal decisions.

11:2411:36
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:24 · section reference included

Use distributed evaluations to locate failures

The final demonstration applies these ideas to Arize’s own deployed copilot. Embedded throughout the product, it helps users debug, summarize, inspect information, and search using natural language. Aparna opens its production traces and describes running evaluations at every step. For the search example, a top-level evaluation checks whether the overall response is correct. Intermediate checks examine the routing choice and the arguments passed into it. The visible trace contains a planner, embedding steps, SearchRouter, and SearchFunction calls; the Evaluations tab shows SearchQACorrectness marked incorrect.

Arize trace interface showing a planner, embedding steps, SearchRouter and SearchFunction calls, alongside an Evaluations tab with SearchQACorrectness labeled incorrect.Open full source frame
A copilot trace shows nested search steps and a SearchQACorrectness evaluation marked incorrect.

The remaining question is whether execution completed the task or skill correctly. Together, the checks cover different levels of the same request:

ScopeEvaluation question
Overall responseWas the search response correct?
Routing decisionWas the right route selected?
ArgumentsWere the correct arguments supplied?
Skill executionDid the task complete correctly?

Evaluations throughout the trace make failures diagnosable. An incorrect overall response establishes that something went wrong. Checks at the decision and execution points help determine whether the problem occurred in routing, within a skill, or elsewhere along the flow. That is the practical reason to evaluate an agent at multiple levels: the results should help engineers locate the behavior they need to fix.

13:1413:25
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:14 · section reference included

Resources

From the talk

Transcript download
Full transcript

Loading transcript…