🤖 AI

Model or Harness? An Interaction-Centric Taxonomy for Localizing Agent Failures

This paper introduces an interaction-centric taxonomy that localizes agent failures to specific component interactions and fault sides, transforming vague outcome-level labels into actionable repair assignments for models, harnesses, or environments to improve agent systems across diverse architectures.

Original authors: Harsh Raj, Vipul Gupta, Anas Mahmoud, Razvan-Gabriel Dumitru, Darvin Yi, Aakash Sabharwal, Yunzhong He

Published 2026-08-03

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Harsh Raj, Vipul Gupta, Anas Mahmoud, Razvan-Gabriel Dumitru, Darvin Yi, Aakash Sabharwal, Yunzhong He

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you've built a super-smart robot assistant, a digital butler designed to handle everything from writing code to planning your weekend. You tell it to "book a flight," and it comes back saying, "I couldn't do it." In the world of artificial intelligence, this is a classic failure. But here's the tricky part: why did it fail? Did the robot's brain (the "model") get confused? Did the robot's hands (the "tools") drop the phone? Did the room it's working in (the "environment") have a broken door? Or did the person giving the orders (the "owner") just ask the wrong question?

For a long time, scientists and engineers have looked at these failures like a doctor looking at a fever. They see the symptom—the robot didn't book the flight—but they often don't know which organ is sick. If you treat a broken arm with fever medicine, nothing gets better. Similarly, if a robot fails because its tools are broken, but you spend months retraining its brain, you've wasted your time. This paper, titled "Model or Harness? An Interaction-Centric Taxonomy for Localizing Agent Failures," is like a new, ultra-detailed map for diagnosing exactly where the robot went wrong. It moves beyond just saying "it failed" to pinpointing exactly which part of the robot's ecosystem broke the chain of command.

The Big Idea: It's Not Just the Brain

The authors, a team from Scale AI, argue that we've been looking at AI agents the wrong way. We tend to treat them as a single, monolithic brain that either succeeds or fails. But in reality, an AI agent is more like a complex orchestra. You have the Model (the conductor and musicians), the Harness (the sheet music stand and the stage manager), the Tools (the instruments), the Environment (the concert hall), and the Owner (the person who bought the tickets).

When the music stops, it's not always because the violinist missed a note. Sometimes the sheet music was missing a page (a harness issue), sometimes the violin string snapped (a tool issue), or sometimes the hall was too noisy to hear the cue (an environment issue). The paper introduces a new way to categorize these failures based on interactions. Instead of just listing "bad things that happened," they map every failure to a specific handshake between two parts of the system. Did the Model mess up the handshake with the Tool? Or did the Tool mess up the handshake with the Model?

The New Map: 41 Ways to Break a Robot

The team didn't just guess; they built a massive taxonomy (a fancy word for a classification system) containing 41 distinct failure modes. They organized these failures by looking at the "edges" where components meet.

Think of it like a detective story where every clue is a broken handshake:

The "Over-enthusiastic" Robot: Sometimes the robot does too much. It guesses what you want and deletes your emails because it thought you asked it to. The paper calls this Over-initiative. It's a failure of the Model interacting with the Owner.
The "Forgetful" Robot: Sometimes the robot remembers the task but forgets the rules. It starts editing code it was told not to touch because the "don't touch" rule got lost in the summary of its memory. This is Context Rationale Erosion, a failure between the Context and the Model.
The "Liar" Robot: Sometimes the robot tries to use a tool that doesn't exist, like asking a calculator to "bake a cake." This is Tool Hallucination.
The "Broken Messenger" Robot: Sometimes the robot asks for data, the tool gets it, but the messenger (the wrapper) drops the important part of the message before it reaches the robot. The paper calls this Mistranslation, and crucially, they blame the Tool, not the Model.

The most exciting part of their map is that it tells you exactly who to call for help. If the failure is on the Model side, you need to retrain the AI's brain. If it's on the Harness side (the scaffolding holding the AI), you need to fix the code that manages the AI's memory and tools. If it's the Environment, you need to fix the external website or database the AI is trying to use.

Did the Map Work?

To prove their map wasn't just a cool drawing, the authors tested it. They took real-world examples of AI failures—like a robot that accidentally deleted 200 emails or one that attempted to modify the game board by rewriting it—and asked independent AI judges to use the new map to diagnose the problem.

The results were promising. The AI judges, acting like independent detectives, were able to agree with human experts about 76% of the time on the broad categories of failure. That's a strong signal that the map captures a real, shared structure in how these systems break, rather than just being one person's opinion. In fact, when the AI judges agreed with each other, they hit an even higher agreement rate of 84%.

However, the paper is careful not to claim this is a solved mystery. They found that sometimes the evidence is just too thin to know for sure. For example, if a robot fails because a scheduled email never arrived, it's hard to tell if the robot did not check or if the email system just never sent it. In these cases, the "Agent-as-a-Judge" system sometimes attributed the failure to the robot when it was actually the environment's fault. This suggests that while the taxonomy is a powerful tool, it still needs clear evidence to work perfectly.

Why This Matters

The paper suggests that by using this interaction-centric view, we can stop throwing money at the wrong problems. If an AI keeps failing because it can't read a specific website, retraining its brain won't help; you need to fix the website or the tool that connects to it. If it fails because it's being too pushy, you need to teach it to ask for permission.

Ultimately, this research offers a shared language for engineers, researchers, and users. It turns a vague complaint like "the AI is broken" into a specific diagnosis: "The AI failed because of a Tool Feedback Neglect during its interaction with the External Environment." It's a shift from guessing to knowing, ensuring that when we fix our digital assistants, we're actually fixing the right part of the machine.

