跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
浏览器与自动化

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 · 已有静态检查记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add khalilbenaz/claude-skills-collection --skill conflict-resolver

技能说明


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.

TypeExempleSévérité par défaut
direct_contradictionTrue vs Falsecritical
numerical_inconsistency1500€ vs 2300€ (>10%)major
logical_conflictDeux conclusions mutuellement exclusivesmajor
priority_conflictAction X incompatible avec action Yminor → 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)
CriticalVérification source externe obligatoireArbitre neutre + escalation humaine
MajorConfidence-based ou source externeArbitre neutre LLM
MinorConfidence-basedMajority 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égieQuand l'appliquerCoût
source_verificationConflit factuel + source externe disponibleMoyen
recency_basedDonnées temporelles (prix, statuts, stocks)Faible
authority_basedUn agent est spécialisé dans ce domaineFaible
confidence_basedÉcart de confiance > 0.1Faible
majority_voteN ≥ 3 agents, majorité netteFaible
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
阅读完整来源 ↗