💻 computer science

Aegis: Automated Error Generation and Attribution for Multi-Agent Systems

This paper introduces Aegis, a novel framework that addresses the scarcity of error attribution data for large language model-based multi-agent systems by automatically generating a large-scale dataset of 9,533 annotated faulty trajectories, which enables the training of efficient models that achieve performance competitive with much larger proprietary systems.

Original authors: Fanqi Kong, Ruijie Zhang, Huaxiao Yin, Guibin Zhang, Xiaofei Zhang, Ziang Chen, Zhaowei Zhang, Xiaoyuan Zhang, Song-Chun Zhu, Xue Feng

Published 2026-03-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Fanqi Kong, Ruijie Zhang, Huaxiao Yin, Guibin Zhang, Xiaofei Zhang, Ziang Chen, Zhaowei Zhang, Xiaoyuan Zhang, Song-Chun Zhu, Xue Feng

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

The Big Problem: The "House of Cards" Multi-Agent System

Imagine you hire a team of highly intelligent robots (AI agents) to build a complex house. They work together: one designs the blueprint, another lays the bricks, a third checks the plumbing, and a fourth paints the walls. This is a Multi-Agent System (MAS).

Usually, these teams work wonders. But sometimes, the house collapses.

The problem is that when the house falls, it's incredibly hard to figure out who knocked it over and why.

Did the bricklayer use weak mortar?
Did the plumber forget to turn off the water?
Or did the painter accidentally paint over the structural supports?

In AI, errors often "cascade." A tiny mistake by the first robot gets passed down, amplified, and eventually causes a massive failure at the end. Because these systems are so complex, humans can't manually check every single conversation log to find the culprit. It's like trying to find a single dropped needle in a haystack the size of a city.

The Bottleneck: We Need More "Crime Scenes"

To teach AI how to debug itself, we need a lot of examples of "failed projects" where we already know exactly what went wrong.

The Old Way: Humans manually read thousands of robot conversations, found the errors, and labeled them. This is slow, expensive, and boring. We only have a few hundred examples (like a tiny crime scene file).
The Result: AI models are bad at debugging because they haven't seen enough "crimes" to learn from.

The Solution: AEGIS (The "Saboteur" Simulator)

The authors created AEGIS (Automated Error Generation and Attribution for Multi-Agent Systems). Think of AEGIS as a super-villain simulator or a chaos engineer.

Instead of waiting for robots to fail naturally, AEGIS takes a team of robots that is doing a perfect job and secretly injects "bugs" to make them fail in specific, controlled ways.

How it works (The Analogy):

The Perfect Run: AEGIS watches a team of robots successfully build a house.
The Sabotage: AEGIS has a "Manipulator" (a digital saboteur). It sneaks in and whispers a wrong instruction to the bricklayer ("Use sand instead of cement") or tricks the plumber ("Ignore the pressure gauge").
The Crash: The house collapses.
The Label: Because AEGIS caused the crash, it knows exactly who it sabotaged and how. It instantly writes a report: "The bricklayer failed because of 'Wrong Materials'."
Repeat: It does this 9,500+ times, creating a massive library of "crash reports" with perfect answers.

The Three Ways AEGIS Teaches AI

Once AEGIS has this massive library of "crash reports," it teaches AI models to become expert detectives using three different training styles:

Supervised Fine-Tuning (The "Textbook" Method):
- Analogy: Like a student studying a textbook where every question has the answer key right next to it.
- How: The AI reads the "crash report" and is told, "This is the error, and this is the culprit." It memorizes the pattern.
Reinforcement Learning (The "Video Game" Method):
- Analogy: Like playing a game where you get points for finding the right suspect and losing points for guessing wrong.
- How: The AI tries to guess the culprit. If it's right, it gets a "reward." If it's wrong or guesses too many people, it gets a "penalty." Over time, it learns to be precise to maximize its score.
Contrastive Learning (The "Spot the Difference" Method):
- Analogy: Showing a detective two photos side-by-side: one of a perfect house and one of a collapsed house.
- How: The AI learns to spot the tiny, subtle differences between a "good" conversation and a "bad" one, training its brain to recognize the specific "vibe" of an error.

The Results: Small Models, Big Brains

The paper tested these trained AI detectives on real-world problems they had never seen before.

The Surprise: The AI models trained on AEGIS became so good at debugging that they outperformed massive, expensive "super-models" (like GPT-4 or Claude) that are 10 times bigger.
The Takeaway: You don't need a giant brain to be a good detective; you just need good training data. AEGIS provided that data.

Why This Matters

Before AEGIS, fixing broken AI teams was like trying to fix a car engine while blindfolded. AEGIS gives us a map. It proves that we can automatically generate the "practice exams" AI needs to learn how to fix itself.

In the future, this means we can build AI teams that are self-healing. If an AI team starts to make a mistake, a trained "AEGIS model" can instantly point a finger and say, "Stop! Agent 3 is lying about the data," allowing the system to correct itself before disaster strikes.

In short: AEGIS is a factory that manufactures "failures" so that AI can learn how to prevent them, making our future AI teams much more reliable and easier to trust.

1. Problem Statement

Large Language Model (LLM) based Multi-Agent Systems (MAS) have shown promise in solving complex tasks but suffer from structural fragility. A single agent's error can cascade through interactions, leading to system-wide failures that are difficult to trace back to their root cause.

