Council

Council is an AI skill that orchestrates multi-agent deliberation for complex decision making, enabling multiple AI perspectives to debate, evaluate, and converge on recommendations. It covers agent role definition, debate structuring, consensus building, dissent tracking, and decision synthesis that produce more thoroughly examined conclusions than single-perspective analysis.

What Is This?

Overview

Council provides frameworks for running structured deliberations among multiple AI agents, each assigned distinct roles and evaluation criteria. It handles defining agent roles with specific expertise and evaluation perspectives, structuring debate rounds where agents present arguments and counterarguments, scoring proposals against each agent's criteria for quantitative comparison, tracking dissenting opinions alongside majority recommendations, synthesizing multi-perspective analysis into actionable recommendations, and documenting the deliberation process for transparency and review.

Who Should Use This

This skill serves architects evaluating technology choices that benefit from multiple perspectives, product teams making prioritization decisions with competing stakeholder interests, risk managers who need thorough examination of potential failure modes, and research teams conducting literature reviews that benefit from diverse analytical angles.

Why Use It?

Problems It Solves

Single perspective analysis misses risks and opportunities that become visible from different viewpoints. Complex decisions involve trade-offs between competing priorities like cost, speed, and quality that no single framework captures completely. Confirmation bias leads analysts to favor evidence supporting their initial hypothesis. Important decisions lack documented rationale showing which alternatives were considered.

Core Highlights

Multi-agent debate surfaces arguments that a single analyst would not generate independently. Role-based evaluation ensures each important perspective has a dedicated advocate. Structured rounds prevent deliberations from becoming unfocused. Dissent tracking preserves minority opinions that may prove valuable if circumstances change.

How to Use It?

Basic Usage

from dataclasses import dataclass, field

@dataclass
class Agent:
    name: str
    role: str
    criteria: list
    arguments: list = field(default_factory=list)

class Council:
    def __init__(self, topic):
        self.topic = topic
        self.agents = []
        self.rounds = []
        self.proposals = []

    def add_agent(self, name, role, criteria):
        agent = Agent(name, role, criteria)
        self.agents.append(agent)
        return agent

    def submit_proposal(self, proposal_name, details):
        self.proposals.append({
            "name": proposal_name,
            "details": details,
            "scores": {}
        })

    def deliberate(self):
        for proposal in self.proposals:
            for agent in self.agents:
                score = self.evaluate(
                    agent, proposal["details"]
                )
                proposal["scores"][agent.name] = score
        return self.synthesize()

    def evaluate(self, agent, details):
        score = sum(
            1 for c in agent.criteria
            if c.lower() in details.lower()
        )
        return score / max(len(agent.criteria), 1) * 10

    def synthesize(self):
        ranked = sorted(
            self.proposals,
            key=lambda p: sum(p["scores"].values()),
            reverse=True
        )
        return ranked

Real-World Examples

class DeliberationRound {
  constructor(roundNumber, proposals) {
    this.round = roundNumber;
    this.proposals = proposals;
    this.arguments = [];
    this.rebuttals = [];
  }

  addArgument(agentName, proposal, position, reasoning) {
    this.arguments.push({
      agent: agentName,
      proposal,
      position,
      reasoning,
      timestamp: new Date().toISOString(),
    });
  }

  addRebuttal(agentName, targetArgument, counterpoint) {
    this.rebuttals.push({
      agent: agentName,
      target: targetArgument,
      counterpoint,
    });
  }

  tally() {
    const votes = {};
    for (const arg of this.arguments) {
      if (!votes[arg.proposal]) {
        votes[arg.proposal] = { support: 0, oppose: 0 };
      }
      if (arg.position === "support") {
        votes[arg.proposal].support++;
      } else {
        votes[arg.proposal].oppose++;
      }
    }
    return votes;
  }

  summary() {
    return {
      round: this.round,
      arguments: this.arguments.length,
      rebuttals: this.rebuttals.length,
      tally: this.tally(),
    };
  }
}

Advanced Tips

Assign at least one agent the explicit role of critic or devil's advocate to ensure proposals face rigorous challenge. Limit deliberation to three rounds to prevent analysis paralysis while still allowing substantive debate. Record the strongest dissenting argument alongside the majority recommendation to inform future reassessment.

When to Use It?

Use Cases

Use Council when evaluating architectural decisions that affect multiple teams or systems, when prioritizing features where different stakeholders have competing interests, when assessing risks that benefit from examination from security, performance, and usability perspectives, or when conducting thorough evaluations of vendor or technology options.

Related Topics

Multi-agent AI systems, structured argumentation frameworks, decision matrices, Delphi method for expert consensus, and architecture decision records complement council based deliberation.

Important Notes

Requirements

A clearly defined decision question that benefits from multiple perspectives. At least three distinct evaluation roles with different criteria sets. Structured proposal descriptions that agents can evaluate against their criteria.

Usage Recommendations

Do: define agent roles to cover genuinely different perspectives rather than overlapping viewpoints. Include quantitative scoring alongside qualitative arguments to enable direct comparison. Document both the winning recommendation and the reasoning behind rejected alternatives.

Don't: use council deliberation for simple decisions where a single analysis suffices. Weight all agent perspectives equally when some criteria are clearly more important for the specific decision. Treat the council output as a final answer without human review of the reasoning.

Limitations

Multi-agent deliberation adds overhead that is not justified for routine decisions. Agent roles are defined by the user, so blind spots in role selection propagate through the analysis. Consensus can converge on a safe middle ground that avoids the best innovative option.