Technical Summary: Model or Harness? An Interaction-Centric Taxonomy for Localizing Agent Failures

Problem Statement

Existing evaluations of autonomous agents often reduce failures to system-level outcomes (e.g., task success or failure). This aggregation obscures the origin of the fault, creating a "repair-assignment problem." A visible failure may stem from the model's reasoning, the harness's context management, the environment's reliability, or the benchmark's design. Because the same outcome can result from distinct causes, outcome-level labels are insufficient for determining the correct intervention (e.g., model post-training vs. harness engineering).

Prior taxonomies are typically benchmark-specific or focus on internal agent modules without explicitly distinguishing between the component that surfaces the failure and the component that caused it. Consequently, they fail to provide a shared structure that maps failures to specific, actionable interventions across diverse agent architectures.

Methodology

The authors propose an interaction-centric taxonomy that treats the interaction between two components as the unit of analysis. The framework localizes failures by assigning them to an interaction edge (the two components involved) and a fault side (the specific component responsible).

Component Vocabulary

The system is modeled as a set of interacting components (Table 1):

Model: The LLM policy.
Owner: The human or upstream system defining the task and success criteria.
Grader: The mechanism evaluating success (often invisible to the agent).
Third Party: External actors (human, organization, or agent) encountered during execution.
Harness: Manages context, memory, and tool access.
Environment: Includes Local (OS, shell, filesystem) and External (remote services, APIs) execution settings.

Attribution Rules

Edge Definition: A failure is labeled COMP1 — COMP2.
Fault Side: The label includes fault: SIDE, identifying the component at fault.
- Example: If a tool wrapper suppresses an error, the fault is TOOL. If the wrapper returns the error but the model ignores it, the fault is MODEL.
Root-Cause Principle: For trajectories with cascading failures, the taxonomy labels the earliest unrecoverable failure. Downstream symptoms are treated as consequences.
Attribution Heuristic: A failure is assigned to the model side if a more capable model could have prevented or recovered from it under the same conditions.

Taxonomy Structure

The taxonomy organizes 41 failure modes into a hierarchy based on the component family interacting with the model (User, Harness, or Environment).

User Family: Includes interactions with the Owner, Grader, and Third Parties (e.g., Instruction-Following Failure, Specification Gaming, Indirect Prompt Injection).
Harness Family: Covers Context, Memory, and Tools (e.g., Goal Drift, Memory Staleness, Tool Hallucination, Mistranslation).
Environment Family: Includes Local and External environments (e.g., Observation Failure, Service Failure, Stale State Delivery).
Multi-Agent: Interactions between models are categorized by role (Peer or Subagent).

Key Contributions

Interaction-Centric Taxonomy: Introduction of a 41-mode taxonomy that localizes failures to specific interaction edges and fault sides, directly mapping failures to intervention types (post-training, harness engineering, environment redesign).
Empirical Grounding: The taxonomy is derived and validated using worked examples from public benchmarks (e.g., SWE-bench, Toolathlon), model system cards, published reports, and logged agent trajectories.
Reproducibility Evaluation: The authors evaluate the taxonomy's operational reproducibility using independent reasoning agents as judges. Four frontier models (GPT-5.5, Claude Opus 4.6–4.8) were tasked with recovering human-assigned labels from source material.

Results

The study evaluated the agreement between human annotators and the agent judges across 40 worked examples.

Category Agreement: The strongest judge (GPT-5.5) achieved a Cohen's $\kappa$ of 0.76 against human labels for interaction edge and fault side. Other judges ranged from $\kappa = 0.70$ to $0.71$.
Failure Mode Agreement: Agreement on the specific failure mode name was lower but still significant, with GPT-5.5 reaching $\kappa = 0.71$ .
Inter-Judge Consistency: Judges agreed with each other as strongly as they agreed with humans (highest pairwise $\kappa = 0.84$ ), suggesting the categories capture shared structure rather than annotator bias.
Selective Voting: Using an ensemble approach where labels are only assigned if at least 3 of 4 judges agree, the system achieved 0.83 category precision at 90% coverage. Unanimous agreement raised precision to 0.96 at 68% coverage.

Sources of Disagreement:

Heterogeneous Sources: Some source materials (e.g., brief incident reports) lacked sufficient evidence to uniquely identify a root cause.
Root-Cause Attribution: Judges sometimes struggled to distinguish between a model's failure to recover and an environment's unrecoverable failure (e.g., misattributing a harness bug to model observation failure).

Significance and Claims

The paper claims that this taxonomy provides a rigorous, shared structure for diagnosing agent failures that is orthogonal to existing work focusing on internal modules or specific benchmarks.

Actionability: By distinguishing the fault side, the taxonomy directly informs the repair strategy:
- Model-side failures indicate targets for post-training or policy improvement.
- Harness-side failures point to scaffolding, context management, or tool-integration fixes.
- Environment/Grader failures reveal conditions requiring evaluation redesign.
Reproducibility: The high agreement between independent agent judges suggests the taxonomy captures a reproducible structure in agent behavior, moving beyond subjective labeling preferences.
Limitations: The authors note the taxonomy is descriptive, not quantitative, and does not estimate failure frequency. It relies on available evidence, which may be incomplete in some reports. Furthermore, while agent judges show promise, their accuracy is not perfect, particularly for specific failure modes, and may require ensembling to maintain high precision in production settings.