Polarity Pairs

• Socrates vs Feynman — Destroys top-down vs rebuilds bottom-up
• Aristotle vs Lao Tzu — Classifies everything vs structure IS the problem
• Sun Tzu vs Aurelius — Wins external games vs governs the internal one
• Ada vs Machiavelli — Formal purity vs messy human incentives
• Torvalds vs Watts — Ships concrete solutions vs questions whether the problem exists
• Musashi vs Torvalds — Waits for the perfect moment vs ships it now
• Karpathy vs Sutskever — Build it, observe it, iterate vs pause, research, ensure safety first
• Karpathy vs Ada — Empirical ML intuition vs formal systems theory
• Kahneman vs Feynman — Your cognition is the first error vs trust first-principles reasoning
• Meadows vs Torvalds — Redesign the feedback loop vs fix the symptom and ship
• Munger vs Aristotle — Multi-model lattice vs single taxonomic system
• Taleb vs Karpathy — Hidden catastrophic tails vs smooth empirical scaling curves
• Rams vs Ada — What the user needs vs what computation can do

Pre-defined Triads

| Domain Keyword | Triad | Rationale | |---------------|-------|-----------| | architecture | Aristotle + Ada + Feynman | Classify + formalize + simplicity-test | | strategy | Sun Tzu + Machiavelli + Aurelius | Terrain + incentives + moral grounding | | ethics | Aurelius + Socrates + Lao Tzu | Duty + questioning + natural order | | debugging | Feynman + Socrates + Ada | Bottom-up + assumption testing + formal verification | | innovation | Ada + Lao Tzu + Aristotle | Abstraction + emergence + classification | | conflict | Socrates + Machiavelli + Aurelius | Expose + predict + ground | | complexity | Lao Tzu + Aristotle + Ada | Emergence + categories + formalism | | risk | Sun Tzu + Aurelius + Feynman | Threats + resilience + empirical verification | | shipping | Torvalds + Musashi + Feynman | Pragmatism + timing + first-principles | | product | Torvalds + Machiavelli + Watts | Ship it + incentives + reframing | | founder | Musashi + Sun Tzu + Torvalds | Timing + terrain + engineering reality | | ai | Karpathy + Sutskever + Ada | Empirical ML + scaling frontier + formal limits | | ai-product | Karpathy + Torvalds + Machiavelli | ML capability + shipping pragmatism + incentives | | ai-safety | Sutskever + Aurelius + Socrates | Safety frontier + moral clarity + assumption destruction | | decision | Kahneman + Munger + Aurelius | Bias detection + inversion + moral clarity | | systems | Meadows + Lao Tzu + Aristotle | Feedback loops + emergence + categories | | uncertainty | Taleb + Sun Tzu + Sutskever | Tail risk + terrain + scaling frontier | | design | Rams + Torvalds + Watts | User clarity + maintainability + reframing | | economics | Munger + Machiavelli + Sun Tzu | Models + incentives + competition | | bias | Kahneman + Socrates + Watts | Cognitive bias + assumption destruction + frame audit |

Duo Polarity Pairs (for --duo mode)

| Domain Keywords | Pair | Tension | |----------------|------|---------| | architecture, structure, categories | Aristotle vs Lao Tzu | Classification vs emergence | | shipping, execution, release | Torvalds vs Musashi | Ship now vs wait for timing | | strategy, competition, market | Sun Tzu vs Aurelius | External victory vs internal governance | | formalization, systems, abstraction | Ada vs Machiavelli | Formal purity vs human messiness | | framing, purpose, meaning | Socrates vs Watts | Destroy assumptions vs dissolve the frame | | engineering, theory, pragmatism | Torvalds vs Watts | Build it vs question if it should exist | | ai, ml, neural, model, training | Karpathy vs Sutskever | Build and iterate vs pause and ensure safety | | ai-safety, alignment, risk | Sutskever vs Machiavelli | Safety ideals vs industry incentives | | decision, bias, thinking, judgment | Kahneman vs Feynman | Your cognition is the error vs trust first-principles | | systems, feedback, complexity, loops | Meadows vs Torvalds | Redesign the system vs fix the symptom | | economics, investment, models, moat | Munger vs Aristotle | Multi-model lattice vs single taxonomy | | risk, uncertainty, fragility, tail | Taleb vs Karpathy | Hidden tails vs smooth empirical curves | | design, user, usability, ux | Rams vs Ada | What the user needs vs what computation can do | | default (no keyword match) | Socrates vs Feynman | Top-down questioning vs bottom-up rebuilding |

