🤖 AI

Conflict-Resilient Multi-Agent Reasoning via Signed Graph Modeling

The paper introduces SIGMA, a novel multi-agent reasoning framework that leverages signed graph modeling to explicitly capture trust and conflict relations among agents, enabling conflict-aware message passing and weighted aggregation to significantly outperform existing methods in accuracy and resilience against conflicting signals.

Original authors: Longgang He, Longzhu He, Daojing He, Chaozhuo Li

Published 2026-05-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Longgang He, Longzhu He, Daojing He, Chaozhuo Li

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 Idea: A Team That Knows Who to Trust

Imagine you have a team of experts (AI agents) trying to solve a difficult puzzle. In the past, these teams worked like a group of people in a circle where everyone assumed everyone else was right. If one person shouted a wrong answer, the whole group might get confused and follow that wrong path.

The authors of this paper, SIGMA, realized that real life isn't like that. Sometimes, team members disagree, sometimes they are wrong, and sometimes they are brilliant. The problem with current AI teams is that they treat everyone as equally trustworthy, even when they are arguing or making mistakes.

SIGMA is a new system that teaches the AI team to keep score of trust and conflict. It uses a "Signed Graph," which is just a fancy way of drawing a map where lines between people can be Green (+) for "I trust you," Red (-) for "I disagree with you," or Grey (0) for "I'm not sure."

How SIGMA Works: The Four-Step Process

The paper describes SIGMA working in four distinct stages, like a well-organized meeting:

1. Picking the Right Team (Query-Guided Selection)

Before the meeting starts, SIGMA doesn't just invite everyone. It looks at the specific question (the "query") and picks a small group of experts who are:

