🤖 AI

CAM: A Causality-based Analysis Framework for Multi-Agent Code Generation Systems

This paper introduces CAM, the first causality-based analysis framework for Multi-Agent Code Generation Systems (MACGS), which quantifies the contribution of intermediate outputs to system correctness to reveal context-dependent feature interactions, optimize hybrid backend architectures, and enable practical applications like failure repair and efficient feature pruning.

Original authors: Zongyi Lyu, Zhenlan Ji, Songqiang Chen, Liwen Wang, Yuheng Huang, Shuai Wang, Shing-Chi Cheung

Published 2026-07-21

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Zongyi Lyu, Zhenlan Ji, Songqiang Chen, Liwen Wang, Yuheng Huang, Shuai Wang, Shing-Chi Cheung

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 are watching a team of expert chefs work together in a giant, high-tech kitchen to bake a perfect cake. This isn't just one chef; it's a whole brigade. One person writes the recipe, another preps the ingredients, a third designs the decoration, and a fourth checks the oven temperature. In the world of computer science, this is called a Multi-Agent Code Generation System. Instead of a human chef, the "chefs" are powerful AI models (Large Language Models) that talk to each other to write computer code. They are incredibly good at this, but they are also a bit of a mystery box. When the final cake (the code) turns out burnt or flat, nobody knows exactly which chef made the mistake. Did the recipe writer get the sugar wrong? Did the decorator use the wrong frosting? Or did the oven checker miss a degree? Because these AI teams produce so much "intermediate chatter" (notes, plans, and drafts) before the final code, it's hard to tell which part of the conversation actually matters. This paper steps into that kitchen to figure out exactly who is responsible for the success or failure of the cake.

The researchers introduce a new tool called CAM, which stands for a Causality-based Analysis Framework. Think of CAM as a super-smart detective that doesn't just guess who messed up; it uses a method called "actual causality." In simple terms, this means the detective asks, "If we changed only this one specific note in the recipe, would the cake still be ruined?" By systematically changing small parts of the AI's conversation and seeing what happens to the final code, CAM can pinpoint exactly which parts of the process are the true heroes and which are just along for the ride. This is a big deal because right now, developers often just guess which parts to fix, or they try to fix everything, which is slow and expensive. CAM offers a way to know for sure.

So, what did the detectives find? First, they discovered that not all parts of the conversation are created equal. The "Specification" (the initial problem description) and the "Design" (the architectural plan) are the heavy hitters. If these get messed up, the whole project usually fails. However, the most surprising discovery was about context-dependent features. Imagine a chef who is perfect at chopping vegetables, but if they are paired with a chef who uses the wrong knife, the whole dish fails. The paper found that some parts of the AI's conversation only become important when they interact with other parts. For example, the choice of programming language might seem fine on its own, but if it clashes with the data structure chosen by another agent, the code breaks. This suggests that checking each part of the AI's work in isolation isn't enough; you have to check how they fit together.

The paper also suggests that we might be able to build better AI teams by mixing and matching different types of AI models. Just like a kitchen might use a specialist for pastry and a generalist for savory dishes, the researchers found that using one AI model for the "planning" stage and a different, specialized model for the "design" stage could improve the final code quality by up to 7.3%. This is a significant jump, suggesting that the future of these systems might not be one giant brain, but a team of specialists working together.

Finally, the researchers showed how this detective work can be used in real life. They used CAM to fix broken code by only tweaking the top three most important parts of the conversation, which fixed 73.6% of the failures. Even cooler, they showed that you can actually remove some of the AI's intermediate chatter entirely. By cutting out the low-importance notes, they reduced the amount of computer power needed by up to 33.6% without hurting the quality of the code, and in some cases, the code actually got better because the AI wasn't distracted by unnecessary information.

In short, this paper proves that we can stop guessing why AI code generation fails. By using a systematic way to test cause-and-effect, we can identify the most critical parts of the process, mix the right AI models for the right jobs, and even cut out the fluff to save time and money. It turns a chaotic, opaque kitchen into a well-oiled machine where every chef knows their role.

Technical Summary: CAM – A Causality-based Analysis Framework for Multi-Agent Code Generation Systems

1. Problem Statement

Multi-Agent Code Generation Systems (MACGS) have demonstrated significant success in automated software development by decomposing complex tasks among specialized agents. However, the inherent complexity of these architectures generates substantial volumes of intermediate outputs, the individual contributions of which to final system correctness remain opaque. This lack of transparency impedes targeted optimization and robustness analysis.

Existing methods for analyzing these intermediate outputs suffer from critical limitations:

Manual Analysis: Intuitive but prohibitively expensive, subjective, and non-scalable.
LLM-based Evaluation: Automated but exhibits low accuracy (e.g., ~41% in preliminary studies) and struggles to distinguish correlation from causation in complex chains.
All-but-One Ablation: Coarse-grained approaches that disable entire agents or modules fail to capture the nuanced, non-additive influence of specific intermediate components and lack generalizability across different architectures.

There is a critical need for a fine-grained analysis method that can systematically quantify the causal influence of specific intermediate features on final code correctness while balancing analytical rigor with computational cost.

2. Methodology: The CAM Framework

The authors propose CAM, the first Causality-based Analysis framework for MACGS. CAM leverages actual causality to identify the relative importance of different intermediate components. The framework operates through three primary stages:

2.1 Causal Modeling of Intermediate Outputs

To address the challenge of modeling complex, heterogeneous intermediate outputs, CAM introduces a function-oriented categorization method.