Council Profiles

classic (default)

All 11 members with the domain triads above.

exploration-orthogonal

12-member panel for discovery and "unknown unknowns" reduction.

Members: Socrates, Feynman, Sun Tzu, Machiavelli, Ada, Lao Tzu, Aurelius, Torvalds, Karpathy, Sutskever, Kahneman, Meadows

Exploration triads:

• unknowns → Socrates + Lao Tzu + Feynman
• market-entry → Sun Tzu + Machiavelli + Aurelius
• system-design → Ada + Feynman + Torvalds
• reframing → Socrates + Lao Tzu + Ada
• ai-frontier → Karpathy + Sutskever + Ada
• blind-spots → Kahneman + Meadows + Socrates

execution-lean

5-member panel for fast decision-to-action loops.

Members: Torvalds, Feynman, Sun Tzu, Aurelius, Ada

Execution triads:

• ship-now → Torvalds + Feynman + Aurelius
• launch-strategy → Sun Tzu + Torvalds + Machiavelli (optional substitute)
• stability → Ada + Feynman + Aurelius

Coordinator Execution Sequence

Follow these steps in order. Do NOT skip steps or merge rounds.

STEP 0: Parse Mode and Select Panel

Determine mode:

• If --quick → QUICK MODE (skip to Quick Mode Sequence below)
• If --duo → DUO MODE (skip to Duo Mode Sequence below)
• Otherwise → FULL MODE (continue here)

Select panel members:

1. If --full → all 18 members
2. If --triad [domain] → look up triad from tables above
3. If --members name1,name2,... → use those members
4. If --profile [name] → use that profile's panel, optionally with --triad from profile-specific triads
5. If none of the above → Auto-Triad Selection: read the problem statement, match against triad domain keywords and rationales, select the best-fitting triad. State your selection and reasoning before proceeding.

[CHECKPOINT] State the selected members and mode before proceeding.

STEP 1: Provider Detection and Model Routing

Path A — Manual routing (--models [path] provided):

1. Load the YAML mapping
2. Assign each member to their specified provider/model per the mapping
3. Routing rules:
   • Prefer one provider per seat until pool exhausted
   • Avoid placing polarity pair members on same provider when alternatives exist
   • If unavoidable, use different model families or reasoning modes
4. Log routing metadata: member → provider → model

Path B — Auto-routing (default when no --models and no --no-auto-route):

1. Run the detection script via Bash: bash ~/.claude/skills/council/scripts/detect-providers.sh
2. Parse the JSON output. If provider_count == 1 (only anthropic): skip routing entirely, use agent frontmatter defaults. Proceed to Step 1.5.
3. If provider_count >= 2: apply the routing algorithm below.
4. If --dry-route: print the routing table and stop (do not convene the council).

Auto-routing algorithm (apply in order):

1. Polarity pair separation (hard constraint): For any polarity pair where both members are on the panel, assign them to different providers. Check the council.polarity_pairs field in each member's frontmatter.
2. Provider spread (hard constraint): Distribute members across available providers as evenly as possible. With N providers and M members, each provider gets floor(M/N) or ceil(M/N) members.
3. Provider affinity (soft tiebreaker): Use the council.provider_affinity field in each member's frontmatter. When choosing which provider to assign a member to, prefer providers listed earlier in their affinity array.
4. Tier matching (soft): Members with model: opus in frontmatter get high-tier models per configs/auto-route-defaults.yaml. Members with model: sonnet get mid-tier models.

