Council

Customization

Before executing, check for user customizations at: ~/.claude/PAI/USER/SKILLCUSTOMIZATIONS/Council/

If this directory exists, load and apply any PREFERENCES.md, configurations, or resources found there. These override default behavior. If the directory does not exist, proceed with skill defaults.

MANDATORY: Voice Notification (REQUIRED BEFORE ANY ACTION)

You MUST send this notification BEFORE doing anything else when this skill is invoked.

1. Send voice notification:

   curl -s -X POST http://localhost:31337/notify \
     -H "Content-Type: application/json" \
     -d '{"message": "Running the WORKFLOWNAME workflow in the Council skill to ACTION"}' \
     > /dev/null 2>&1 &

2. Output text notification:

   Running the **WorkflowName** workflow in the **Council** skill to ACTION...

This is not optional. Execute this curl command immediately upon skill invocation.

Council Skill

Multi-agent debate system where custom-composed agents discuss topics in rounds, respond to each other's points, and surface insights through intellectual friction.

CRITICAL: Custom Agents Only

ALL council members MUST be custom-composed agents created via the Agents skill's ComposeAgent tool (`bun run ~/.claude/skills/Agents/Tools/ComposeAgent.ts`). NEVER use built-in agent types (Architect, Designer, Engineer, PerplexityResearcher, Silas, etc.).

Built-in types are generic and topic-ignorant. Council debates require agents with:

• Domain expertise tailored to the specific debate topic
• Unique voices and personalities via ComposeAgent
• Distinct analytical approaches that create genuine friction

See CouncilMembers.md for full agent composition instructions.

Key Differentiator from RedTeam: Council is collaborative-adversarial (debate to find best path), while RedTeam is purely adversarial (attack the idea). Council produces visible conversation transcripts; RedTeam produces steelman + counter-argument.

Workflow Routing

Route to the appropriate workflow based on the request.

Quick Reference

Context Files

Core Philosophy

Origin: Best decisions emerge from diverse perspectives challenging each other. Not just collecting opinions - genuine intellectual friction where domain-specific experts respond to each other's actual points.

Agents: Every council uses custom-composed agents via the Agents skill. This gives each member a unique voice, personality, and domain expertise tailored to the topic. Generic built-in agents produce generic debate. Custom agents produce sharp, informed debate.

Speed: Parallel execution within rounds, sequential between rounds. A 3-round debate of 4 agents = 12 agent calls but only 3 sequential waits. Complete in 40-90 seconds.

Examples

"Council: Should we use WebSockets or SSE?"
-> Compose 4 custom agents with relevant traits (real-time, frontend, ops, research)
-> DEBATE workflow -> 3-round transcript

"Quick council check: Is this API design reasonable?"
-> Compose 4 custom agents with API-relevant traits
-> QUICK workflow -> Fast perspectives

"Council: Is AI overhyped?"
-> Compose agents: AI builder, security skeptic, pragmatic engineer, evidence analyst
-> DEBATE workflow -> 3-round transcript

Integration

Depends on:

• Agents skill - ComposeAgent tool for creating all council members

Works well with:

• RedTeam - Pure adversarial attack after collaborative discussion
• Research - Gather context before convening the council

Best Practices

1. Use QUICK for sanity checks, DEBATE for important decisions 2. Design agent traits around the specific topic, not generic roles 3. Review the transcript - insights are in the responses, not just positions 4. Trust multi-agent convergence when it occurs 5. NEVER use built-in agent types — ALWAYS use ComposeAgent

---

Last Updated: 2026-03-18

Gotchas

• Council uses the Agents skill (ComposeAgent) for custom agents — NOT built-in agent types. Never use Designer, Architect, etc. for Council debates.
• Debates need genuine disagreement to be valuable. If all agents agree, the topic may not warrant Council.
• More agents ≠ better debate. 4-6 well-composed agents outperform 12 generic ones.

Execution Log

After completing any workflow, append a single JSONL entry:

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"Council","workflow":"WORKFLOW_USED","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl

Replace WORKFLOW_USED with the workflow executed, 8_WORD_SUMMARY with a brief input description, and SECONDS with approximate wall-clock time. Log status: "error" if the workflow failed.

Council Members

