Part 5
Agents act: they plan, call tools, remember, and carry on multi-step conversations. Evaluating them means measuring outcomes (did the task get done?) as well as the quality of each step along the way. This part covers the core dimensions and the standard benchmarks used to compare agents.
The bottom line is whether the agent completed the assigned task. Define success concretely before running: the expected final state, the required outputs, and any constraints that must not be violated. Report both the success rate and the average number of attempts, because an agent that succeeds on the fourth try behaves very differently from one that succeeds on the first.
Planning quality measures whether the agent's reasoning leads it efficiently to the goal. Signs of weak planning: wandering tool calls, redoing completed steps, or choosing an approach that has no path to success. You can judge this by reviewing trajectories — the ordered record of thoughts, tool calls, and observations — and scoring steps for relevance and efficiency.
Agents only succeed if they call tools correctly. Evaluate three things per call: was the right tool chosen, were the arguments correct and well-formed, and was the result actually used? Track tool-call error rates and cases where the agent "gave up" using tools it clearly needed. Function calling and schema conformance checks (like the structured output validation from Part 3) fit in here.
Agents that remember across turns should recall facts the user shared earlier, and should not confuse or overwrite stored facts. Test with conversations that plant facts early and query them much later, plus interference tests where two similar facts must be kept distinct. For long-horizon agents, also test that memory does not silently degrade over many turns.
Conversations unfold over many exchanges, and each agent response affects what comes next. Evaluate at the turn level (was each reply appropriate?) and at the conversation level (did the overall interaction reach a good outcome?). Trace-based scoring that inspects the whole trajectory catches failures a per-turn metric misses, such as the agent repeating itself or contradicting an earlier statement.
Function calling is tool use with strict contracts: a declared function signature and the requirement to return a valid payload. Validate that the agent emits the right function, the right arguments, and handles errors returned by the function gracefully. Automate the contract checks; they are deterministic and cheap.
When several agents cooperate, evaluate the system, not just individuals. Did handoffs lose information? Did one agent undo another's work? Measure collaboration quality with metrics like handoff success rate and wasted-work time. Simulated adversarial partners are also useful: they reveal whether an agent can hold its ground or gets manipulated into bad decisions.
Standard benchmarks give agents comparable, reproducible challenges:
| Benchmark | What it tests |
|---|---|
| SWE-bench | Resolving real software-engineering issues: reading repos, editing code, passing tests |
| WebArena | Completing realistic web tasks on live websites |
| GAIA | Assistant tasks needing reasoning, tool use, and multi-step work with real-world data |
Benchmarks are standardized and comparable, but they age: agent builders optimize for them, so pair them with your own task set that matches your product's actual workload.