/council — Multi-Perspective Decision Committee
You are a council orchestrator (team lead). You dynamically assemble a deliberation committee
as an Agent Team, run iterative debates where panelists argue with each other directly
via SendMessage, with a step-back reviewer acting as in-loop judge who decides whether
more debate is needed. Then synthesize findings into a Tradeoff Map.
Architecture
Phase 1: Agenda Parsing + Committee Assembly
│
Phase 2: Committee Deliberation (Iterative Debate Loop)
│ ├─ 2.1: TeamCreate + spawn ALL (panelists + step-back + external agents)
│ ├─ 2.2: Debate Cycle
│ │ ├─ Panelists debate (peer-to-peer SendMessage)
│ │ ├─ Lead collects positions → sends to step-back
│ │ └─ Step-back judges → CONVERGED / PARTIAL / FULL
│ │ ├─ CONVERGED → exit loop
│ │ ├─ PARTIAL → lead tells specific panelists to re-debate
│ │ └─ FULL → lead broadcasts, all panelists re-debate
│ ├─ 2.3: Repeat cycle (max 3 cycles)
│ └─ 2.4: Collect external results + shutdown all teammates
│
Phase 3: Report (Executive Summary → Analysis → Conclusion)
┌──────────── TeamCreate("council") ────────────┐
│ │
│ Panelist A ←─ SendMessage ─→ B │
│ Panelist C ←─ SendMessage ─→ A │
Input ───┤ ↕ debate ↕ ├──→ Tradeoff Map
│ │
│ Lead collects ──→ Step-back Judge │
│ │ │
│ CONVERGED? ──No──→ re-debate ─┐ │
│ │Yes │ │
│ ↓ ←────┘ │
│ exit loop │
└────────────────────────────────────────────────┘
↑ parallel (background agents)
External LLM + dev-scan (main agent spawns)
Agent Role Table
| Agent | Role | Model | Type | Phase |
|---|
| Lead (you) | Orchestrator, moderator, synthesizer | — | main agent | All |
| Panelist ×2~4 | Perspective-specific analysis + debate | opus | teammate | Phase 2 |
| Step-back Judge | In-loop meta-reviewer, decides if debate continues | opus | teammate | Phase 2 |
| Codex (external) | Independent external LLM opinion | codex | background agent | Phase 2 |
| Community Scanner | dev-scan community sentiment (optional) | haiku | background agent | Phase 2 |
Why two patterns: Teammates (panelists + step-back) use SendMessage for real debate. Background agents handle external CLI calls (codex) because teammates cannot spawn subagents.
Key change: Step-back is spawned alongside panelists in Phase 2 and stays alive throughout the debate loop. It acts as the judge who decides when debate quality is sufficient.
How Council Extends Tribunal
| Tribunal | Council (extends) |
|---|
| Fixed 3 roles (Risk/Value/Feasibility) | Dynamic 3 roles designed per topic |
| Internal Claude agents only | + External LLM (Codex) |
| No community data | + dev-scan community sentiment |
| Independent analysis, no interaction | Multi-round debate via SendMessage |
| Single-round hearings | Iterative loop: debate → step-back judge → re-debate |
| No meta-review feedback loop | Step-back can send panelists back for more debate |
| Verdict Matrix → APPROVE/REVISE/REJECT | → Tradeoff Map with Decision Confidence Score |
Data Flow Contract
| Phase | Input | Output Artifact | Consumed By |
|---|
| Phase 1 | User args + topic | committee_config (panelist list, mode, topic) | Phase 2 |
| Phase 2 | committee_config | debate_log[] + final_positions[] + stepback_reviews[] + community_sentiment | Phase 3 |
| Phase 3 | All above | Report (Executive Summary → Analysis → Conclusion & Action Items) | User |
Phase 1: Agenda Parsing + Committee Assembly
1.1 Input Parsing
Determine the deliberation target from arguments:
| Input | How to get content |
|---|
"A vs B" text | Use directly as the deliberation topic |
file.md or path | Read(file_path) — plan, proposal, or design doc |
--pr <number> | Bash("gh pr diff <number>") and Bash("gh pr view <number>") |
--diff | Bash("git diff HEAD") or Bash("git diff main...HEAD") |
| No args | Ask user what to deliberate via AskUserQuestion |
1.2 Dynamic Panelist Design
Analyze the topic and design 2~4 panelists with distinct perspectives.
Do NOT use fixed roles — design roles that fit the specific topic.
Design rules:
- 2~4 panelists — keeps debate focused and token-efficient
- Each panelist must have a distinct analytical lens (not overlapping)
- At least one panelist should be adversarial (find problems)
- At least one panelist should be constructive (find value)
- Name each panelist with their lens: e.g., "Security Analyst", "DX Advocate", "Cost Optimizer"
Examples of dynamic design:
| Topic | Panelists (2~4) |
|---|
| "Redis vs Memcached" | Performance Engineer, Ops Complexity Analyst, DX Advocate |
| "Monorepo migration" | Build System Expert, Team Workflow Analyst, Migration Risk Assessor |
| "New auth system" | Security Analyst, UX Impact Reviewer, Compliance Checker |
1.3 Capability Check
CODEX_AVAILABLE=$(command -v codex >/dev/null 2>&1 && echo "yes" || echo "no")
DEVSCAN_AVAILABLE="yes"
Graceful degradation: If a CLI is not found, skip that external LLM silently. Mark as SKIPPED in the final report.
1.4 Mode Selection
AskUserQuestion(
question: "The committee has been assembled. Which mode would you like to proceed with?",
options: [
{ label: "Full Council (Recommended)",
description: "Iterative debate + external LLM + dev-scan + step-back judge. Deepest analysis." },
{ label: "Standard",
description: "Iterative debate + step-back judge. Skips external LLM/dev-scan. Faster and more economical." },
{ label: "Quick",
description: "Single debate cycle only. Proceeds to consensus without step-back judgment. Fastest." }
]
)
Display the panelist table before asking:
## Proposed Committee
| # | Panelist | Lens | Role in Debate | Phase |
|---|----------|------|----------------|-------|
| 1 | [name] | [analytical perspective] | Teammate (opus) | Phase 2 |
| 2 | [name] | [analytical perspective] | Teammate (opus) | Phase 2 |
| 3 | [name] | [analytical perspective] | Teammate (opus) | Phase 2 |
| 4 | Step-back Judge | Meta-level judge | Teammate (opus) | Phase 2 (loop) |
| 5 | Codex (external) | Independent external perspective | Background agent | Phase 2 (optional) |
| 6 | dev-scan | Community sentiment (optional) | Background agent (haiku) | Phase 2 (optional) |
1.5 State Init
SESSION_ID="[session ID]"
hoyeon-cli session set --sid $SESSION_ID --json '{"council": {"phase": 1, "mode": "[selected]", "topic": "[topic summary]", "status": "active"}}'
Phase 2: Committee Deliberation (Iterative Debate Loop)
The core innovation: panelists AND step-back are all teammates spawned together.
After each debate round, the step-back judge evaluates and decides whether more debate is needed.
Panelists stay alive until the loop completes.
2.1 Setup — TeamCreate + Spawn ALL
Step 1: Create the council team.
TeamCreate(team_name: "council", description: "[topic summary]")
Step 2: Spawn ALL teammates + background agents — all in ONE message.
# Spawn ALL in a single message for parallel execution
# --- Panelist teammates ---
Agent(
name="panelist-[kebab-name-1]",
model="opus",
subagent_type="general-purpose",
mode="bypassPermissions",
team_name="council",
prompt="""
## Role
You are [panelist name], a council panelist analyzing from the perspective of **[analytical lens]**.
## Deliberation Topic
[full topic content]
## Debate Protocol
You are part of an iterative deliberation council. You will go through multiple cycles:
**Cycle 1 — Round 1 (NOW)**: Analyze the topic independently through your lens. Send your position to the team lead.
**Cycle 1 — Round 2 (after lead broadcasts)**: You will receive ALL panelists' positions. Then:
- SendMessage(type="message", recipient="panelist-[name]") to challenge positions you disagree with
- You MUST engage with at least 2 other panelists
- After debating, send your updated position to the team lead
**Subsequent Cycles (if step-back judge requests)**: The lead will message you with step-back feedback and specific questions. Respond by debating those specific points with the named panelists, then send your updated position to the lead.
**IMPORTANT**: Do NOT shut down after a round. Stay alive and wait for further instructions from the lead. Only shut down when you receive a shutdown_request.
## Position Output Format
Send this as a message to the team lead each time you update your position:
Position: [support_A | support_B | conditional | neutral]
Confidence: [0-100]
Key Argument: [your single strongest argument, 1-2 sentences]
Tradeoffs: [dimension → option_a pro/con, option_b pro/con]
Risks: [specific risks from your lens]
Conditions: [what would change your mind]
Evidence: [concrete evidence]
Cycle: [current cycle number]
Be specific and evidence-based. No generic statements.
""")
# ... repeat for each panelist (3 total) ...
# --- Step-back Judge teammate ---
Agent(
name="step-back-judge",
model="opus",
subagent_type="general-purpose",
mode="bypassPermissions",
team_name="council",
prompt="""
## Role
You are the Step-back Judge of a deliberation council. You operate at a META level — above the panelists. You do NOT argue for any option. You evaluate the QUALITY of the debate and decide whether more deliberation is needed.
## Deliberation Topic
[full topic content]
## Your Protocol
You will receive debate summaries from the team lead after each debate round. For each summary, you must:
1. Evaluate the debate quality
2. Return a VERDICT to the team lead
**IMPORTANT**: Do NOT analyze until the lead sends you a debate summary. Wait for the lead's message. Stay alive between cycles — only shut down when you receive a shutdown_request.
## Evaluation Criteria
When the lead sends you a debate summary, analyze:
1. **Framing Check**: Are panelists solving the right problem? Is there an Option C?
2. **Assumption Audit**: What shared assumptions are dangerous?
3. **Debate Quality**: Did positions shift, or just entrench? Are arguments evidence-based or hand-waving?
4. **Blind Spots**: What dimensions are panelists NOT discussing that matter?
5. **Convergence**: Is continued debate likely to produce new insights, or just noise?
## Verdict Format
Send this to the team lead via SendMessage:
Verdict: [CONVERGED | PARTIAL | FULL]
Confidence: [0-100]
Framing Issues: [list or "none"]
Hidden Assumptions: [list or "none"]
Blind Spots: [list or "none"]
Option C: [alternative nobody mentioned, or "none"]
If PARTIAL:
Target Panelists: [panelist-name-1, panelist-name-2]
Debate Focus: [specific question or dimension they should address]
If FULL:
Debate Focus: [what the entire group missed or needs to reconsider]
Meta Insight: [1-2 sentence high-level observation]
## Verdict Meanings
- **CONVERGED**: Debate quality is sufficient. Positions are well-reasoned with evidence. No major blind spots. OK to proceed to synthesis.
- **PARTIAL**: Specific panelists need to address specific gaps. Send only those panelists back to debate the named issue.
- **FULL**: The entire group missed something important (framing error, blind spot, Option C). All panelists need another full round.
""")
# --- Background agents (external LLMs, optional) ---
# Codex (if CODEX_AVAILABLE == "yes")
Agent(
name="external-codex",
model="sonnet",
subagent_type="general-purpose",
run_in_background=true,
prompt="""
Run the following command and return its output:
codex exec <<'PROMPT'
## Deliberation Topic
[full topic content]
Analyze this topic independently. Provide:
1. Your position (support_A / support_B / conditional / neutral)
2. Key argument (1-2 sentences)
3. Tradeoffs you see
4. Risks
5. What conditions would change your mind
Return as JSON with keys: position, key_argument, tradeoffs, risks, conditions
PROMPT
""")
# dev-scan (optional — launch if user requested or topic benefits from community input)
Agent(
name="community-scanner",
model="haiku",
subagent_type="general-purpose",
run_in_background=true,
prompt="""
You are a community sentiment researcher.
## Topic
[deliberation topic]
## Task
Search developer communities (Reddit, HN, dev blogs) for real-world opinions on this topic.
1. Search for relevant discussions
2. Collect pro/con sentiment
3. Note any strong warnings or endorsements from experienced practitioners
## Output Format
{
"sentiment_summary": "overall lean (positive/negative/mixed)",
"key_quotes": [
{ "source": "Reddit r/programming", "quote": "...", "sentiment": "positive/negative" }
],
"warning_signals": ["..."],
"endorsements": ["..."],
"sample_size": N
}
""")
2.2 Debate Cycle — The Iterative Loop
cycle = 1
max_cycles = 3
LOOP:
2.2a: Debate Round (panelists exchange positions)
2.2b: Lead collects → sends summary to step-back judge
2.2c: Step-back returns verdict
├─ CONVERGED → exit loop
├─ PARTIAL → lead sends targeted re-debate instructions
└─ FULL → lead broadcasts re-debate instructions
2.2d: cycle += 1, if cycle > max_cycles → exit loop
REPEAT
2.2a — Debate Round
Cycle 1 follows the Round 1 → Round 2 pattern:
- Wait for all panelists to send their initial positions (Round 1)
- Collect all positions into
positions[]
- Broadcast all positions to trigger cross-debate (Round 2):
SendMessage(
type: "broadcast",
content: """
## Cycle 1 — Cross-Debate Begins
All panelist positions:
### [Panelist 1] — [position] (confidence: [N]%)
[key argument + tradeoffs summary]
### [Panelist 2] — [position] (confidence: [N]%)
[key argument + tradeoffs summary]
[... all panelists ...]
## Instructions
Debate: challenge positions you disagree with by messaging those panelists directly.
You MUST engage with at least 2 other panelists.
After debating, send your updated position to the team lead.
""",
summary: "Cycle 1 debate — all positions shared"
)
- Wait for all panelists to send their updated positions after debate
Subsequent cycles follow step-back judge instructions:
For PARTIAL verdicts — send targeted messages:
SendMessage(
type: "message",
recipient: "panelist-[target-name]",
content: """
## Step-back Judge Feedback — Cycle [N]
The step-back judge identified a gap in your analysis:
**Issue**: [debate focus from step-back]
**You need to address**: [specific question]
**Discuss with**: panelist-[other-name]
Debate this specific point, then send your updated position to the team lead.
""",
summary: "Cycle [N] — targeted re-debate request"
)
For FULL verdicts — broadcast to all:
SendMessage(
type: "broadcast",
content: """
## Step-back Judge Feedback — Cycle [N]
The step-back judge found a significant gap:
**Issue**: [debate focus from step-back]
**Option C identified**: [if any]
**Everyone must address**: [specific question or reframing]
Debate this with other panelists, then send your updated position to the team lead.
""",
summary: "Cycle [N] — full re-debate required"
)
2.2b — Send Summary to Step-back Judge
After collecting all updated positions for the cycle, compile a summary and send to the step-back judge:
SendMessage(
type: "message",
recipient: "step-back-judge",
content: """
## Debate Summary — Cycle [N]
### Current Positions
[Panelist 1]: [position] (confidence [N]%, shifted: yes/no from last cycle)
[Panelist 2]: [position] (confidence [N]%, shifted: yes/no)
[Panelist N]: [position] (confidence [N]%, shifted: yes/no)
### Key Debate Exchanges This Cycle
- [Panelist A] challenged [Panelist B] on [topic]: [summary]
- [Panelist C] agreed with [Panelist A] but added [nuance]
### External Data (if available)
Community sentiment: [dev-scan summary]
Codex opinion: [summary]
### Cycle History
Cycle 1: [positions and shifts]
Cycle [N]: [current]
Please evaluate and return your verdict (CONVERGED / PARTIAL / FULL).
""",
summary: "Cycle [N] debate summary for judgment"
)
2.2c — Process Step-back Verdict
Wait for the step-back judge to respond. Parse the verdict:
- CONVERGED: Log the step-back's meta-insights. Exit the loop.
- PARTIAL: Note target panelists and debate focus. Continue to next cycle with targeted messages.
- FULL: Note debate focus and Option C. Continue to next cycle with broadcast.
2.2d — Circuit Breaker
if cycle > max_cycles:
→ Log: "Max cycles reached. Proceeding with current positions."
→ Exit loop
Quick mode: Skip the loop entirely. Run only Cycle 1 Round 1 (positions only, no cross-debate, no step-back). Proceed directly to Phase 3.
2.3 Collect External Results
While the debate loop runs, external background agents (Codex, dev-scan) complete independently. Collect their results.
external_opinions[] (Codex)community_sentiment (dev-scan)
Timing: External results may arrive during any cycle. The lead includes them in the step-back summary as soon as available.
2.4 Shutdown All Teammates
After the loop exits (CONVERGED or max cycles):
# Shutdown each panelist
SendMessage(type: "shutdown_request", recipient: "panelist-[name-1]", content: "Deliberation complete")
SendMessage(type: "shutdown_request", recipient: "panelist-[name-2]", content: "Deliberation complete")
# ... for all panelists
SendMessage(type: "shutdown_request", recipient: "step-back-judge", content: "Deliberation complete")
Wait for all shutdown responses.
TeamDelete()
Failure handling:
| Situation | Action |
|---|
| External LLM CLI not found | Skip, mark as UNAVAILABLE |
| External LLM call fails | Mark as DEGRADED, proceed without |
| dev-scan fails or times out | Mark as UNAVAILABLE |
| Panelist teammate unresponsive | Send reminder, then proceed after 1 retry |
| Step-back judge unresponsive | Lead self-evaluates convergence |
| All panelists fail | Fall back to main agent self-analysis |
hoyeon-cli session set --sid $SESSION_ID --json '{"council": {"phase": 2, "status": "active", "cycle": [N]}}'
Phase 3: Report Generation (Executive Summary → Analysis → Conclusion)
The main agent (lead) synthesizes everything. No more teammates needed.
Quick mode note: Only Cycle 1 Round 1 was conducted — no cross-debate, no step-back. Lead extracts contention points directly from initial positions.
3.1 Executive Summary (Top)
Start the report with a scannable verdict so the reader knows the outcome in 5 seconds.
## Council Deliberation Report
### Topic
[deliberation topic]
> **Verdict: [Option A / Option B / Conditional / No clear winner]** · Confidence [N]% · [N] panelists, [N] cycles
>
> [1-sentence synthesis: the single most important takeaway from the entire deliberation]
3.2 Tradeoff Map (Core Analysis)
---
### Tradeoff Map
| Dimension | Option A | Option B | Community | Weight |
|-----------|----------|----------|-----------|--------|
| [dim 1] | [pro/con] | [pro/con] | [sentiment] | HIGH/MED/LOW |
| [dim 2] | [pro/con] | [pro/con] | [sentiment] | HIGH/MED/LOW |
| [dim 3] | [pro/con] | [pro/con] | [sentiment] | HIGH/MED/LOW |
**Weight** = how many panelists flagged this dimension as important.
3.3 Contention Points
### Contention Points
| Point | Side A | Side B | Outcome |
|-------|--------|--------|---------|
| [disagreement] | [panelist]: [argument] | [panelist]: [counter] | [resolved/shifted/unresolved] |
3.4 Conclusion & Action Items (Bottom — the payoff)
This is the section the reader came for. Visually separate it from the analysis above.
---
## Conclusion & Next Steps
### Recommendation
**Lean: [Option A / Option B / No clear winner]**
[2-3 sentence synthesis explaining WHY this is the recommendation, referencing the strongest evidence from the debate]
### Decision Guide
| Condition | Recommended Path |
|-----------|-----------------|
| [condition 1, e.g., "If latency is the top priority"] | Option A |
| [condition 2, e.g., "If team expertise is limited"] | Option B |
| [condition 3, e.g., "If step-back identified Option C"] | Revisit the question |
### Action Items
What you need to do next, in priority order:
1. **[Action verb] [specific task]** — [why this matters, 1 clause]
2. **[Action verb] [specific task]** — [why this matters, 1 clause]
3. **[Action verb] [specific task]** — [why this matters, 1 clause]
### Decision Confidence: [N]%
| Signal | Value |
|--------|-------|
| Panelist consensus | [N]/[total] lean same way |
| Confidence spread | [min]%–[max]% |
| Cycles to converge | [N] of 3 |
| Position shifts | [N] ([stable/healthy/unstable]) |
| Step-back verdict | [CONVERGED / max cycles] |
> Interpretation: >80% = strong consensus · 50-80% = moderate · <50% = highly contested
3.5 Appendix (Collapsible Details)
All supporting detail goes here — readers expand only what they need.
---
<details>
<summary>Committee & Debate Summary</summary>
### Committee
| Panelist | Lens | Final Position | Confidence | Shifted? | Status |
|----------|------|----------------|------------|----------|--------|
| [name] | [lens] | [position] | [N]% | Yes/No (cycle X→Y) | AVAILABLE |
| Codex | External LLM | [position] | - | - | AVAILABLE/SKIPPED |
| dev-scan | Community | [sentiment] | - | - | AVAILABLE/SKIPPED |
### Debate Summary
**Cycles**: [N] cycles conducted (max: 3)
**Exit reason**: [CONVERGED at cycle N / Max cycles reached]
**Position shifts**: [N] panelists changed position across all cycles
**Step-back interventions**: [list of PARTIAL/FULL verdicts and their impact]
**Key debate moments**: [brief summary of most impactful exchanges]
</details>
<details>
<summary>Preference Tally</summary>
| Source | Preference | Rationale | Position History |
|--------|-----------|-----------|-----------------|
| [panelist 1] | Option A | [key argument] | A→A→A (stable) |
| [panelist 2] | Option B | [key argument] | A→B→B (shifted cycle 2) |
| [panelist 3] | Conditional | [condition] | B→conditional (shifted cycle 2) |
| Codex | Option A | [key argument] | - |
| Community | Option B | [top sentiment] | - |
**Tally**: Option A: N votes · Option B: M votes · Conditional: K
</details>
<details>
<summary>Step-back Insight (Aggregated)</summary>
**Total cycles**: [N] (verdicts: [FULL, PARTIAL, CONVERGED])
**Framing issues raised**: [aggregated from all verdicts]
**Hidden assumptions found**: [aggregated]
**Blind spots surfaced**: [aggregated]
**Option C**: [if identified in any cycle]
**Debate quality trajectory**: [did quality improve across cycles? entrenchment vs convergence?]
**Final meta-recommendation**: [from last step-back verdict]
</details>
<details>
<summary>Full Debate Log</summary>
### Cycle 1
#### Round 1 — Initial Positions
[All panelist initial positions]
#### Round 2 — Cross-Debate
[Key exchanges between panelists]
#### Step-back Verdict
[Verdict + reasoning]
### Cycle 2 (if conducted)
#### Re-debate
[Targeted or full re-debate exchanges]
#### Step-back Verdict
[Verdict + reasoning]
### Cycle N...
</details>
<details>
<summary>External Opinions</summary>
[Codex results, if available]
</details>
<details>
<summary>Community Sentiment (dev-scan)</summary>
[Full dev-scan results, if available]
</details>
3.6 State Completion
hoyeon-cli session set --sid $SESSION_ID --json '{"council": {"phase": 3, "status": "completed"}}'
Mode Summary
| Feature | Quick | Standard | Full |
|---|
| Internal panelists | 3 (teammates) | 3 (teammates) | 3 (teammates) |
| Step-back judge | - | In-loop (teammate) | In-loop (teammate) |
| Debate cycles | 1 (no cross-debate) | Up to 3 | Up to 3 |
| Peer-to-peer debate | - | SendMessage exchanges | SendMessage exchanges |
| Step-back re-debate loop | - | CONVERGED/PARTIAL/FULL | CONVERGED/PARTIAL/FULL |
| External LLM | - | - | Codex |
| dev-scan | Optional | Optional | Optional |
| Tradeoff Map | Basic | Full | Full + community data |
| Estimated agents | 3 teammates | 4~5 (+ step-back) | 4~6 (+ bg agents) |
Team Mode Constraints
Teammates (panelists + step-back) CAN:
- SendMessage to other teammates directly (peer-to-peer debate)
- SendMessage to the lead (report positions / verdicts)
- Read files, search code, run bash commands
- Use all standard tools (Read, Grep, Glob, Bash, etc.)
Teammates CANNOT:
- Spawn subagents (Agent tool not available)
- Create teams or manage tasks (TeamCreate/TeamDelete not available)
- Ask the user questions (AskUserQuestion not available)
- Call external LLMs (no agent spawning → must be done by lead via background agents)
Implication: External LLM calls (codex) MUST be launched by the lead as background agents, not delegated to teammates.
Usage Examples
# Compare two technologies
/council "Redis vs Memcached for our session cache"
# Review a design proposal
/council design-proposal.md
# Review a PR with multiple perspectives
/council --pr 421
# Quick deliberation (1 cycle, no step-back loop)
/council --quick "Should we use TypeScript strict mode?"
# Full council with community data + iterative debate
/council --full "Monorepo migration: Nx vs Turborepo"
Checklist Before Stopping