Council members are ALWAYS custom-composed agents created via the Agents skill's ComposeAgent tool. They are NEVER built-in agent types.

CRITICAL: No Built-In Agent Types

NEVER use built-in agent types (Architect, Designer, Engineer, PerplexityResearcher, Silas, etc.) for council members. Built-in types are generic — they have no knowledge of the debate topic and produce shallow, generic perspectives.

Council members MUST be composed using ComposeAgent with topic-specific traits so they have:

• Unique personalities and voices matched to the debate
• Domain expertise relevant to the specific topic
• Distinct analytical approaches that create genuine friction

How to Create Council Members

Step 1: Analyze the Topic

Before composing agents, determine what perspectives would create the most productive friction for THIS specific debate. Don't use generic roles — design roles around the topic.

Example — "Should we use WebSockets or SSE?"

• Agent 1: Real-time systems architect (traits: technical,analytical,systematic)
• Agent 2: Frontend DX advocate (traits: ux,enthusiastic,pragmatic)
• Agent 3: Ops/reliability skeptic (traits: technical,skeptical,cautious)
• Agent 4: Industry researcher (traits: research,comparative,thorough)

Example — "Is AI overhyped?"

• Agent 1: AI infrastructure builder (traits: technical,enthusiastic,systematic)
• Agent 2: Security practitioner skeptic (traits: security,skeptical,meticulous)
• Agent 3: Pragmatic engineer (traits: technical,pragmatic,analytical)
• Agent 4: Evidence-based researcher (traits: research,analytical,comparative)

Step 2: Compose Each Agent via ComposeAgent

bun run ~/.claude/skills/Agents/Tools/ComposeAgent.ts \
  --traits "technical,analytical,systematic" \
  --task "Debate: Should we use WebSockets or SSE?" \
  --output json

Each call returns: name, voice, voice_id, color, traits, and a full prompt with unique personality.

Step 3: Launch with general-purpose

ALWAYS use `subagent_type: "general-purpose"` — NEVER use static types.

Agent({
  description: "Council member 1 - systems architect",
  prompt: <composedAgentPrompt + round instructions + topic context>,
  subagent_type: "general-purpose",
  model: "sonnet"
})

Default Perspective Slots

When the user doesn't specify council members, compose 4 agents covering these perspective types (but with topic-specific traits):

The specific traits should be tailored to the topic, not generic.

Anti-Patterns

Output Format

Standard format for council debate transcripts.

CRITICAL: Custom Agents Only

All council members are custom-composed via ComposeAgent. Agent names and trait descriptions come from the ComposeAgent output. NEVER use generic labels like "Architect" or "Designer" — use the actual composed agent names.

Full Debate Transcript

## Council Debate: [Topic]

**Council Members:** [Composed agent names with trait summaries]

### Round 1: Initial Positions

**[Agent 1 Name] ([trait summary]):**
[Position from their specialized perspective]

**[Agent 2 Name] ([trait summary]):**
[Position from their specialized perspective]

**[Agent 3 Name] ([trait summary]):**
[Position from their specialized perspective]

**[Agent 4 Name] ([trait summary]):**
[Position from their specialized perspective]

### Round 2: Responses & Challenges

**[Agent 1 Name]:**
[Responds to specific points from Round 1]

**[Agent 2 Name]:**
[Responds to specific points from Round 1]

[...]

### Round 3: Synthesis

**[Agent 1 Name]:**
[Final position, areas of agreement/disagreement]

[...]

### Council Synthesis

**Areas of Convergence:**
- [Points where multiple agents agreed]

**Remaining Disagreements:**
- [Points still contested]

**Recommended Path:**
[Synthesized recommendation]

Quick Council Format

## Quick Council: [Topic]

### Perspectives

**[Agent 1 Name] ([traits]):**
[Brief take - 30-50 words]

**[Agent 2 Name] ([traits]):**
[Brief take]

[...]

### Quick Summary

**Consensus:** [Do they agree? On what?]
**Concerns:** [Red flags raised?]
**Recommendation:** [Proceed / Reconsider / Need full debate]

Output Requirements

• Length: 100-150 words per agent per round (debate), 30-50 words (quick)
• Tone: Professional but direct; genuine challenges
• Must Include: Specific references to other agents' points in Round 2+
• Must Avoid: Generic opinions, restating initial position without engagement
• Agent Names: Use actual ComposeAgent names, never generic built-in type labels

