Council System Specification — Deep Panel with Peer Review

Version: 1.0 Date: 2026-03-30 Status: AUTHORITATIVE — replaces old 5-seat Crafter/Panelist/Synthesizer system Command: /council

Overview

The council is a decision-making process for strategic questions. It runs a full deep panel with anonymous peer review every time. There is no quick mode.

Panel Roster (LOCKED — no substitutions)

Seat	Model	Provider	Route
Advisor 1	Claude Opus 4.6	Anthropic	Spawned native, max reasoning
Advisor 2	Claude Sonnet 4.6	Anthropic	Spawned native
Advisor 3	Gemini 3.1 Pro Preview	Google	OpenRouter (`google/gemini-3.1-pro-preview`)
Advisor 4	Grok 4.20 Reasoning	xAI	OpenRouter (`x-ai/grok-4.20-beta`, `reasoning.effort: "high"`)
Advisor 5	gpt-oss-120b	OpenAI	OpenRouter (`openai/gpt-oss-120b`)

Rules:

No model may be substituted without a full council ruling on itself (meta-ruling)
Exact model IDs only — no "latest" aliases, no version upgrades without explicit approval
If a model's API is down, retry 3x. After 3 failures, run with 4 advisors. Never substitute.
All 5 advisors receive identical prompts. No per-advisor customization.
All go COLD every session — no memory, no context from prior councils

Process (5 phases)

Phase 0: Question Crafting

Before the council runs, the chairman (the model the user is talking to) discusses the question with the boss. The chairman helps refine the question — adding context, clarifying scope, identifying what the council needs to rule on. Once the boss approves the final prompt, the chairman sends it to all 5 advisors.

The chairman crafts the prompt but the boss approves it before it fires.

Phase 1: Advisory Round

All 5 advisors receive the approved question simultaneously (parallel calls). Each responds independently.

Advisor prompt template:

You are an advisor on a strategic ruling panel. You are going in COLD — no memory, no knowledge of other advisors. Give your honest, independent analysis.