Categorization: Instead of relying on standard operating procedures (SOPs) which may lack generalizability, CAM reorganizes intermediate outputs into four functional categories: Specification (e.g., problem statements), Analysis (e.g., requirement breakdown), Design (e.g., architecture and algorithms), and Dependency (e.g., package management).
Feature Extraction: This process maps outputs to 12 structured semantic fields (features) spanning the generation chain.
Causal Graph Construction: A Directed Acyclic Graph (DAG) is constructed where nodes represent features and edges represent information flow. To ensure acyclicity despite iterative refinement processes in MACGS, features are defined by their final values in the execution trace, abstracting away intermediate iterative states.

2.2 Realistic Error Simulation

To perform causal analysis, the framework must simulate counterfactual scenarios.

LLM-based Intervention: CAM employs an LLM as a counterfactual intervention engine. Given an original feature, the LLM generates a modified version that introduces realistic errors or misunderstandings while maintaining semantic coherence within the workflow.
Validity: Interventions are implemented as direct value substitutions to eliminate confounding factors, ensuring observed performance changes are attributable to the specific intervention.

2.3 Identification of Important Features

CAM utilizes an efficient algorithm to identify "important feature combinations" (minimal sets of features whose simultaneous intervention causes system failure) without exhaustively testing all states.

Influence Sets: Leveraging the self-correction capabilities of agents, the framework defines an influence set $E(S)$ as the set of downstream features whose semantics are altered when a feature set $S$ is intervened upon.
Collective Influence Sets: To reduce computational overhead, a collective influence set $\hat{E}(S)$ is computed by aggregating influence sets of subsets of $S$ , allowing for prioritized search without executing the full MACGS for every candidate.
Search Algorithm: A greedy selection strategy prioritizes feature combinations with large collective influence sets. The algorithm iteratively explores combinations of increasing length, pruning unpromising regions based on minimality and influence properties.
Feature Responsibility (FR): The importance of a feature is quantified by aggregating its contribution across problems. The FR metric weights features appearing in shorter (more critical) combinations more heavily, defined as:
$FR(f_i) = \frac{1}{|P|} \sum_{p \in P} \sum_{S \in S_p, f_i \in S} \left(\frac{1}{|S|}\right)^2$

3. Key Contributions

Framework Proposal: Introduction of CAM, the first framework to apply actual causality to systematically analyze MACGS intermediate outputs, establishing causality analysis as a viable approach for understanding these systems.
Methodological Innovation: Development of a generalizable function-oriented categorization method and an efficient search algorithm utilizing influence sets to balance analysis comprehensiveness with computational cost.
Empirical Insights: Extensive analysis across multiple MACGS (MetaGPT, Self-Collab, etc.), backend LLMs (GPT-4o-mini, DeepSeek-Coder, Qwen), and datasets (HumanEval, MBPP, CodeContest, CoderEval).
Practical Applications: Demonstration of CAM's utility in failure repair (optimizing top-ranked features) and feature pruning (reducing token consumption).

4. Key Results and Findings

4.1 Validation

Reliability: CAM's feature importance rankings show strong agreement with manual human annotations, with Kendall's correlation coefficients ranging from 0.76 to 0.91 across different dataset-LLM combinations.

4.2 Feature Importance Patterns

Hierarchy: Specification and Design features consistently dominate the top importance rankings. Dependency features generally occupy the lowest positions.
Context-Dependency: A significant finding is the existence of context-dependent features. For example, the importance of Program_Lang (programming language) emerges primarily through interactions with other features (78.8% of cases), rather than in isolation. This suggests that failures often stem from subtle incompatibilities between seemingly correct intermediate features, necessitating cross-feature consistency checks over module-level validation.

4.3 Impact of Backend LLMs

Model-Specific Strengths: Different backend LLMs exhibit distinct feature importance patterns. Specialized code models (DS-Coder, Qwen) show higher reliance on Design features, while general-purpose models (GPT-4o-mini) rely more heavily on Specification features.
Hybrid Architecture: Based on these findings, a hybrid backend architecture (assigning DS-Coder to the design stage and GPT-4o-mini to other stages) was tested. This configuration achieved up to a 7.3% improvement in Pass@1 on complex datasets like CodeContest compared to uniform backend configurations.

4.4 Impact of Dataset Characteristics

Difficulty Modulation: Challenging datasets (e.g., CodeContest) exhibit more uniform feature importance distributions, indicating that complex problems require the synthesis of information across multiple features. Simpler datasets show dominance by a few critical features.
Domain Specificity: In engineering-focused datasets (CoderEval), Dependency features rise in importance, reflecting the critical nature of library integration in real-world scenarios.

4.5 Downstream Applications

Failure Repair: A causality-guided repair strategy, which optimizes only the top-3 ranked features, achieved a 73.6% success rate in fixing failed code generation, significantly outperforming random or temporal baselines (27.8%–39.4%).
Feature Pruning: Pruning low-importance features (removing the bottom 2–4 features) reduced intermediate token consumption by up to 33.6% with negligible or sometimes positive impacts on Pass@1 performance. Aggressive pruning (8 features) led to consistent performance degradation.

5. Significance and Claims

The paper claims that CAM provides actionable insights for the design and deployment of MACGS. By moving beyond coarse-grained ablation to fine-grained causal analysis, the framework reveals that:

Quality Assurance must evolve from isolated module validation to include cross-feature consistency checks to address context-dependent failures.
Hybrid Architectures leveraging the specific strengths of different LLMs for specific subtasks (e.g., design vs. specification) represent a promising direction for future MACGS design.
Resource Allocation should be adaptive; simple tasks allow for focusing on top-ranked features, while complex tasks require balanced optimization across all feature categories.

The authors position CAM as a broadly applicable analysis tool that establishes causality analysis as a powerful methodology for understanding and improving the robustness and efficiency of Multi-Agent Code Generation Systems.