Round Structure

How council debates progress through rounds.

CRITICAL: Custom Agents Only

All council members are custom-composed via the Agents skill's ComposeAgent. NEVER use built-in agent types. See CouncilMembers.md.

Three-Round Debate Structure

Round 1 - Initial Positions

Each custom-composed agent gives their take from their specialized perspective. No interaction yet - just establishing positions.

Goal: Surface diverse viewpoints before interaction.

Round 2 - Responses & Challenges

Each agent reads Round 1 transcript and responds to specific points:

• "I disagree with [Agent Name]'s point about X because..."
• "Building on [Agent Name]'s concern about Y..."

Goal: Genuine intellectual friction through direct engagement.

Round 3 - Synthesis & Convergence

Each agent identifies:

• Where the council agrees
• Where they still disagree
• Their final recommendation given the full discussion

Goal: Surface convergence and remaining tensions honestly.

The Value Is In Interaction

Not just collecting opinions - genuine challenges where custom agents with domain-specific knowledge push back on each other's actual points with informed perspectives.

Timing

Total: 40-90 seconds for full debate

Debate Workflow

Full structured multi-agent debate with 3 rounds and visible transcript.

Voice Notification

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the Debate workflow in the Council skill to run multi-agent debate"}' \
  > /dev/null 2>&1 &

Running the Debate workflow in the Council skill to run multi-agent debate...

Prerequisites

• Topic or question to debate
• Optional: Custom council member descriptions (otherwise auto-composed)

CRITICAL: Agent Composition

ALL council members MUST be custom-composed agents via the Agents skill's ComposeAgent tool. NEVER use built-in agent types (Architect, Designer, Engineer, PerplexityResearcher, Silas, etc.).

Built-in types are generic and topic-ignorant. Council debates require agents with domain-specific knowledge, unique voices, and distinct analytical approaches tailored to the debate topic.

See CouncilMembers.md for full instructions on composing agents.

Execution

Step 0: Compose Council Members

Before any debate rounds, compose 4 custom agents tailored to the topic using ComposeAgent:

# Analyze the topic and determine what perspectives create productive friction
# Then compose each agent with topic-specific traits:

bun run ~/.claude/skills/Agents/Tools/ComposeAgent.ts \
  --traits "[domain],enthusiastic,systematic" \
  --task "[debate topic]" \
  --output json

bun run ~/.claude/skills/Agents/Tools/ComposeAgent.ts \
  --traits "[domain],skeptical,meticulous" \
  --task "[debate topic]" \
  --output json

bun run ~/.claude/skills/Agents/Tools/ComposeAgent.ts \
  --traits "[domain],pragmatic,analytical" \
  --task "[debate topic]" \
  --output json

bun run ~/.claude/skills/Agents/Tools/ComposeAgent.ts \
  --traits "research,analytical,comparative" \
  --task "[debate topic]" \
  --output json

Each agent gets a unique name, voice, voice_id, color, and personality prompt.

Step 1: Announce the Council

Output the debate header with the composed agent names:

## Council Debate: [Topic]

**Council Members:** [List composed agent names with their trait descriptions]
**Rounds:** 3 (Positions -> Responses -> Synthesis)

Step 2: Round 1 - Initial Positions

Launch 4 parallel Agent calls (one per composed council member).

CRITICAL: Use `subagent_type: "general-purpose"` for ALL agents. NEVER use built-in types.

Each agent prompt includes the composed agent's full prompt PLUS:

COUNCIL DEBATE - ROUND 1: INITIAL POSITIONS

Topic: [The topic being debated]

[Full topic context — include relevant background, data, quotes, etc. that the agent needs to form an informed opinion]

Give your initial position on this topic from your specialized perspective.
- Speak in first person as your character
- Be specific and substantive (100-150 words)
- State your key concern, recommendation, or insight
- You'll respond to other council members in Round 2

Output each response as it completes:

### Round 1: Initial Positions

**[Agent 1 Name] ([trait description]):**
[Response]

**[Agent 2 Name] ([trait description]):**
[Response]

**[Agent 3 Name] ([trait description]):**
[Response]

**[Agent 4 Name] ([trait description]):**
[Response]