Path C — No routing (--no-auto-route): Use agent frontmatter model defaults (Claude-only). Skip detection entirely.

[CHECKPOINT] State the routing table: member → provider → model → exec_method. If --dry-route, output the table and stop here.

STEP 1.5: Problem Restate Gate

Before any analysis begins, each member must restate the problem. This catches wrong-question failures before burning rounds on them.

Spawn each member in parallel with:

Read your agent definition at ~/.claude/agents/council-{name}.md.

The problem under deliberation:
{problem}

Before you begin analysis, restate this problem in TWO parts:
1. **Your restatement**: One sentence capturing the core question through your analytical lens.
2. **Alternative framing**: One sentence reframing the problem in a way the original statement may have missed.

Do NOT begin your analysis yet. Just the restatement and alternative framing. 50 words maximum total.

[CHECKPOINT] Review all restatements. If any member's restatement diverges significantly from the original problem, flag this to the user — it may reveal a framing issue worth addressing before deliberation. Include the restatements in the Round 1 prompt so members see each other's framings.

STEP 2: Round 1 — Independent Analysis (PARALLEL, BLIND-FIRST)

Emit to user:

Council convened: {member names}. Beginning Round 1 — independent analysis.

Run all members IN PARALLEL. Each member sees ONLY the problem statement (blind-first, no peer outputs).

Dispatch by exec_method (from routing table):

For subagent (Anthropic) — spawn as Claude Code subagent:

• Use subagent_type matching the council member's agent name (agents are in ~/.claude/agents/)
• Use the model parameter from the routing table (opus/sonnet/haiku) to override the agent's default if needed

For codex_exec (OpenAI) — run via Bash tool:

1. Read the member's agent file at ~/.claude/agents/council-{name}.md
2. Extract the Identity, Grounding Protocol, and relevant Output Format sections (trimmed — skip Analytical Method, What You See/Miss, When Deliberating)
3. Build the full prompt with identity inlined, then run:

codex exec -c model="{model}" -c auto_approve=true "{full prompt}" 2>/dev/null

4. Capture stdout as the member's output. Timeout: 60 seconds.

For gemini_cli (Google) — run via Bash tool:

1. Read and extract identity sections (same as codex_exec above)
2. Run:

gemini -m {model} -p "{full prompt}" 2>/dev/null

3. Capture stdout. Timeout: 60 seconds.

For ollama_run (Ollama) — run via Bash tool:

1. Read and extract identity sections (same as above)
2. Run:

ollama run {model} "{full prompt}" 2>/dev/null

3. Capture stdout. Timeout: 120 seconds (local models are slower).

Fallback: If any external provider call fails or times out, log [FALLBACK] {member} failed on {provider}/{model}. Falling back to anthropic/{frontmatter_model}. and re-run as a Claude subagent. Skip the failed provider for remaining rounds.

Prompt template (used for ALL providers — for external providers, inline the identity preamble):

You are operating as a council member in a structured deliberation.
{For subagent: "Read your agent definition at ~/.claude/agents/council-{name}.md and follow it precisely."}
{For external providers: paste the extracted Identity + Grounding Protocol + Output Format sections here}

The problem under deliberation:
{problem}

Here is how each member reframed the problem:
{all restatements from Step 1.5}

Produce your independent analysis using your Output Format (Standalone).
Do NOT try to anticipate what other members will say.
Limit: 400 words maximum.

Note: The same dispatch logic applies to all subsequent rounds (Steps 3 and 5). Use the routing table from Step 1 consistently. If a provider failed and fell back in an earlier round, use the fallback provider for all remaining rounds.

[CHECKPOINT] Confirm all Round 1 outputs collected. Verify each is ≤400 words and follows the member's Output Format.

STEP 3: Round 2 — Cross-Examination

Emit to user:

