When a multi-agent LLM system fails, the logs can run for thousands of tokens across dozens of interaction steps. Figuring out which agent broke the chain, and at which step, is the kind of debugging task that makes developers want to switch careers. A new research collaboration between Penn State University, Duke University, Google DeepMind, University of Washington, Meta, Nanyang Technological University, and Oregon State University has turned that pain into a formal problem: automated failure attribution.
The team, led by co-first authors from PSU and Duke, introduced the Who&When benchmark and tested three distinct attribution methods. Their findings are sobering. Even the best single method identified the responsible agent only about 40 percent of the time, and pinpointed the exact error step in roughly 15 percent of cases. Some methods performed worse than random guessing.
The Three Attribution Strategies
The researchers designed and evaluated three approaches, each representing a different trade-off between cost and precision.
All-at-Once feeds the complete failure log to the model in a single pass and asks it to name the agent and the step. It is cheap but imprecise, especially as context length grows. The model tends to fixate on salient but not necessarily causal events.
Step-by-Step mimics human debugging. The model reviews the log sequentially and makes a judgment at each step until it finds the error. This is more precise at locating the exact step, but it incurs higher API costs and risks compounding errors. A wrong judgment at step three can derail every subsequent conclusion.
Binary Search splits the difference. It repeatedly divides the log in half, asks the model which segment contains the error, and recurses. It offers middle-ground performance on both accuracy and cost.
What the Experiments Revealed
The Who&When dataset contains failure logs from 127 multi-agent systems, some algorithmically generated and some hand-crafted by experts. Each log carries fine-grained human annotations for the responsible agent, the decisive step, and a natural language explanation of the failure cause.
Tests were run in two conditions: one where the evaluator knew the ground-truth answer to the task the agents were attempting, and one where it did not. The primary model was GPT-4o, with additional tests on OpenAI o1 and DeepSeek R1. Even these advanced reasoning models found the task challenging, which suggests that failure attribution demands a type of reasoning distinct from the forward-planning tasks these models are typically benchmarked on.
A few specific findings stand out. First, different methods excel at different aspects: All-at-Once is better at identifying "who," while Step-by-Step is better at determining "when." Second, combining methods helps. Using All-at-Once to narrow down the agent, then Step-by-Step to find the exact step, improved overall performance at the cost of significantly more compute. Third, context length degrades accuracy. As logs grow longer, all methods suffer, with error-step identification degrading faster than agent identification.
Why This Matters for the Field
Multi-agent systems are increasingly deployed for complex tasks: software engineering, research synthesis, customer support. The current debugging workflow is manual, slow, and dependent on deep system expertise. Without automated attribution, teams cannot iterate quickly. Worse, they may misattribute failures and "fix" the wrong agent, leaving the real bug untouched.
The Who&When benchmark and the open-sourced code provide a foundation for the community to build better attribution methods. But the low baseline scores are a warning. If we cannot reliably explain why our agent teams fail, we should hesitate to give them more autonomy.