Step 3: Round 2 - Responses & Challenges

Launch 4 parallel Agent calls with Round 1 transcript included.

Each agent prompt includes the composed agent's full prompt PLUS:

COUNCIL DEBATE - ROUND 2: RESPONSES & CHALLENGES

Topic: [The topic being debated]

Here's what the council said in Round 1:
[Full Round 1 transcript]

Now respond to the other council members:
- Reference specific points they made ("I disagree with [Name]'s point about X...")
- Challenge assumptions or add nuance
- Build on points you agree with
- Maintain your specialized perspective
- 100-150 words

The value is in genuine intellectual friction -- engage with their actual arguments.

Step 4: Round 3 - Synthesis

Launch 4 parallel Agent calls with Round 1 + Round 2 transcripts.

Each agent prompt includes the composed agent's full prompt PLUS:

COUNCIL DEBATE - ROUND 3: SYNTHESIS

Topic: [The topic being debated]

Full debate transcript so far:
[Round 1 + Round 2 transcripts]

Final synthesis from your perspective:
- Where does the council agree?
- Where do you still disagree with others?
- What's your final recommendation given the full discussion?
- 100-150 words

Be honest about remaining disagreements -- forced consensus is worse than acknowledged tension.

Step 5: Council Synthesis

After all rounds complete, synthesize the debate:

### Council Synthesis

**Areas of Convergence:**
- [Points where 3+ agents agreed]
- [Shared concerns or recommendations]

**Remaining Disagreements:**
- [Points still contested between agents]
- [Trade-offs that couldn't be resolved]

**Recommended Path:**
[Based on convergence and weight of arguments, the recommended approach is...]

Timing

• Agent Composition: ~5-10 seconds (4 ComposeAgent calls)
• Round 1: ~10-20 seconds (parallel)
• Round 2: ~10-20 seconds (parallel)
• Round 3: ~10-20 seconds (parallel)
• Synthesis: ~5 seconds

Total: 40-90 seconds for full debate

Done

Debate complete. The transcript shows the full intellectual journey from initial positions through challenges to synthesis.

Quick Workflow

Fast single-round perspective check. Use for sanity checks and quick feedback.

Voice Notification

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the Quick workflow in the Council skill to get fast perspectives"}' \
  > /dev/null 2>&1 &

Running the Quick workflow in the Council skill to get fast perspectives...

Prerequisites

• Topic or question to evaluate
• Optional: Custom council members

CRITICAL: Agent Composition

ALL council members MUST be custom-composed agents via the Agents skill's ComposeAgent tool. NEVER use built-in agent types (Architect, Designer, Engineer, PerplexityResearcher, Silas, etc.).

See CouncilMembers.md for full instructions.

Execution

Step 1: Compose & Announce Quick Council

Compose 4 agents with topic-specific traits via ComposeAgent, then announce:

## Quick Council: [Topic]

**Council Members:** [List composed agent names]
**Mode:** Single round (fast perspectives)

Step 2: Parallel Perspective Gathering

Launch all council members in parallel using subagent_type: "general-purpose".

Each agent prompt includes the composed agent's full prompt PLUS:

QUICK COUNCIL CHECK

Topic: [The topic]

[Relevant context for the topic]

Give your immediate take from your specialized perspective:
- Key concern, insight, or recommendation
- 30-50 words max
- Be direct and specific

This is a quick sanity check, not a full debate.

Step 3: Output Perspectives

### Perspectives

**[Agent 1 Name] ([traits]):**
[Brief take]

**[Agent 2 Name] ([traits]):**
[Brief take]

**[Agent 3 Name] ([traits]):**
[Brief take]

**[Agent 4 Name] ([traits]):**
[Brief take]

### Quick Summary

**Consensus:** [Do they generally agree? On what?]
**Concerns:** [Any red flags raised?]
**Recommendation:** [Proceed / Reconsider / Need full debate]

When to Escalate

If the quick check reveals significant disagreement or complex trade-offs, recommend:

This topic has enough complexity for a full council debate.
Run: "Council: [topic]" for 3-round structured discussion.

Timing

• Total: 15-30 seconds (composition + single parallel round)

Done

Quick perspectives gathered. Use for fast validation; escalate to DEBATE for complex decisions.