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.
| Metric | What it actually measures | Why it matters |
|---|
| Task completion rate | Whether the final outcome met the success criteria. | Necessary, but blind to how the outcome was reached. |
|---|
| Tool-call accuracy | Whether the right tool was invoked, with correctly formed arguments, at each step. | Catches silent failures that a lucky recovery would otherwise hide. |
|---|
| Trajectory efficiency | Step count and backtracking relative to an optimal or reference path. | Flags agents that work but don’t scale economically or predictably. |
|---|
| Recovery behavior | What 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 task | Model 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 rate | How 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.