Most engineering teams still evaluate AI agents the same way they grade math homework. They look at the final output. If the answer is right, they greenlight the release and move on. This is a dangerous shortcut. A correct answer can hide a deeply broken system.
The real story lives in the path the agent took to get there. That path is called the agent trajectory. It includes every tool call, every routing decision, every pause where the agent stops to reconsider. You can think of it as the agent's trail of breadcrumbs. And if you only inspect the destination, you miss all the warning signs scattered along the way.
The Problem with Messy Paths
An agent can land on the right answer while behaving like a drunk driver. It swerves through the wrong tools, doubles back to the router, and cycles through redundant reasoning before finally stumbling into something correct. The user sees a clean result. Behind the scenes, the system is bleeding resources and accumulating risk.
What does this mess actually look like in practice?
First, there is the redundant tool call. The agent queries your customer database, gets the result, forgets it five seconds later, and queries the same record again with identical parameters. This is not a data issue. It is a trajectory issue. The agent failed to retain state, so it repeats work.
Then there is the wrong-tool-first pattern. A coding agent might try to search the web for a function definition that already lives in the local repository. Or a support agent might reach for the billing API when the user's question clearly requires the account settings tool. Each wrong choice burns tokens, adds latency, and increases the chance that context limits get crushed before the real work begins.
Router loops are another red flag. The decision node cannot commit. It sends the task to branch A, changes its mind, pulls it back, forwards it to branch B, then routes it through a general-purpose fallback node for no reason. Every loop adds a network hop and another layer of confusion to the eventual debug log.
Finally, there is repeated analysis. The agent keeps re-deriving the same conclusion at every step instead of treating it as settled. It is like a carpenter who measures the board ten times before every cut. The first measurement was fine. The next nine are wasted motion.
These extra steps have real consequences. Latency stacks up. In a synchronous chat interface, an extra three seconds feels like a lifetime. At scale, those seconds translate into thousands of dollars in compute. The failure risk climbs too. Every unnecessary hop is another chance for an external API to time out, a context window to overflow, or a race condition to surface. And when something does break, good luck debugging a trace that looks like spaghetti. You will spend hours reconstructing why the agent took step seven only to realize step seven never should have existed.
What Convergence Actually Means
If trajectory is the path, convergence is the measure of its efficiency. Convergence tells you how closely the agent sticks to the shortest viable route between a user's request and the correct resolution.
This is not the same as accuracy. Accuracy is a blunt instrument. It asks whether the final state is correct. Convergence asks whether the journey was sane. An agent with high accuracy and low convergence is a liability wearing a success costume. An agent with high convergence and middling accuracy is usually easier to fix, because its reasoning is clean and its mistakes are localized.
You can calculate a rough convergence score by comparing the steps the agent actually takes against the shortest path you have defined for that task class. If a standard refund query should require exactly three tool calls and the agent used nine, your convergence ratio is taking a hit. You can refine this by weighting different types of waste. A single wrong tool call might cost more than a single redundant call, depending on the tool's latency and price. A router loop that adds no value might carry the heaviest penalty of all, because it signals architectural