記事一覧へ
Claude Code で40件以上のアーキテクチャ・戦略の意思決定をテストしました。最大の失敗は「間違った答え」ではありませんでした。単一視点による盲点でした。
そこで私は、11のエージェントが合意する前に意見を戦わせるシステムを構築しました。ブレークスルーはより良いプロンプトではありませんでした。
それは構造化された意見の相違でした:
• 11の視点を歴史的思想家にモデル化
• 6つの意図的な対極ペア
• コンセンサスの前に反対尋問を行う3ラウンドプロトコル
熟議を省略すれば、多次元の意思決定を単一視点に委ねることになります。
この記事では、完全なアーキテクチャ、再帰防止セーフガード、一般的なドメイン向けの11個の事前構築トライアドをご紹介します。
## 「バランスのとれた」単一エージェント回答の問題点
一つのモデルに「モノレポかポリレポか?」と尋ねると、洗練されたニュアンスある回答が返ってきます。バランスが取れているように見えます。
でも実際はそうではありません。
出力は一度に一つの推論の伝統から来ています。
モデルがシステム優先に傾いていれば、モノレポの論理が出ます。
モジュール優先に傾いていれば、ポリレポの論理が出ます。
一つの視点しか得られていません——ただ、よく書かれているだけです。
構造化された単一エージェントスキル(「核心を見つける」など)でさえ、組織は改善されますが、視点の多様性は改善されません。
より良い単数推論は得られます。
敵対的な熟議は得られません。
## Council of High Intelligence: システム設計
LLMは本当の意味で並行して考えることはできません。
一度の生成につき、一つの一貫した視点をシミュレートします。
そこで私は意見の相違レイヤーを外部化しました:
• 11の独立した Claude Code サブエージェント
• それぞれが独自の分析手法を持つ
• それぞれが明示的に宣言された盲点を持つ
• 中央プロトコル実施者が調整
モデル分割:
OPUS(深度優先): Socrates, Aristotle, Aurelius, Lao Tzu, Watts
SONNET(速度優先): Feynman, Sun Tzu, Ada, Machiavelli, Torvalds, Musashi
これは「11人の専門家」ではありません。
意図的な相互牽制システムです。
**OPUS(深度優先)**
- Socrates: 前提の破壊 → 全員が受け入れている隠れた前提
- Aristotle: 分類と構造 → 何かがどのカテゴリに属するか
- Marcus Aurelius: 回復力と道徳的明確性 → 制御できることとできないこと
- Lao Tzu: 非行動と創発 → 解決策が試みをやめることにある時
- Alan Watts: 視点の解消 → 問題が枠組みにある時
**SONNET(速度優先)**
- Feynman: ファーストプリンシプルデバッグ → 説明されていない複雑さ
- Sun Tzu: 敵対的戦略 → 地形と競争ダイナミクス
- Ada Lovelace: 形式システム → 機械化できることとできないこと
- Machiavelli: 権力ダイナミクス → アクターが実際にどのように行動するか
- Linus Torvalds: 実用的エンジニアリング → 出荷できるものと良さそうに見えるもの
- Miyamoto Musashi: 戦略的タイミング → 決定的な瞬間
各エージェントは分析手法、他が見逃すものを自分が見ること、そして——重要なことに——自分が見逃す傾向のあるものを宣言します。
## 6つの対極ペア
議会は11人のランダムな思想家ではありません。6つの意図的な相互牽制です:
- Socrates vs Feynman — 両者ともすべてに疑問を呈するが、Socrates はトップダウンで破壊し、Feynman はボトムアップで再構築する
- Aristotle vs Lao Tzu — Aristotle はすべてをカテゴリに分類する。Lao Tzu はカテゴリが問題だと言う
- Sun Tzu vs Aurelius — Sun Tzu は外部ゲームに勝つ。Aurelius は内部を統治する
- Ada vs Machiavelli — Ada は形式的純粋さに向かって抽象化する。Machiavelli は乱雑な人間のインセンティブに固定される
- Torvalds vs Watts — Torvalds は具体的な解決策を出荷する。Watts は問題が存在するかどうかを疑問視する
- Musashi vs Torvalds — Musashi は完璧な瞬間を待つ。Torvalds は今すぐ出荷しろと言う
これらのペアはグループシンクを防ぎます。11人全員が集まると、すべてのポジションに構造的な対立者がいます。3人のトライアドを選ぶ時、特定の緊張関係を選んでいます——専門知識の分野だけでなく。
## 3ラウンド熟議プロトコル
議会は11の意見を投票するだけではありません。関与を強制する構造化された3ラウンドプロトコルを実行します。
**ラウンド1: 独立分析(並列)**
選ばれた全メンバーが問題を受け取り、独立した分析を作成します。メンバー1人あたり最大400ワード。各メンバーはエージェント固有の出力テンプレートに従います:本質的な問い、ドメイン分析、評決、信頼レベル、そして自分が間違っているかもしれない点。
**ラウンド2: 反対尋問(順次)**
各メンバーが全員のラウンド1出力を受け取り、4つのプロンプトに答えなければなりません:どのポジションに最も同意できないか、別のメンバーのどの洞察が自分のポジションを強化するか、何が見解を変えたか、ポジションを再述する。最大300ワード。少なくとも2人の他のメンバーを名前で言及しなければなりません。
**ラウンド3: 統合**
各メンバーは100ワード以内で最終ポジションを述べます。新しい議論はありません。結晶化のみ。Socrates はちょうど一つの質問を得て、その後ポジションを述べなければなりません。
## 再帰防止の実施
Socrates は最も危険なメンバーです。3つの実施メカニズムがこれを防ぎます:
- ヘムロックルール: Socrates が別のメンバーが証拠で既に対処した質問を再度問う場合、コーディネーターは50ワードのポジション声明を強制します。
- 3レベル深さ制限: 前提に疑問を呈し、応答に疑問を呈し、もう一度疑問を呈します。3レベル後、Socrates は自分のポジションを述べなければなりません。
- 2メッセージ打ち切り: メンバーのペアが2メッセージ以上交換した場合、コーディネーターが打ち切り、ラウンド3を強制します。
## タイブレークとコンセンサスルール
議会は3つの決定ルールを使用します:2/3多数でコンセンサス(反対意見は少数派レポートに記録)、多数なしの場合は各ポジションを明確に述べてユーザーに提示、ドメイン専門家の重み付け(問題に最も直接対応するメンバーが1.5倍の重み)。
## 事前定義トライアド(代表例)
- アーキテクチャ: Aristotle + Ada + Feynman(分類→形式化→シンプルさテスト)
- 戦略: Sun Tzu + Machiavelli + Aurelius(地形→インセンティブ→道徳的根拠)
- デバッグ: Feynman + Socrates + Ada(ボトムアップ→前提→形式検証)
- 出荷: Torvalds + Musashi + Feynman(実用主義→タイミング→ファーストプリンシプル)
呼び出し例:
```
/council --triad architecture "should we split the monolith now or after Series B?"
/council --full "is this acquisition worth pursuing at 8x revenue?"
```
## インストール
```bash
git clone https://github.com/0xNyk/council-of-high-intelligence.git
cd council-of-high-intelligence
./install.sh
```
リポジトリはCC0(パブリックドメイン)でライセンスされています。