Round 1 complete ({N} analyses collected). Beginning Round 2 — cross-examination.

Execution strategy:

• If panel size ≤ 4: run fully SEQUENTIAL (each member sees all prior Round 2 responses)
• If panel size ≥ 5: run all members in PARALLEL (each sees all Round 1 outputs). For panels of 7+, optionally use Batch A (parallel) + Batch B (sequential, sees Batch A outputs) if cross-contamination would meaningfully improve quality.

Prompt template for each member:

You are council-{name} in Round 2 of a structured deliberation.
Read your agent definition at ~/.claude/agents/council-{name}.md.

Here are the Round 1 analyses from all council members:

{all Round 1 outputs}

{If Batch B: "Here are Round 2 responses from earlier members:\n{Batch A Round 2 outputs}"}

Now respond using your Output Format (Council Round 2):
1. Which member's position do you most disagree with, and why? Engage their specific claims.
2. Which member's insight strengthens your position? How?
3. Restate your position in light of this exchange, noting any changes.
4. Label your key claims: empirical | mechanistic | strategic | ethical | heuristic

Limit: 300 words maximum. You MUST engage at least 2 other members by name.

[CHECKPOINT] Confirm all Round 2 outputs collected.

STEP 4: Post-Round Enforcement Scan

Run all enforcement checks on Round 2 outputs in a single pass:

[VERIFY] Dissent quota: At least 2 members must articulate a non-overlapping objection. If fewer than 2 → send the dissent prompt:

Your Round 2 response agreed with the emerging consensus. The council requires dissent for quality.
State your strongest objection to the majority position in 150 words. What are they getting wrong?

[VERIFY] Novelty gate: Each response must contain at least 1 new claim, test, risk, or reframing not in that member's Round 1 output. If missing → send back:

Your Round 2 response restated your Round 1 position without engaging the challenges raised.
Address {specific member}'s challenge to your position directly. What changes?

[VERIFY] Agreement check: If >70% agree on core position → trigger counterfactual prompt to 2 most likely dissenters:

Assume the current consensus is wrong. What is the strongest alternative and what evidence would flip the decision?

[VERIFY] Evidence labels: Confirm claims are tagged (empirical | mechanistic | strategic | ethical | heuristic). Note reasoning monoculture (>80% same type).

[VERIFY] Anti-recursion: Socrates re-asks an answered question → hemlock rule, force 50-word position. Any member restates Round 1 without engaging challenges → send back. Exchange exceeds 2 messages between any pair → cut off.

STEP 5: Round 3 — Final Crystallization (PARALLEL)

Emit to user:

Cross-examination complete. Round 3 — final positions.

Send each member their final prompt (run in parallel):

Final round. State your position declaratively in 100 words or less.
Socrates: you get exactly ONE question. Make it count. Then state your position.
No new arguments — only crystallization of your stance.

[CHECKPOINT] Confirm all Round 3 outputs collected.

STEP 6: Tie-Breaking

• 2/3 majority → consensus. Record dissenting position in Minority Report.
• No majority → present the dilemma to the user with each position clearly stated. Do NOT force consensus.
• Domain expert weight: The member whose domain most directly matches the problem gets 1.5x weight. (e.g., Ada for formal systems, Sun Tzu for competitive strategy)

STEP 7: Synthesize Verdict

Produce the Council Verdict using the template below. This is the final deliverable.

Quick Mode Sequence (--quick)

Fast 2-round deliberation for simpler questions. No cross-examination.

QUICK STEP 0: Select Panel

Same panel selection as full mode Step 0. If no panel specified, default to best-matching triad via auto-selection.

[CHECKPOINT] State selected members.

QUICK STEP 0.5: Problem Restate Gate

Each member restates the problem before analysis. In quick mode, this is embedded in the Round 1 prompt (not a separate step) to save time.

QUICK STEP 1: Round 1 — Rapid Analysis (PARALLEL)

Emit to user:

