The problem the paper defines
A team from Penn State University and Duke University, in collaboration with Google DeepMind, the University of Washington, Meta, Nanyang Technological University, and Oregon State University, has formalized a new research problem: automated failure attribution in LLM multi-agent systems. The work, accepted as a Spotlight at ICML 2025, introduces the first benchmark for the task.
The basic problem is that LLM multi-agent systems fail all the time, and when they fail, developers have no good way to figure out which agent, at what step, was responsible. Sifting through interaction logs to pinpoint the root cause is finding a needle in a haystack, and a familiar frustration for anyone who has built or maintained a multi-agent system.
The paper defines the task concretely: given a failed multi-agent trajectory, identify the failure-responsible agent and the decisive error step. Both annotations are required for a useful diagnosis.
The Who&When benchmark
To support the task, the team built Who&When, a dataset of failure logs from 127 LLM multi-agent systems, either algorithmically generated or hand-crafted by experts. Each failure log comes with fine-grained human annotations: which agent failed, the specific interaction step where the decisive error occurred, and a natural language explanation of why.
The benchmark is now publicly available on Hugging Face, with the code on GitHub. It is the first dataset of its kind for the failure attribution task, and it is comprehensive enough to be useful for training and evaluation.
What the current methods can and cannot do
The paper evaluates three automated attribution methods: All-at-Once (single pass over the whole log), Step-by-Step (sequential review), and Binary Search (log division). Each has a different cost-performance profile.
The results are sobering. The best-performing single method achieved only about 53.5% accuracy in identifying the responsible agent, and a mere 14.2% in pinpointing the exact error step. Some methods performed below random. Even state-of-the-art reasoning models like OpenAI o1 and DeepSeek R1 fail to achieve practical usability on the task.
Performance also decreases as context length increases, which is the worst possible failure mode for a tool meant to debug long-running agent systems.
Why this matters beyond the paper
The work is significant for two reasons. First, it names a problem that everyone who has run a multi-agent system has hit, and it gives the field a way to measure progress on it. That is the prerequisite for any serious research effort to follow.
Second, the gap between the difficulty of the task and the capability of current models is large enough that nobody should be deploying multi-agent systems in production without a clear answer to the question "what do we do when this fails, and which agent do we blame." The honest answer today is that you blame the whole system, because the tools to localize the failure are not yet good enough.
The paper's authors have made the dataset and code open, which is the right move for a foundational benchmark. The next round of work will tell us whether the right approach is better attribution models, better agent designs that fail more locally, or both.