Guide AI Testing & Evaluations

Evaluating AI Agents: Metrics That Actually Matter Beyond Task Success

An agent that completes 95% of its assigned tasks sounds production-ready — until you check how it got there. Maybe it called the refund API three times before the right one landed. Maybe it “succeeded” by silently skipping a verification step. Task success rate tells you the ending; it says almost nothing about the path, and for an agentic system that can take real actions, the path is exactly where the risk lives.

01

Tool-call accuracy

Did the agent call the right tool, with the right arguments, at the right step — not just eventually get an acceptable result.

02

Trajectory efficiency

Reaching the goal isn’t enough on its own; the path taken to get there — how many steps, how much backtracking, how much was wasted — is part of correctness.

03

Cost & recovery

A 95% success rate that burns forty model calls and never recovers cleanly from a failed tool call isn’t a production metric — it’s a demo metric.

Why task success rate alone is misleading

Task success rate answers one question — did the agent eventually produce an acceptable outcome — and that question is too coarse for anything that takes real actions on your behalf. An agent can hit the right answer by calling the correct API on the third retry after two failed attempts with malformed arguments, by taking a thirty-step detour through tools it didn’t need, or by skipping a safety check that happened not to matter on this particular input. All three count as a “success.” None of them are the same agent you’d want handling a customer refund or a production deployment unsupervised.

MetricWhat it actually measuresWhy it matters
Task completion rateWhether the final outcome met the success criteria.Necessary, but blind to how the outcome was reached.
Tool-call accuracyWhether the right tool was invoked, with correctly formed arguments, at each step.Catches silent failures that a lucky recovery would otherwise hide.
Trajectory efficiencyStep count and backtracking relative to an optimal or reference path.Flags agents that work but don’t scale economically or predictably.
Recovery behaviorWhat the agent does after a tool call fails or returns an unexpected result.Production tool calls fail routinely — recovery quality is a core reliability signal.
Cost & latency per taskModel calls, tokens and wall-clock time consumed to reach completion.A correct answer that costs 10× more than budgeted isn’t a shippable one.
Human-intervention rateHow often a human had to step in, correct, or approve before completion.The real measure of how close an agent is to unsupervised operation.

Where teams get this wrong

The most common mistake: optimizing an agent against task completion rate alone, then discovering in production that the agent’s “successes” were routinely routing through unintended tool calls, retried actions that should have been idempotent-checked first, or quietly skipping a confirmation step. A dashboard that only tracks the ending gives a false sense of reliability right up until the first incident report.

Building an evaluation harness for agentic systems

Start below the task level: unit-test individual tool calls against a library of inputs, checking that the agent selects the correct tool and forms valid arguments before it’s ever asked to complete a multi-step task. Layer trajectory evaluation on top of that — run the agent against a held-out set of realistic tasks and score the full path it takes, not just the final state, ideally against a reference trajectory or a rubric an experienced operator would apply. Only then move to production: shadow-mode monitoring that logs tool calls, intervention events and cost per task in the live environment, because an agent’s behavior under real, messy inputs reliably diverges from its behavior on a curated test set.

Agentic evaluation is not the same exercise as red-teaming

It’s worth separating this from adversarial testing. Red-teaming asks what happens when someone deliberately tries to break the agent; the metrics above ask how the agent performs on the ordinary, well-intentioned tasks it was actually built for. A production-ready agent needs to pass both — a high score on trajectory efficiency says nothing about what happens when a user tries to manipulate it, and a clean red-team report says nothing about whether the agent is economically viable to run at scale.

A note on scope and currency This is general guidance on agent evaluation architecture, not a scoped evaluation plan for your specific agentic system. Appropriate thresholds for tool-call accuracy, trajectory efficiency and cost-per-task vary significantly by task complexity and risk tolerance — calibrate them against your own reference trajectories before using them as release gates.

Frequently asked questions

What’s the difference between task success rate and trajectory evaluation?

Task success rate checks only the final outcome. Trajectory evaluation scores the path the agent took to get there — which tools it called, in what order, and how much backtracking or wasted effort was involved — which is where most production reliability problems actually show up.

How do you evaluate an agent that completed the task but took an inefficient or risky path?

Score it separately on completion and on trajectory quality rather than collapsing both into one pass/fail number. An agent that reaches the right answer through an inefficient or risky path should be flagged for review even though it technically succeeded.

Should tool-call accuracy be measured per call or per task?

Both. Per-call accuracy catches individual malformed requests or wrong-tool selections; per-task aggregation shows whether those individual errors are compounding into unreliable end-to-end behavior.

How often should agent evaluations run in production?

Continuously on a sample of live traffic, not only before launch — agent behavior drifts as the underlying model, available tools, or upstream data change, and shadow-mode monitoring is what catches that drift before users do.