Relevant: They know about this specific topic.
Diverse: They think differently from each other (so they don't all make the same mistake).
Confident: They have a track record of being right.
Analogy: It's like a teacher picking a study group. She doesn't pick the loudest kids; she picks the ones who actually know the subject, think differently, and usually get good grades.

2. Drawing the Map (Signed Graph Construction)

Once the team is picked, SIGMA asks them to look at each other's initial answers. It then draws a map:

If Agent A and Agent B agree, it draws a Green Line (+).
If Agent A and Agent B strongly disagree, it draws a Red Line (-).
If they are unsure, it draws a Grey Line.
Analogy: Imagine a group of detectives solving a crime. If two detectives agree on a suspect, they link arms (Green). If one thinks the other is chasing a wild goose, they point in opposite directions (Red). SIGMA maps these relationships immediately.

3. The "Conflict-Aware" Discussion (Signed Message Passing)

This is the magic part. The team discusses the problem, but they don't just average their answers.

Green Lines (Trust): If a trusted agent says something, the others listen closely and reinforce that idea.
Red Lines (Conflict): If a conflicting agent says something, the system doesn't just ignore it; it actively suppresses it. It treats that input as a signal to be careful, effectively "canceling out" the noise.
Analogy: Think of a noise-canceling headphone. If a trusted friend whispers a secret (Green), you hear it clearly. If a stranger is screaming nonsense (Red), the system cancels out that noise so it doesn't ruin your conversation. SIGMA lets the "good" signals get louder and the "bad" signals get quieter.

4. The Final Vote (Signed Consensus Readout)

Finally, SIGMA combines all the refined thoughts into one answer. It doesn't just count votes (1 person = 1 vote). Instead, it weighs the votes based on the map:

Agents who are surrounded by Green lines (trusted by many) get a heavy vote.
Agents who are surrounded by Red lines (disputed by many) get a light or negative vote.
Analogy: It's like a jury where the foreman listens to who the other jurors trust. If the whole jury trusts one person's logic, that logic carries the most weight. If someone is constantly arguing against the group without good reason, their voice is lowered.

Why This Matters (The Results)

The paper tested SIGMA on six different "exam" datasets (covering general knowledge, math, and coding). They compared it to other AI teams that just assumed everyone was cooperative.

The Result: SIGMA consistently got higher scores.
The "Villain" Test: The researchers even added "bad agents" to the mix—some who just made random noise, some who were lazy, and some who tried to confuse the group. Even with up to 50% of the team being "bad," SIGMA still figured out the right answer. The "Red Lines" successfully isolated the bad actors, preventing them from dragging the whole team down.

Summary

In short, SIGMA is a smarter way for AI agents to work together. Instead of blindly trusting everyone, it builds a dynamic map of who trusts whom and who disagrees. By amplifying the voices of the reliable experts and dampening the noise of the confused or conflicting ones, it creates a team that is much harder to trick and much better at solving hard problems.

Technical Summary: Conflict-Resilient Multi-Agent Reasoning via Signed Graph Modeling (SIGMA)

1. Problem Statement

While Large Language Model (LLM)-based Multi-Agent Systems (MAS) have demonstrated superior reasoning capabilities compared to single agents, existing frameworks suffer from critical limitations when handling conflicting information. Current graph-based MAS approaches typically assume uniformly cooperative interactions, modeling agent relationships as non-negative or implicitly supportive. This assumption leads to two primary failure modes:

Uncontrolled Error Propagation: When conflicting signals arise, naive aggregation mechanisms fail to distinguish between trustworthy and adversarial agents, allowing errors to amplify across reasoning steps.
Lack of Structural Awareness: Existing methods lack explicit modeling of the polarity (trust vs. conflict) of inter-agent relations, making it difficult to identify reliable interaction patterns or suppress misleading signals in noisy or adversarial environments.

Consequently, current systems are vulnerable to performance degradation when faced with low-confidence, hallucinated, or adversarial agent outputs.

2. Methodology: SIGMA Framework

The authors propose SIGMA (SIgned Graph-informed Multi-Agent reasoning), a framework that explicitly models the polarity of agent interactions using signed graph theory. The framework operates through four distinct stages:

Stage I: Query-Guided Agent Selection

To ensure the reasoning pool is both relevant and robust, SIGMA selects a subset of agents ( $V_s$ ) based on a composite scoring function that balances three dimensions:

Semantic Relevance: Alignment between the agent's capabilities and the query.
Structural Diversity: Encouraging complementary perspectives to mitigate correlated errors.
Agent Confidence: Prioritizing agents with high self-consistency or low uncertainty.
The selection score $s(v_i)$ combines these factors, ensuring the subsequent reasoning process operates on a diverse, relevant, and reliable agent pool.

Stage II: Signed Relational Graph Construction

Unlike traditional adjacency matrices that only capture interaction strength, SIGMA constructs a signed adjacency matrix $A$ where each edge $A_{ij}$ is decomposed into polarity ( $s_{ij} \in \{-1, 0, +1\}$ ) and magnitude ( $w_{ij} \geq 0$ ):

Trust (+): Supportive interactions where agents agree.
Conflict (-): Contradictory interactions where agents disagree.
Neutral (0): Weak or uncertain interactions.
The polarity is determined by a pairwise evaluation function $f_{eval}$ that assesses the compatibility of initial reasoning states. This allows the system to partition an agent's neighborhood into positive (supportive) and negative (conflicting) sets, extending to multi-hop balanced and unbalanced neighborhoods based on social balance theory.

Stage III: Conflict-Aware Signed Message Passing

SIGMA employs an iterative message-passing mechanism that explicitly disentangles supportive and conflicting signals. Instead of uniform aggregation, each agent maintains separate positive ( $h^{pos}$ ) and negative ( $h^{neg}$ ) representation vectors.

Positive Aggregation: Reinforces signals from balanced neighborhoods (trust) while incorporating polarity-flipped inputs from unbalanced neighborhoods.
Negative Aggregation: Performs the symmetric operation to capture conflict structures.
This design ensures that supportive signals are amplified while conflicting signals are suppressed, preventing the collapse of semantically distinct reasoning paths.

Stage IV: Signed Consensus Readout

The final prediction is generated via a structure- and conflict-aware weighted aggregation. The weight $w_i$ for each agent is computed based on the net supportive strength within the signed graph (summing positive edges and subtracting negative ones). This mechanism prioritizes agents consistently endorsed by the network while down-weighting those surrounded by conflict, yielding a globally consistent and conflict-resilient prediction.

3. Key Contributions

The paper outlines three primary contributions:

Identification of a Critical Limitation: The authors highlight that existing MAS frameworks fail to model trust and conflict, assuming uniform cooperation which reduces robustness under contradictory or noisy outputs.
Proposal of SIGMA: A novel framework that introduces signed graph modeling to LLM-based MAS. It explicitly captures trust, conflict, and neutral relations, enabling conflict-aware message passing and structure-aware aggregation.
Empirical Validation: Extensive experiments demonstrate that SIGMA consistently outperforms state-of-the-art baselines across diverse reasoning tasks, achieving robust performance even in the presence of conflicting or low-quality agents.

4. Experimental Results

SIGMA was evaluated on six benchmark datasets spanning general reasoning (MMLU, MMLU-Pro, GPQA), mathematical reasoning (GSM8K, MultiArith), and code generation (HumanEval), using various LLM backbones (GPT-5, GPT-5 mini, DeepSeek-V3.2).

Performance: SIGMA achieved state-of-the-art results across all datasets, with an average accuracy of 89.17%, outperforming the best baselines (e.g., GoA, G-Designer) by significant margins (e.g., +2.95% on MMLU, +11.54% on MMLU-Pro).
Robustness: In adversarial settings where up to 50% of agents were malicious (simulating random noise, low-quality reasoning, conflict induction, or blind conformity), SIGMA exhibited minimal performance degradation. The framework successfully isolated malicious agents by assigning them negative weights, maintaining high accuracy even under severe noise.
Ablation Studies: Removing any core component (Query-Guided Selection, Signed Graph Construction, Conflict-Aware Message Passing, or Signed Consensus Readout) resulted in performance drops, confirming the necessity of each module.
Hyperparameter Sensitivity: The framework showed stable performance across different values of the relevance-diversity trade-off ( $\lambda$ ) and the number of selected agents ( $k$ ), with optimal results typically found at moderate settings.

5. Significance and Claims

The paper claims that SIGMA fundamentally shifts multi-agent reasoning from a model of "uniform cooperation" to "structured reasoning dynamics." By explicitly modeling the polarity of interactions, SIGMA transforms how agents handle disagreement: rather than treating conflict as noise to be averaged out, it treats conflict as a signal to be suppressed while reinforcing trust.

The authors assert that this approach provides a principled solution to the vulnerability of current MAS in noisy environments. The framework's ability to dynamically identify and isolate unreliable agents makes it particularly suitable for high-stakes applications requiring precise and verifiable reasoning. The paper concludes that explicit modeling of trust and conflict is essential for the next generation of robust, collaborative AI systems.