The Bottleneck: The primary obstacle to improving MAS reliability is the severe scarcity of large-scale, diverse datasets for error attribution. Existing benchmarks (e.g., Who&When, MASFT, TRAIL) are small (hundreds of examples) and rely on costly, expert-driven manual annotation.
The Challenge: Current SOTA LLMs perform poorly on error attribution tasks. While synthetic data generation has succeeded in other domains (reasoning, coding), applying it to MAS error attribution is difficult because errors must be verifiable (the system must actually fail) and attributable (the specific agent and error mode causing the failure must be known).

2. Methodology: The Aegis Framework

Aegis is a novel, fully automated pipeline designed to generate a large-scale dataset of labeled error trajectories and train models to diagnose them.

A. Automated Data Construction

The framework follows a three-stage pipeline to convert successful executions into verifiable error cases:

Baseline Collection: Generate deterministic, successful trajectories across diverse MAS frameworks (e.g., MacNet, DyLAN, AgentVerse) and task domains (Math, Coding, Science, etc.).
Adaptive Error Injection: An LLM-based Manipulator ( $M_{manip}$ $M_{mani p}$ ) intervenes in successful trajectories to induce failures. It uses two strategies:
- Prompt Injection: Altering the agent's input state.
- Response Corruption: Tampering with the agent's output.
  The manipulator targets specific agents and injects errors based on a taxonomy of 14 error modes (derived from the MAST taxonomy), categorized into Specification Issues, Agent Misalignment, and Task Verification Failures.
Validation & Labeling: The system validates that the injection caused a system failure ( $Z(\tau)=1$ ). The ground truth label is the set of injected errors (Agent + Error Mode), ensuring 100% label fidelity without human intervention.

Dataset Scale: The process yields 9,533 annotated error trajectories covering 6 MAS frameworks and 6 task domains, with ~24,843 individual error instances.

B. Learning Paradigms

The structured nature of the Aegis dataset supports three distinct learning approaches for the error attribution task (predicting the responsible agent and error mode):

Supervised Fine-Tuning (SFT):
- Formulated as a sequence-to-sequence task.
- Input: Trajectory log. Output: JSON-formatted attribution map.
- Objective: Maximize likelihood of generating the ground-truth error labels.
Reinforcement Learning (RL) with GRPO:
- Uses Group Relative Policy Optimization (GRPO).
- Hierarchical Reward Function: Provides dense, graded feedback rather than binary rewards.
  - Partial Credit: Rewards correct agent identification and correct error mode identification separately.
  - Penalties: Penalizes malformed JSON, duplicate predictions, and excessive output length.
  - Normalization: Rewards are normalized by example difficulty.
Disentangled Contrastive Learning (DCL):
- A lightweight, representation-learning approach.
- Mechanism: Treats a trajectory as a "bag" of turns. Uses Multiple Instance Learning (MIL) attention to identify salient "evidence turns."
- Contrastive Objective: Pulls representations of error turns closer to "positive anchors" (the original successful turn and prototype vectors for the specific agent/error) and pushes them away from negatives.
- Consistency: Enforces logical constraints (e.g., the probability of an agent-error pair cannot exceed the probability of the agent alone) via a hierarchical loss.

3. Key Contributions

Aegis Dataset: A large-scale, diverse dataset of ~9.5k annotated error trajectories, significantly larger than prior resources, covering varied architectures and error modes.
Automated Generation Pipeline: A reproducible method to programmatically generate realistic, verifiable error cases with ground-truth attribution, solving the data scarcity bottleneck.
Comprehensive Evaluation: Validation across three learning paradigms (SFT, RL, CL) showing consistent improvements.
Open Source: Release of all code, data, and models to facilitate future research in reliable MAS.

4. Experimental Results

The authors evaluated open-source models (Qwen2.5, Qwen3) and proprietary models (GPT-4o, o3, Gemini) on Aegis-Bench (in-domain) and Who&When (out-of-distribution).

Performance Gains:
- Aegis-SFT (fine-tuned on the dataset) achieved the highest average score (26.51), outperforming all baselines.
- Aegis-GRPO (18.41) remained competitive with large foundation models.
- Fine-tuning a 14B model (Qwen2.5-14B) nearly doubled its performance compared to the base model (13.99 $\to$ 26.51).
- The lightweight DCL model (using a ~35M parameter encoder) achieved a score of 12.61, significantly beating the random baseline (4.08) and demonstrating the efficacy of contrastive learning for this task.
Generalization: Models trained on Aegis showed strong generalization to the human-annotated Who&When benchmark, validating that automated synthesis produces realistic data.
Analysis Findings:
- Agent vs. Error: Models find it easier to identify which agent failed (Agent-level) than why it failed (Error-level).
- Long-tail Distribution: Micro-F1 scores were consistently higher than Macro-F1, indicating models struggle with rare, specific error modes.
- CoT Impact: Chain-of-Thought (CoT) prompting was detrimental to base open-source models (causing parsing failures) but highly beneficial after GRPO training, suggesting RL helps models structure their reasoning effectively.

5. Significance

Methodological Shift: Aegis demonstrates that programmatic data generation is a viable and scalable path to improving AI reliability, moving away from the bottleneck of manual annotation.
Robustness: The ability of models trained on synthetic data to generalize to real-world, human-annotated failures suggests that the structure of errors (agent interactions, error modes) is more critical than the specific content of the tasks.
Future Vision: This work lays the groundwork for self-repairing agentic systems, where models can not only detect but potentially diagnose and fix their own cascading failures in complex multi-agent environments.