QUESTION: {user's question}

{any additional context provided}

Give your full analysis and specific recommendations.

Phase 2: Anonymization

The chairman (the model the user is talking to) receives all 5 responses and:

Strips any self-identifying information
Randomly assigns labels: Advisor A, B, C, D, E (shuffled each council)
The mapping is hidden — reviewers cannot know which model produced which response

Phase 3: Peer Review Round

All 5 models are called again (fresh session, cold) as REVIEWERS. Each receives all 5 anonymized advisor responses and answers exactly 3 questions:

Reviewer prompt template:

You are a peer reviewer on a strategic panel. You are reviewing 5 anonymous advisor responses to this question:

QUESTION: {original question}

=== ADVISOR A ===
{anonymized response A}

=== ADVISOR B ===
{anonymized response B}

=== ADVISOR C ===
{anonymized response C}

=== ADVISOR D ===
{anonymized response D}

=== ADVISOR E ===
{anonymized response E}

Answer exactly these 3 questions:

1. STRONGEST RESPONSE: Which advisor's response is strongest and why? What makes their reasoning superior?

2. BIGGEST BLIND SPOT: Which response has the biggest blind spot or flaw? What did they miss or get wrong?

3. WHAT DID ALL FIVE MISS: What important consideration did ALL five advisors fail to address? What angle was nobody looking at?

Be specific. Reference advisor letters. Be critical — agreeing with everyone helps nobody.

Phase 4: Chairman Synthesis

The chairman (whichever model the user is currently talking to) reads:

All 5 original advisor responses
All 5 peer reviews
The anonymization mapping (so it can attribute insights to specific models if useful)

The chairman produces a structured synthesis:

=== COUNCIL RESULTS ===

QUESTION: {original question}

ADVISOR SUMMARY:
- Where advisors agreed: {consensus points}
- Where advisors disagreed: {key divergences}
- Strongest argument: {from peer review}
- Biggest blind spot identified: {from peer review}
- What everyone missed: {from peer review}

DETAILED FINDINGS:
{structured breakdown of key points, attributed to advisor letters}

PEER REVIEW HIGHLIGHTS:
{what the reviewers flagged that changes the picture}

OPEN QUESTIONS FOR DISCUSSION:
{what needs your input before a ruling can be made}

Phase 5: Ruling

The boss reviews the synthesis and makes the final ruling through discussion with the chairman. The chairman does NOT make the ruling — it presents findings and the boss decides.

Technical Implementation

API Calls Per Council (11 total)

Phase	Calls	Models
Advisory	5 parallel	Opus, Sonnet, Gemini, Grok, gpt-oss
Review	5 parallel	Same 5 models (fresh session)
Synthesis	1	Chairman (current model)
Total	11

Estimated Cost Per Council

Model	Advisory	Review	Total
Opus 4.6	Spawned (free)	Spawned (free)	$0
Sonnet 4.6	Spawned (free)	Spawned (free)	$0
Gemini 3.1 Pro	~$0.04	~$0.08	~$0.12
Grok 4.20	~$0.02	~$0.04	~$0.06
gpt-oss-120b	~$0.003	~$0.006	~$0.01
Total			~$0.19

Review phase costs more because input is longer (includes all 5 advisor responses).

Timeouts

Advisory phase: 3 minutes per model (parallel, so 3 min total)
Review phase: 4 minutes per model (longer input, parallel)
Total wall clock: ~7-10 minutes

Error Handling

Model fails advisory: Retry 3x. If still fails, proceed with 4 advisors. Log failure.
Model fails review: Retry 3x. If still fails, proceed with 4 reviews. Log failure.
Minimum viable council: 3 advisors + 3 reviews. Below that, abort and alert boss.

Rules

No substitutions. If Grok is down, run with 4. Never swap in a different model.
All cold. No memory, no prior context, no knowledge of other advisors.
Anonymous reviews. Reviewers never know which model produced which response.
Shuffle every time. The A-E mapping changes each council so reviewers can't learn patterns.
Chairman presents, boss rules. The chairman never makes the final decision.
Every council is logged. All advisor responses, all reviews, the mapping, and the final ruling are stored permanently for audit.
No partial councils. Either run the full 5-phase process or don't run it at all.
Identical prompts. All advisors get the exact same question. No per-model hints or framing.

What This Replaces

The old council system (core/council.ts, 962 lines) used:

Crafter (Sonnet) → wrote prompts for panelists
3 Panelists (Gemini, Grok, Llama) → answered in parallel
Synthesizer/Judge (Sonnet or Opus) → wrote final ruling

Problems with old system:

Only 3 independent voices (not 5)
No peer review — synthesizer just picked favorites
Crafter biased the prompts (each panelist got a different framing)
No blind spot detection — nobody asked "what did everyone miss?"
Synthesizer made the ruling (now boss makes it)

The new system fixes all of these.

Storage

Each council is stored at: /home/ubuntu/edgeclaw/data/councils/{YYYY-MM-DD}/{council-id}/

council-{id}/
├── question.txt           — original question + context
├── advisory/
│   ├── advisor-1-opus.json
│   ├── advisor-2-sonnet.json
│   ├── advisor-3-gemini.json
│   ├── advisor-4-grok.json
│   └── advisor-5-gptoss.json
├── anonymized/
│   ├── mapping.json       — {A: "opus", B: "gptoss", C: "gemini", ...}
│   └── shuffled.json      — all 5 responses with A-E labels
├── reviews/
│   ├── reviewer-1-opus.json
│   ├── reviewer-2-sonnet.json
│   ├── reviewer-3-gemini.json
│   ├── reviewer-4-grok.json
│   └── reviewer-5-gptoss.json
├── synthesis.json         — chairman's structured output
└── ruling.txt             — boss's final decision (added after discussion)

Document Control

This spec replaces the old council system entirely. The old core/council.ts and llm/council-clients.ts will be removed.

Amendments require a council ruling on the council itself (meta-ruling).

Source: ~/edgeclaw/docs/council-spec.md