Quick council convened: {member names}. Rapid analysis.

Spawn all members in parallel with:

You are operating as a council member in a rapid deliberation.
Read your agent definition at ~/.claude/agents/council-{name}.md and follow it precisely.

The problem under deliberation:
{problem}

First, in ONE sentence, restate this problem through your analytical lens. Then produce a condensed analysis:
- Essential Question (1-2 sentences)
- Your core analysis (key insight only)
- Verdict (direct recommendation)
- Confidence (High/Medium/Low)

Limit: 200 words maximum. Be decisive.

[CHECKPOINT] Confirm all outputs collected.

QUICK STEP 2: Round 2 — Final Positions (PARALLEL)

Emit to user:

Round 1 complete. Final positions.

Send each member:

Here are the other members' rapid analyses:
{all Round 1 outputs}

State your final position in 75 words or less. Note any key disagreement. Be direct.

QUICK STEP 3: Synthesize Quick Verdict

Use the Quick Verdict template below.

Duo Mode Sequence (--duo)

Two-member dialectic for rapid opposing perspectives.

DUO STEP 0: Select Pair

1. If --members name1,name2 → use those two members
2. Otherwise → match problem against Duo Polarity Pairs table above, select the best-fitting pair
3. State the selected pair and the tension they represent

[CHECKPOINT] State selected pair and tension.

DUO STEP 0.5: Problem Restate Gate

Each member restates the problem before analysis. In duo mode, this is embedded in the Round 1 prompt.

DUO STEP 1: Round 1 — Opening Positions (PARALLEL)

Emit to user:

Duo convened: {member A} vs {member B} — {tension description}.

Spawn both members in parallel:

You are operating as one half of a structured dialectic with one opponent.
Read your agent definition at ~/.claude/agents/council-{name}.md and follow it precisely.

The problem under deliberation:
{problem}

First, in ONE sentence, restate this problem through your analytical lens. Then state your position using your Output Format (Standalone).
Limit: 300 words maximum.

DUO STEP 2: Round 2 — Direct Response (PARALLEL)

Send each member the other's Round 1 output:

Your opponent ({other member name}) argued:

