consensus-builder
Mécanismes de consensus et de vote entre agents pour prendre des décisions collectives fiables. Se déclenche avec "consensus agent", "vote agents", "décision collective", "agent voting", "multi-agent decision", "majority vote", "agent debate", "agent deliberation". Also triggers on "agent consensus", "majority vote between agents".
khalilbenaz · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add khalilbenaz/claude-skills-collection --skill consensus-builder技能说明
name: consensus-builder description: Mécanismes de consensus et de vote entre agents pour prendre des décisions collectives fiables. Se déclenche avec "consensus agent", "vote agents", "décision collective", "agent voting", "multi-agent decision", "majority vote", "agent debate", "agent deliberation". Also triggers on "agent consensus", "majority vote between agents".
Agent Consensus Builder
Quand utiliser ce skill
| Critère | Utilise le consensus | N'utilise PAS le consensus |
|---|---|---|
| Nature de la question | Incertaine, subjective, multicritère | Factuelle, vérifiable, calculable |
| Conséquences d'erreur | Irréversibles ou coûteuses | Faibles, corrigeables facilement |
| Perspectives | Plusieurs angles utiles (risque, UX, technique) | Un seul expert suffit |
| Latence | Acceptable (>2s) | Critique (<500ms) |
| Budget tokens | Disponible (N × appels) | Contraint |
Règle rapide : si grep -r "answer" knowledge_base trouve la réponse, pas besoin de consensus. Si la décision dépend de valeurs ou de jugement, le consensus ajoute de la valeur.
Workflow en 10 étapes
1. Qualifier la décision
Avant de lancer quoi que ce soit, score la décision sur 3 axes (0–3 chacun) :
def consensus_necessity_score(decision: dict) -> int:
score = 0
if decision["is_reversible"] is False: score += 2
if decision["uncertainty"] == "high": score += 2
if decision["perspectives_needed"] > 1: score += 1
# score >= 3 → consensus justifié
# score < 3 → agent unique suffisant
return score
2. Définir la question et les options AVANT de lancer les agents
Format standard à passer à chaque agent :
CONSENSUS_PROMPT_TEMPLATE = """
Tu es un agent spécialisé en {role}.
Question : {question}
Options disponibles : {options}
Contexte : {context}
Réponds en JSON :
{{
"choice": "<une des options>",
"confidence": <float 0.0-1.0>,
"rationale": "<explication concise>",
"risks": ["<risque 1>", "<risque 2>"]
}}
"""
3. Choisir la méthode de vote
| Méthode | Usage | Quand | Seuil typique |
|---|---|---|---|
| Majority vote | Binaire simple | Décision oui/non | >50% |
| Supermajority | Décision risquée | Rollback, suppression de données | ≥66% |
| Weighted vote | Agents spécialisés | Agent expert > généraliste | Poids définis a priori |
| Confidence-weighted | Agents incertains | Analyse de sentiments, prévisions | Score agrégé |
| Borda count | N > 2 options | Choix d'architecture, priorisation | Premier rang |
from collections import Counter
from typing import Any
def majority_vote(votes: list[str]) -> str:
counts = Counter(votes)
winner, count = counts.most_common(1)[0]
return winner if count > len(votes) / 2 else "no_consensus"
def confidence_weighted_consensus(votes: list[dict[str, Any]]) -> dict:
# votes = [{"choice": "A", "confidence": 0.8}, ...]
scores: dict[str, float] = {}
for v in votes:
scores[v["choice"]] = scores.get(v["choice"], 0) + v["confidence"]
total = sum(scores.values())
normalized = {k: round(v / total, 3) for k, v in scores.items()}
winner = max(normalized, key=normalized.get)
return {"winner": winner, "scores": normalized, "strength": normalized[winner]}
def borda_count(rankings: list[list[str]]) -> str:
# rankings = [["A","B","C"], ["B","A","C"], ...]
n = len(rankings[0])
scores: dict[str, int] = {}
for ranking in rankings:
for i, option in enumerate(ranking):
scores[option] = scores.get(option, 0) + (n - i - 1)
return max(scores, key=scores.get)
4. Assurer la diversité d'opinion (critique)
Sans diversité, le consensus amplifie les biais. Minimum 2 axes de différenciation :
AGENT_CONFIGS = [
{"role": "risk_analyst", "temperature": 0.2, "framing": "Quels sont les risques ?"},
{"role": "optimist", "temperature": 0.7, "framing": "Quels sont les gains potentiels ?"},
{"role": "devils_advocate","temperature": 0.5, "framing": "Pourquoi cette option échouerait-elle ?"},
{"role": "neutral_analyst","temperature": 0.3, "framing": "Évalue objectivement chaque option."},
]
# Règle : jamais 2 agents avec le même role + temperature + framing
5. Lancer les agents en parallèle (Round 1)
import asyncio
async def run_vote(agents: list, question: str, options: list[str]) -> list[dict]:
tasks = [agent.vote(question, options) for agent in agents]
results = await asyncio.gather(*tasks, return_exceptions=True)
# Filtrer les erreurs sans bloquer le vote
valid = [r for r in results if isinstance(r, dict)]
if len(valid) < len(agents) // 2 + 1:
raise RuntimeError("Trop d'agents en échec pour un consensus fiable")
return valid
6. Débat structuré (si no_consensus au Round 1)
3 rounds maximum. Au-delà, pas de valeur ajoutée.
async def run_debate(agents: list, question: str, options: list[str]) -> dict:
# Round 1 : positions initiales (parallèle)
positions = await run_vote(agents, question, options)
# Round 2 : cross-examination (chaque agent voit les autres)
critiques = await asyncio.gather(*[
agent.critique(question, positions, own_idx=i)
for i, agent in enumerate(agents)
])
# Round 3 : vote final avec toutes les informations
final_votes = await asyncio.gather(*[
agent.final_vote(question, options, positions, critiques)
for agent in agents
])
return {"votes": final_votes, "positions": positions, "critiques": critiques}
7. Résoudre les deadlocks
Priorité décroissante :
- Tiebreaker déterministe : option la plus conservatrice/sûre gagne (pas de hasard)
- Moderator agent : agent supplémentaire invoqué avec le dossier complet (temperature=0.0)
- Escalation humaine : présenter les options avec pro/contra à un humain
- Random + logging explicite : dernier recours, jamais silencieux
def resolve_deadlock(
阅读完整来源 ↗