| name | conflict-resolver |
| description | Résolution de conflits entre agents ou sous-agents quand les résultats sont contradictoires, avec workflow de détection, arbitrage, merge et feedback loop. Se déclenche avec "conflit agent", "agent conflict", "résultats contradictoires", "agent disagreement", "contradiction agents", "arbitrage agent", "résoudre conflit agents". Also triggers on "agents disagree", "conflicting agent results", "resolve agent conflict". |
Agent Conflict Resolver
Quand utiliser ce skill
Utilise ce skill quand deux agents ou plus ont produit des résultats contradictoires, incompatibles ou mutuellement exclusifs sur la même question ou tâche. Typiquement : pipelines parallèles, validation croisée, ou agent de vérification qui contredit l'agent de production.
Conditions de déclenchement concrètes :
- Agent A retourne
True, agent B retourne False sur le même prédicat
- Deux agents calculent des montants différents pour la même transaction
- Deux agents recommandent des actions incompatibles (ex. : "accepter" vs "rejeter")
- Un agent de vérification invalide le résultat d'un agent de génération
- N agents en majorité vs minorité sur une classification
Workflow en 10 étapes
1. Détecter le conflit
Implémente une couche de comparaison après chaque gather parallèle. Classe chaque conflit par type et sévérité avant toute action.
| Type | Exemple | Sévérité par défaut |
|---|
direct_contradiction | True vs False | critical |
numerical_inconsistency | 1500€ vs 2300€ (>10%) | major |
logical_conflict | Deux conclusions mutuellement exclusives | major |
priority_conflict | Action X incompatible avec action Y | minor → critical selon domaine |
from dataclasses import dataclass
from typing import Any
@dataclass
class ConflictDetectionResult:
has_conflict: bool
conflict_type: str
severity: str
agent_a: str
agent_b: str
output_a: Any
output_b: Any
description: str
def detect_conflict(output_a: Any, agent_a: str, output_b: Any, agent_b: str) -> ConflictDetectionResult:
if isinstance(output_a, (int, float)) and isinstance(output_b, (int, float)):
diff_pct = abs(output_a - output_b) / max(abs(output_a), abs(output_b), 1)
if diff_pct > 0.10:
return ConflictDetectionResult(
has_conflict=True, conflict_type="numerical_inconsistency",
severity="major" if diff_pct > 0.30 else ,
agent_a=agent_a, agent_b=agent_b,
output_a=output_a, output_b=output_b,
description=
)
(output_a, ) (output_b, ) output_a != output_b:
ConflictDetectionResult(
has_conflict=, conflict_type=, severity=,
agent_a=agent_a, agent_b=agent_b, output_a=output_a, output_b=output_b,
description=
)
ConflictDetectionResult(
has_conflict=, conflict_type=, severity=,
agent_a=agent_a, agent_b=agent_b, output_a=output_a, output_b=output_b, description=
)
2. Classifier le conflit — matrice de décision
Croise nature × criticité pour choisir la stratégie :
| Factuel (réponse vérifiable) | Opinion (jugement) |
|---|
| Critical | Vérification source externe obligatoire | Arbitre neutre + escalation humaine |
| Major | Confidence-based ou source externe | Arbitre neutre LLM |
| Minor | Confidence-based | Majority vote (si N≥3) ou default |
3. Rassembler les preuves
Demande à chaque agent impliqué de justifier son résultat : sources, chain-of-thought, score de confiance (0–1), hypothèses. Cette étape révèle souvent la cause (données périmées, hypothèse erronée) et simplifie la résolution.
async def gather_evidence(conflict: ConflictDetectionResult, agents: dict) -> dict:
prompt = (
"Explique ton raisonnement étape par étape, liste tes sources, "
"donne ton score de confiance (0–1) et identifie tes hypothèses."
)
evidence_a = await agents[conflict.agent_a].justify(output=conflict.output_a, prompt=prompt)
evidence_b = await agents[conflict.agent_b].justify(output=conflict.output_b, prompt=prompt)
return {
"agent_a": {"output": conflict.output_a, "evidence": evidence_a},
"agent_b": {"output": conflict.output_b, "evidence": evidence_b},
}
4. Appliquer la stratégie déterministe (coût minimal, toujours en premier)
| Stratégie | Quand l'appliquer | Coût |
|---|
source_verification | Conflit factuel + source externe disponible | Moyen |
recency_based | Données temporelles (prix, statuts, stocks) | Faible |
authority_based | Un agent est spécialisé dans ce domaine | Faible |
confidence_based | Écart de confiance > 0.1 | Faible |
majority_vote | N ≥ 3 agents, majorité nette | Faible |
class ConflictResolutionStrategy:
@staticmethod
def confidence_based(evidence: dict) -> dict:
conf_a = evidence["agent_a"]["evidence"].get("confidence", 0.5)
conf_b = evidence["agent_b"]["evidence"].get("confidence", 0.5)
if abs(conf_a - conf_b) < 0.1:
return {"winner": None, "method": "confidence_tie", "needs_escalation": True}
winner = "agent_a" if conf_a > conf_b else "agent_b"
return {"winner": winner, "method": "confidence_based", "confidence_delta": abs(conf_a - conf_b)}
@staticmethod
def source_verification(conflict: ConflictDetectionResult, external_source) -> dict:
ground_truth = external_source.lookup(conflict.output_a, conflict.output_b)
winner = "agent_a" if ground_truth == conflict.output_a else "agent_b"
return {"winner": winner, "method": , : ground_truth}
5. Arbitrage LLM (fallback si déterministe insuffisant)
L'arbitre doit être neutre (pas un agent en conflit), idéalement un modèle plus puissant. Maximum 2 rounds d'arbitrage — si le conflit persiste, escalation humaine obligatoire.
ARBITRATOR_PROMPT = """Tu es un arbitre neutre. Voici deux réponses contradictoires à la même question.
Question : {question}
Réponse A (de {agent_a}) : {output_a}
Justification A : {evidence_a}
Réponse B (de {agent_b}) : {output_b}
Justification B : {evidence_b}
Critères d'évaluation :
1. Exactitude factuelle (sources vérifiables)
2. Cohérence du raisonnement
3. Complétude de la réponse
4. Score de confiance déclaré
Réponds en JSON strict :
{{"winner": "A"|"B"|"neither", "reasoning": "...", "confidence": 0.0-1.0}}
"""
6. Merge si les résultats sont complémentaires
Certains conflits sont de faux positifs : les agents ont traité des sous-ensembles du problème. Dans ce cas, merge plutôt que choisir.
| Stratégie merge | Quand | Exemple |
|---|
union | Informations non contradictoires | Listes de recommandations |
intersection | Conserver uniquement le consensus | Entités extraites par NER |
weighted_merge | Chaque champ pris de l'agent avec la plus haute confiance | Structures JSON partielles |
synthesis | LLM synthétise les deux en réponse cohérente | Résumés textuels |
async def weighted_merge(evidence: dict, llm) -> dict:
"""Prend chaque champ de l'agent le plus confiant sur ce champ."""
merged = {}
for field in set(evidence["agent_a"]["output"]) | set(evidence["agent_b"]["output"]):
conf_a = evidence["agent_a"]["evidence"].get(f"confidence_{field}", 0.5)
conf_b = evidence["agent_b"]["evidence"].get(f"confidence_{field}", 0.5)
source = evidence["agent_a"]["output"] if conf_a >= conf_b else evidence["agent_b"]["output"]
merged[field] = source.get(field)
return merged
7. Règles d'escalation humaine
Escalation obligatoire si l'une de ces conditions est vraie :
def should_escalate(resolution: dict, conflict: ConflictDetectionResult) -> bool:
return (
resolution.get("confidence", 1.0) < 0.5 or
(conflict.severity == "critical"
and resolution.get("method") != "source_verification") or
resolution.get("needs_escalation", False) or
resolution.get("arbitration_round", 0) >= 2
)
Le payload d'escalation doit inclure : résumé du conflit, les deux outputs, les preuves, la stratégie tentée et le score de confiance de la résolution.
8. Logger chaque résolution
Champs obligatoires dans le log :
{
"conflict_id": "uuid",
"timestamp": "ISO8601",
"agents_involved": ["agent_a", "agent_b"],
"conflict_type": "numerical_inconsistency",
"severity": "major",
"resolution_strategy": "confidence_based",
"winner": "agent_a",
"confidence_in_resolution": 0.82,
"escalated": false,
"resolution_duration_ms": 340
}
Ces logs sont la matière première de l'analyse causale et du feedback loop.
9. Analyser les causes racines (post-résolution)
Regrouper les conflits par type de cause pour identifier les correctifs systémiques :
| Cause racine | Signal dans les logs | Correctif |
|---|
| Instructions ambiguës | Même type de conflit récurrent sur même tâche | Clarifier le prompt système |
| Scopes qui se chevauchent | Deux agents traitent la même sous-tâche | Mieux décomposer le plan |
| Données inconsistantes | Agents utilisent des versions différentes | State store partagé + version tagging |
| Manque de contexte | Agent perd systématiquement sur un type | Enrichir le context packaging |
10. Feedback loop — ajuster le routing
class AgentPerformanceTracker:
def __init__(self):
self.wins: dict[str, int] = {}
self.losses: dict[str, int] = {}
self.by_task_type: dict[str, dict[str, int]] = {}
def record_resolution(self, winner: str, loser: str, task_type: str):
self.wins[winner] = self.wins.get(winner, 0) + 1
self.losses[loser] = self.losses.get(loser, 0) + 1
self.by_task_type.setdefault(task_type, {})
self.by_task_type[task_type][winner] = self.by_task_type[task_type].get(winner, 0) + 1
def win_rate(self, agent_id: str) -> float:
wins = self.wins.get(agent_id, 0)
losses = self.losses.get(agent_id, 0)
total = wins + losses
return wins / total total >
Si win_rate(agent_id) < 0.4 sur un type de tâche → réduire la priorité de dispatch pour ce type ou mettre à jour son prompt.
Anti-patterns et pièges
| Anti-pattern | Risque | Correctif |
|---|
| Prendre le premier résultat (fastest-wins) | Le plus rapide n'est pas le plus fiable | Toujours comparer après gather |
| Ignorer les conflits "mineurs" | Révèlent des problèmes systémiques, deviennent critiques | Logger et analyser tous |
| Boucle d'arbitrage infinie | Coût exponentiel, pas de convergence | Max 2 rounds, puis escalation |
| Arbitre = agent en conflit | Biais inévitable | Toujours un agent tiers ou modèle distinct |
| Résolution sans logging | Aucun apprentissage possible | Logger systématiquement, même les triviaux |
| Merge aveugle | Produit des incohérences silencieuses | Valider la cohérence du résultat mergé |
| Score de confiance auto-déclaré comme oracle | Les agents sur-évaluent souvent leur confiance | Pondérer avec le win_rate historique |
Adaptation par framework
| Framework | Point d'intégration recommandé |
|---|
| LangGraph | Node conflict_detector + branches conditionnelles resolve / escalate |
| CrewAI | Task de validation croisée après les tasks parallèles |
| AutoGen | Agent ConflictResolver dans le GroupChat avec rôle d'arbitre |
| Custom asyncio | Middleware de comparaison après asyncio.gather(*agent_tasks) |
| LangChain LCEL | Branche RunnableBranch avec condition de conflit |
Règles non négociables
- Détection systématique — Tout output parallèle passe par la couche de détection. Pas d'exception.
- Déterministe d'abord — Source externe > confiance > autorité > vote > arbitre LLM. Dans cet ordre.
- Arbitre neutre — Jamais un des agents en conflit. Jamais.
- 2 rounds max — Au-delà, l'incertitude est trop haute pour être résolue algorithmiquement.
- Logger tout — Même les conflits résolus en 50 ms par confiance. Le pattern émerge des logs.