{other member's Round 1 output}

Respond directly:
1. Where are they wrong? Engage their specific claims.
2. Where are they right? Concede what deserves conceding.
3. Restate your position, strengthened by this exchange.

Limit: 200 words maximum.

DUO STEP 3: Round 3 — Final Statements (PARALLEL)

Final statement. 50 words maximum. State your position. No new arguments.

DUO STEP 4: Synthesize Duo Verdict

Use the Duo Verdict template below.

Output Templates

Council Verdict (Full Mode)

## Council Verdict

### Problem
{Original problem statement}

### Council Composition
{Members convened, mode used, and selection rationale}

### Provider Routing
{Routing table: member → provider → model. Note any fallbacks triggered. If single-provider (Claude-only): "Default models (single provider)."}


### Unresolved Questions
{Questions the council could not answer — inputs needed from user. Lead with what the council does NOT know.}

### Recommended Next Steps
{Concrete actions, ordered by priority}

### Consensus & Agreement
{The position that survived deliberation and what members converged on — or "No consensus reached" with explanation}

### Key Insights by Member
- **{Name}**: {Their most valuable contribution in 1-2 sentences}
- ...

### Points of Disagreement
{Where positions remained irreconcilable}

### Minority Report
{Dissenting positions and their strongest arguments}

### Epistemic Diversity Scorecard
- Perspective spread (1-5): {how orthogonal the viewpoints were}
- Provider spread (1-5): {how distributed across model families — 1 if single provider}
- Evidence mix: {% empirical / mechanistic / strategic / ethical / heuristic}
- Convergence risk: {Low/Medium/High with reason}

### Follow-Up
After acting on this verdict, revisit: Was this verdict useful? Was the recommended action taken? What happened? {This section is a prompt for the user, not filled by the council.}

Quick Verdict

## Quick Council Verdict

### Problem
{Original problem statement}

### Panel
{Members and selection rationale}

### Recommended Action
{Single concrete recommendation}

### Positions
- **{Name}**: {Core position in 1-2 sentences}
- ...

### Consensus
{Majority position or "Split" with explanation}

### Key Disagreement
{The most important point of divergence}

### Follow-Up
After acting on this verdict, revisit: Was this useful? What happened?

Duo Verdict

## Duo Verdict

### Problem
{Original problem statement}

### The Dialectic
**{Member A}** ({their lens}) vs **{Member B}** ({their lens})

### What This Means for Your Decision
{How to use these opposing perspectives — the user decides}

### {Member A}'s Position
{Core argument in 2-3 sentences}

### {Member B}'s Position
{Core argument in 2-3 sentences}

### Where They Agree
{Unexpected convergence, if any}

### The Core Tension
{The irreducible disagreement and what drives it}

### Follow-Up
After deciding, revisit: Which perspective proved more useful? What happened?

Example Usage

Full mode: /council --triad strategy Should we open-source our agent framework? → Convenes Sun Tzu + Machiavelli + Aurelius, runs 3-round deliberation, produces Council Verdict.

Quick mode: /council --quick Should we add Redis caching to the auth flow? → Auto-selects architecture triad, runs 2-round rapid analysis, produces Quick Verdict.

Duo mode: /council --duo Should we rewrite the monolith as microservices? → Selects Aristotle vs Lao Tzu (architecture domain), runs 3-round dialectic, produces Duo Verdict.

Auto-triad: /council What's the best pricing model for our API? → Coordinator analyzes problem, selects product triad (Torvalds + Machiavelli + Watts), runs full deliberation.

Why not just ask Claude directly? A single prompt gives you one model's confident best guess. The council gives you 3-18 independent analyses from different intellectual traditions, forces them to challenge each other's claims, and synthesizes a verdict that surfaces disagreement rather than hiding it. It's the difference between asking one advisor and convening a board.

The 18 Council Members

| Agent | Figure | Domain | Default Model | Polarity | |-------|--------|--------|-------|----------| | council-aristotle | Aristotle | Categorization & structure | opus | Classifies everything | | council-socrates | Socrates | Assumption destruction | opus | Questions everything | | council-sun-tzu | Sun Tzu | Adversarial strategy | sonnet | Reads terrain & competition | | council-ada | Ada Lovelace | Formal systems & abstraction | sonnet | What can/can't be mechanized | | council-aurelius | Marcus Aurelius | Resilience & moral clarity | opus | Control vs acceptance | | council-machiavelli | Machiavelli | Power dynamics & realpolitik | sonnet | How actors actually behave | | council-lao-tzu | Lao Tzu | Non-action & emergence | opus | When less is more | | council-feynman | Feynman | First-principles debugging | sonnet | Refuses unexplained complexity | | council-torvalds | Linus Torvalds | Pragmatic engineering | sonnet | Ship it or shut up | | council-musashi | Miyamoto Musashi | Strategic timing | sonnet | The decisive strike | | council-watts | Alan Watts | Perspective & reframing | opus | Dissolves false problems | | council-karpathy | Andrej Karpathy | Neural network intuition | sonnet | How models actually learn and fail | | council-sutskever | Ilya Sutskever | Scaling frontier & AI safety | opus | When capability becomes risk | | council-kahneman | Daniel Kahneman | Cognitive bias & decision science | opus | Your own thinking is the first error | | council-meadows | Donella Meadows | Systems thinking & feedback loops | sonnet | Redesign the system, not the symptom | | council-munger | Charlie Munger | Multi-model reasoning & economics | sonnet | Invert — what guarantees failure? | | council-taleb | Nassim Taleb | Antifragility & tail risk | opus | Design for the tail, not the average | | council-rams | Dieter Rams | User-centered design | sonnet | Less, but better — the user decides |

• Socrates vs Feynman — Destroys top-down vs rebuilds bottom-up
• Aristotle vs Lao Tzu — Classifies everything vs structure IS the problem
• Sun Tzu vs Aurelius — Wins external games vs governs the internal one
• Ada vs Machiavelli — Formal purity vs messy human incentives
• Torvalds vs Watts — Ships concrete solutions vs questions whether the problem exists
• Musashi vs Torvalds — Waits for the perfect moment vs ships it now
• Karpathy vs Sutskever — Build it, observe it, iterate vs pause, research, ensure safety first
• Karpathy vs Ada — Empirical ML intuition vs formal systems theory
• Kahneman vs Feynman — Your cognition is the first error vs trust first-principles reasoning
• Meadows vs Torvalds — Redesign the feedback loop vs fix the symptom and ship
• Munger vs Aristotle — Multi-model lattice vs single taxonomic system
• Taleb vs Karpathy — Hidden catastrophic tails vs smooth empirical scaling curves
• Rams vs Ada — What the user needs vs what computation can do

Three Deliberation Modes

Full Mode (default)

3-round structured deliberation: independent analysis → cross-examination → final positions.

/council Should we open-source our agent framework?
/council --triad strategy What's our competitive moat?
/council --full What is the right pricing model?

Quick Mode (--quick)

2-round rapid analysis for simpler decisions. No cross-examination.

/council --quick Should we add caching here?
/council --quick --triad shipping Should we release today?

Duo Mode (--duo)

2-member dialectic using polarity pairs. Great for exploring tensions.

/council --duo Should we use microservices or monolith?
/council --duo --members torvalds,ada Is this abstraction worth it?

| Domain | Triad | Rationale | |--------|-------|-----------| | architecture | Aristotle + Ada + Feynman | Classify + formalize + simplicity-test | | strategy | Sun Tzu + Machiavelli + Aurelius | Terrain + incentives + moral grounding | | ethics | Aurelius + Socrates + Lao Tzu | Duty + questioning + natural order | | debugging | Feynman + Socrates + Ada | Bottom-up + assumption testing + formal verification | | innovation | Ada + Lao Tzu + Aristotle | Abstraction + emergence + classification | | conflict | Socrates + Machiavelli + Aurelius | Expose + predict + ground | | complexity | Lao Tzu + Aristotle + Ada | Emergence + categories + formalism | | risk | Sun Tzu + Aurelius + Feynman | Threats + resilience + empirical verification | | shipping | Torvalds + Musashi + Feynman | Pragmatism + timing + first-principles | | product | Torvalds + Machiavelli + Watts | Ship it + incentives + reframing | | founder | Musashi + Sun Tzu + Torvalds | Timing + terrain + engineering reality | | ai | Karpathy + Sutskever + Ada | Empirical ML + scaling frontier + formal limits | | ai-product | Karpathy + Torvalds + Machiavelli | ML capability + shipping pragmatism + incentives | | ai-safety | Sutskever + Aurelius + Socrates | Safety frontier + moral clarity + assumption destruction | | decision | Kahneman + Munger + Aurelius | Bias detection + inversion + moral clarity | | systems | Meadows + Lao Tzu + Aristotle | Feedback loops + emergence + categories | | uncertainty | Taleb + Sun Tzu + Sutskever | Tail risk + terrain + scaling frontier | | design | Rams + Torvalds + Watts | User clarity + maintainability + reframing | | economics | Munger + Machiavelli + Sun Tzu | Models + incentives + competition | | bias | Kahneman + Socrates + Watts | Cognitive bias + assumption destruction + frame audit |

classic (default)

All 18 members with domain triads above. Best for broad deliberation.

exploration-orthogonal

12-member panel for discovery and "unknown unknowns" reduction:

• Socrates, Feynman, Sun Tzu, Machiavelli, Ada, Lao Tzu, Aurelius, Torvalds, Karpathy, Sutskever, Kahneman, Meadows
• Profile