When a system built from several cooperating large language model agents fails at a task, figuring out which agent caused the failure, and at what exact step, has traditionally meant a developer manually combing through long interaction logs. Researchers from Penn State University and Duke University, working with collaborators at Google DeepMind, the University of Washington, Meta, Nanyang Technological University, and Oregon State University, argue this needle-in-a-haystack process is exactly the kind of task that should be automatable, and have built the first formal benchmark for doing so.
The team's paper formalizes what it calls automated failure attribution: identifying both the specific agent responsible for a multi-agent task's failure and the exact interaction step where the decisive error occurred. To support that research question, they built Who&When, a dataset drawn from failure logs across 127 different LLM multi-agent systems, some generated algorithmically and others hand-crafted by experts for realism. Each log carries fine-grained human annotations marking the responsible agent, the specific step where things went wrong, and a natural-language explanation of the cause.
Using that dataset, the researchers tested three candidate methods for automated attribution. An all-at-once approach feeds a model the user's original query and the full failure log and asks it to name the responsible agent and error step in one pass, which is cheap but can struggle with long context. A step-by-step method mimics manual debugging, having the model review the log sequentially until it locates the error, which is more precise but costlier and prone to compounding mistakes along the way. A binary-search method splits the difference, repeatedly halving the log and asking the model which half contains the fault.
The results are, by the researchers' own account, sobering. Even the best-performing single method only correctly identified the responsible agent and the exact error step at modest accuracy rates, with some approaches performing worse than random guessing on parts of the task. The all-at-once method tended to be better at identifying who was responsible, while step-by-step was better at pinpointing when the error happened, with binary search landing in between on both dimensions. Combining methods, such as using all-at-once to shortlist a likely agent before running step-by-step analysis on just that portion, improved results but added meaningfully to computational cost. Notably, even advanced reasoning models including OpenAI's o1 and DeepSeek's R1 found the task difficult, underscoring that failure attribution demands a different kind of reasoning than most conventional benchmarks test. The researchers also found that accuracy degraded further as the length of the failure log grew, with the effect most pronounced for pinpointing the exact error step.
The paper has been accepted for publication, and the team has released both the code and the Who&When dataset as open source. The authors frame the work less as a finished solution and more as the opening of a new research direction: turning the currently mysterious question of what went wrong and who is to blame in a multi-agent system into something quantifiable enough to actually improve on.