conflict-resolver
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".
khalilbenaz · Static checks on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add khalilbenaz/claude-skills-collection --skill conflict-resolverAbout this skill
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 retourneFalsesur 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 # "direct_contradiction" | "numerical_inconsistency" | "logical_conflict" | "priority_conflict"
severity: str # "critical" | "major" | "minor"
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:
# Détection numérique
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 "minor",
agent_a=agent_a, agent_b=agent_b,
output_a=output_a, output_b=output_b,
description=f"Écart de {diff_pct:.1%} entre {agent_a} et {agent_b}"
)
# Détection booléenne
if isinstance(output_a, bool) and isinstance(output_b, bool) and output_a != output_b:
return ConflictDetectionResult(
has_conflict=True, conflict_type="direct_contradiction", severity="critical",
agent_a=agent_a, agent_b=agent_b, output_a=output_a, output_b=output_b,
description=f"{agent_a} dit {output_a}, {agent_b} dit {output_b}"
)
return ConflictDetectionResult(
has_conflict=False, conflict_type="none", severity="none",
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_sou
Read the complete source ↗