harness-designagent-opsclaude-workflow
11エージェント対話で盲点を排除
♥ 424↻ 42
原文を表示 / Show original
I tested 40+ architecture and strategy decisions with Claude Code. The biggest failures weren’t “wrong answers.” They were blind spots from a single perspective.
So I built a system that forces 11 agents to disagree before they agree. The breakthrough wasn’t a better prompt.
It was a structured disagreement:
• 11 perspectives modeled on historical thinkers
• 6 deliberate polarity pairs
• a 3-round protocol with cross-examination before consensus
If you skip deliberation, you’re trusting a single perspective on a multi-dimensional decision.
In this article, I’ll show you the full architecture, anti-recursion safeguards, and 11 pre-built triads for common domains.
The Problem With “Balanced” Single-Agent Answers
Ask one model: “Monorepo or polyrepo?”
You’ll get a polished, nuanced answer. It sounds balanced.
It isn’t.
The output comes from one reasoning tradition at a time.
If the model leans system-first, you get monorepo logic.
If it leans modularity-first, you get polyrepo logic.
You’re still getting one perspective—just well-written.
Even structured single-agent skills (“find the crux,” etc.) improve organization, but not perspective diversity.
You get better singular reasoning.
You do not get adversarial deliberation.
Council of High Intelligence: System Design
LLMs don’t truly think in parallel.
They simulate one coherent viewpoint per generation.
So I externalized the disagreement layer:
• 11 independent Claude Code subagents
• each with a unique analytical method
• each with explicitly declared blind spots
• coordinated by a central protocol enforcer
Each one spawns as an independent Claude Code subagent with its own system prompt, analytical method, and blind spots declared upfront.
┌─────────────────────────────────────────────┐
│ Council of High Intelligence │
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │Socrates │ │Aristotle│ │Aurelius │ │
│ │ (opus) │ │ (opus) │ │ (opus) │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │
│ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ │
│ │Feynman │ │Lao Tzu │ │Sun Tzu │ │
│ │(sonnet) │ │ (opus) │ │(sonnet) │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │
│ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ │
│ │ Ada │ │Machiav. │ │Torvalds │ │
│ │(sonnet) │ │(sonnet) │ │(sonnet) │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │
│ ┌────┴────┐ ┌────┴────┐ │
│ │Musashi │ │ Watts │ │
│ │(sonnet) │ │ (opus) │ │
│ └─────────┘ └─────────┘ │
│ │
│ Coordinator: routes, enforces protocol, │
│ applies anti-recursion rules │
└─────────────────────────────────────────────┘
Model split:
OPUS (depth-heavy): Socrates, Aristotle, Aurelius, Lao Tzu, Watts
SONNET (speed-critical): Feynman, Sun Tzu, Ada, Machiavelli, Torvalds, Musashi
This is not “11 experts.”
It’s a deliberate system of counterweights.
OPUS (depth-heavy)
─────────────────────────────────────────────
Socrates assumption destruction
→ hidden premises everyone accepts
Aristotle categorization and structure
→ what category something belongs to
Marcus Aurelius resilience and moral clarity
→ what you control vs what you do not
Lao Tzu non-action and emergence
→ when the solution is to stop trying
Alan Watts perspective dissolution
→ when the problem is the framing
SONNET (speed-critical)
─────────────────────────────────────────────
Feynman first-principles debugging
→ unexplained complexity
Sun Tzu adversarial strategy
→ terrain and competitive dynamics
Ada Lovelace formal systems
→ what can and cannot be mechanized
Machiavelli power dynamics
→ how actors actually behave
Linus Torvalds pragmatic engineering
→ what ships vs what sounds good
Miyamoto Musashi strategic timing
→ the decisive moment
Each agent declares its analytical method, what it sees that others miss, and — critically — what it tends to miss.
Socrates knows he spirals into infinite questioning.
Torvalds knows he dismisses theoretical elegance. These declared blind spots are why the polarity pairs matter.
The 6 polarity pairs
The council is not 11 random thinkers. It is 6 deliberate counterweights:
Socrates vs Feynman — both question everything, but Socrates destroys top-down, while Feynman rebuilds bottom-up
Aristotle vs Lao Tzu — Aristotle classifies everything into categories. Lao Tzu says the categories are the problem
Sun Tzu vs Aurelius — Sun Tzu wins the external game. Aurelius governs the internal one
Ada vs Machiavelli — Ada abstracts toward formal purity. Machiavelli anchors in messy human incentives
Torvalds vs Watts — Torvalds ships concrete solutions. Watts questions whether the problem even exists
Musashi vs Torvalds — Musashi waits for the perfect moment. Torvalds says ship it now
These pairs prevent groupthink. When all 11 convene, every position has a structural opponent. When you pick a triad of 3, you are selecting specific tensions — not just expertise areas.
The 3-round deliberation protocol
The council does not just poll 11 opinions. It runs a structured 3-round protocol that forces engagement.
Round 1: Independent analysis (parallel)
All selected members receive the problem and produce a standalone analysis.
400-word maximum per member.
Each follows their agent-specific output template:
Essential question, domain analysis, verdict, confidence level, and where they might be wrong.
Every member runs as a parallel subagent. A 3-member triad completes round 1 in one parallel batch.
Round 2: Cross-examination (sequential)
Each member receives an all-around 1 output and must answer 4 prompts:
Which position do you most disagree with, and why?
Which insight from another member strengthens your own position?
What, if anything, changed your view?
Restate your position
300-word maximum. Must engage at least 2 other members by name.
Sequential execution so later members can reference earlier cross-examinations.
This is where the real value emerges. Feynman does not just state his view — he has to explain why he disagrees with Socrates.
Round 3: Synthesis
Each member states their final position in 100 words or fewer. No new arguments. Crystallization only.
Socrates gets exactly one question, then must state his position. This is the convergence gate that prevents the dialectic from spiraling.
Anti-recursion enforcement
Socrates is the most dangerous member. His method is questioning, which means he can loop forever without committing to a position.
Three enforcement mechanisms prevent this:
The hemlock rule: if Socrates re-asks a question that another member has already addressed with evidence, the coordinator forces a 50-word position statement.
No more questions.
The 3-level depth limit: question a premise, question the response, question once more. After 3 levels, Socrates must state his own position.
The 2-message cutoff: if any pair of members exchanges more than 2 messages, the coordinator cuts them off and forces round 3.
These rules exist because the first version had no recursion limits. Socrates and Feynman would enter a questioning loop that consumed the entire context window.
no conclusion. just questions.
Tie-breaking and consensus rules
The council uses 3 decision rules:
2/3 majority = consensus. The dissenting position is recorded in a Minority Report section
No majority = the dilemma is presented to the user with each position clearly stated. The council does not force artificial consensus
Domain expert weighting: the member whose domain most directly matches the problem gets 1.5x weight
The minority report matters. Sometimes the dissenting view is the most valuable output.
It surfaces the risk that the majority position misses.
Pre-defined triads for common domains
You do not need all 11 members for every question. The council ships 11 pre-built triads optimized for specific problem domains:
DOMAIN TRIAD WHY
─────────────────────────────────────────────────────────
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 → assumptions → formal verify
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 verify
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
Invocation:
/council --triad architecture "should we split the monolith now or after Series B?"
/council --full "is this acquisition worth pursuing at 8x revenue?"
/council --members socrates,feynman,ada "why does our cache invalidation keep failing?"
--triad selects a pre-built group.
--full convenes all 11.
--members lets you pick any 2-11 members manually.
No flag auto-detects the domain from your question and selects the matching triad [E7].
What a council session produces
The output is not 11 separate opinions. It is a structured verdict:
## Council Verdict
### Problem
should we migrate from REST to GraphQL for the mobile API?
### Council Composition
Architecture triad: Aristotle, Ada, Feynman
### Consensus Position
migrate the mobile-facing read endpoints to GraphQL.
keep REST for write operations and internal services.
### Key Insights by Member
- Aristotle: the problem is a category error — "migrate to GraphQL"
treats it as binary when the real question is which access
patterns benefit from graph traversal
- Ada: GraphQL's type system gives you compile-time guarantees
on the client that REST cannot match — but only for reads
- Feynman: the performance cost of GraphQL resolvers on write-heavy
paths is not theoretical. measure it. if N+1 queries appear
in staging, the abstraction is hiding real cost
### Points of Agreement
- mobile clients benefit from flexible queries (reduce over-fetching)
- write operations do not benefit from GraphQL's query model
- incremental migration is safer than full rewrite
### Points of Disagreement
- Aristotle wants a formal boundary definition before any migration
- Feynman wants a prototype with real latency measurements first
### Minority Report
none — consensus reached on hybrid approach
### Recommended Next Steps
1. prototype GraphQL gateway for 2 highest-traffic read endpoints
2. measure latency delta against current REST implementation
3. if delta is under 15ms p99, proceed with mobile read migration
The key difference from asking a single model: You get the disagreements explicitly.
Aristotle's "category error" reframe and Feynman's "measure it first" constraint are both surfaced. A single model averages these into one confident recommendation. The council keeps them separate so you can decide.
Installation
The council is a Claude Code skill. Installation takes 30 seconds:
git clone https://github.com/0xNyk/council-of-high-intelligence.git
cd council-of-high-intelligence
./install.sh
this copies 11 agent definitions to ~/.claude/agents/ and the coordinator skill to~/.claude/skills/council/SKILL.md.
Manual installation if you prefer:
cp agents/council-*.md ~/.claude/agents/
mkdir -p ~/.claude/skills/council
cp SKILL.md ~/.claude/skills/council/SKILL.md
Requires Claude Code CLI with agent subagent support. CC0 licensed — use it however you want.
When to use the council vs when not to
Use the council for complex decisions where trade-offs are real.
Architecture choices. Strategic pivots. Build-vs-buy. Pricing models.
Do not use it for questions with clear, correct answers.
Do not convene 11 thinkers to debate TypeScript vs JavaScript.
Do not use --full when a triad covers the domain.
11 members consume significant context and API cost.
The sweet spot: Decisions where you already have an opinion but suspect you are missing something. The council surfaces what you are not seeing — structured, with the disagreements visible.
What is the last decision you made where a single confident answer hid the real trade-offs?
Repository licensed under CC0 (public domain), github.com/0xNyk/council-of-high-intelligence
I started a private Telegram channel where I’ll be sharing insights and updates regularly:
https://t.me/+GJ-FEpzcZrtmMTky