For anyone making high-stakes decisions who wants more than a single AI perspective — founders, operators, product leads, strategists
Blueprint: Multi-Agent Consilium
You ask AI something complex. You get a smooth, confident answer — one perspective. You try a trick: “give me three viewpoints.” You get three variations of the same opinion dressed in different words. The model converges to its own bias regardless of instruction — that’s not a bug, it’s an architectural property.
For simple questions, this is fine. For high-stakes decisions — it’s not. When you’re choosing between pivoting and scaling, when you’re deciding whether to fire or restructure a team, when you’re betting on a product that will take six months of your life — you need genuine cognitive diversity, not cosplay.
This Blueprint describes a pattern: a multi-agent consilium — a panel of AI agents with different cognitive styles that independently analyze a problem, debate each other, and produce structured artifacts for decision-making. Not one model’s opinion from different angles, but a clash of different ways of thinking.
What You Get
- A panel of cognitively diverse agents — each with a persistent persona, a distinctive voice, and its own analytical approach
- A debate protocol (independence –> confrontation –> synthesis) — prevents premature consensus and averaging
- 4 structured artifacts from every session: Tension Map, Risk-scored Ideas, Decision Brief, Blind Spots
- A decision archive — the full discussion is saved as a session you can revisit
- Knowledge base integration — agents receive context from your files through links in the problem description
How to Apply
- Open any orchestrator that supports parallel sub-agents (Claude Code, Cursor, a custom script, any multi-agent framework) in your knowledge base directory
- Show it this Blueprint: “Build me a multi-agent consilium using this Blueprint”
- The agent will ask questions from the “Adaptation Questions” section
- Answer about your domain, models, file structure
- The agent will create: persona files, orchestration config, session and problem templates
Context: a single session. The agent needs access to your knowledge base files (for resolving links) and the ability to create new files.
When to Use
- Strategic crossroads — pivot or scale? Hire or automate? Ship now or iterate?
- Hunting blind spots — you suspect something’s missing but can’t see what
- Stress-testing a plan — the plan is ready, but you want to find holes before you start
- Before irreversible decisions — the cost of a missed perspective is high
- Divergent thinking — you need a fan of ideas before narrowing down
NOT for:
- Factual questions (use search)
- Routine tasks (a single agent will do)
- Decisions already made (dissent will just annoy you)
- Problems without context (agents can’t debate in a vacuum)
Litmus test: “Would two smart people genuinely argue about this?” If yes — it’s for the consilium.
Core Idea
Independence BEFORE confrontation BEFORE synthesis. Character voice prevents averaging.
The human:
- Formulates the problem (tension, context, question)
- Observes the debate or waits for the result
- Makes a decision based on the artifacts
The system:
- Generates independent perspectives (round 1)
- Orchestrates confrontation (round 2)
- Collects final positions (round 3)
- Synthesizes artifacts from the full discussion
Architecture
Problem (input)
|
v
+---------------------------------------------------+
| Round 1: Independent Analysis |
| |
| +---------+ +---------+ +---------+ +-------+ |
| |Persona A| |Persona B| |Persona C| | ... | |
| +----+----+ +----+----+ +----+----+ +---+---+ |
| | | | | |
| Independent. Cannot see each other. |
+-------+-----------+-----------+-----------+-------+
v v v v
+---------------------------------------------------+
| Round 2: Confrontation |
| |
| Each sees the others' positions. |
| Attacks. Defends. Looks for synthesis points. |
| |
+-------------------------+-------------------------+
v
+---------------------------------------------------+
| Round 3: Final Positions |
| |
| Each sees the FULL discussion (R1 + R2). |
| "Here's what I think NOW, after everyone." |
| |
+-------------------------+-------------------------+
v
+---------------------------------------------------+
| Synthesizer |
| |
| A separate role (not a persona). |
| Reads R1 + R2 + R3 in full. |
| Generates 4 artifacts. |
| |
+-------------------------+-------------------------+
v
+--------------------+
| Tension Map |
| Risk-scored Ideas |
| Decision Brief |
| Blind Spots |
+--------------------+
File Structure
Consilium/
├── Agents/ — persona files (one file = one archetype)
│ ├── disruptor.md
│ ├── visionary.md
│ ├── critic.md
│ └── rationalist.md
├── Problems/ — problem descriptions (input)
│ └── YYYY-MM-DD Problem Title.md
├── Sessions/ — session results (output)
│ └── YYYY-MM-DD Problem Title.md
├── Templates/
│ ├── problem.md — problem template
│ └── session.md — session template
├── Guides/
│ └── How to Frame a Problem.md
└── CLAUDE.md — orchestrator instructions
File and folder names are examples. The structure adapts to your tools and conventions. What matters: personas, problems, and sessions live as separate files — this lets you reuse personas, archive sessions, and resolve links.
Three Layers
- Personas — persistent cognitive archetypes. Live as files, reused across sessions. They define not what the agent thinks, but how it thinks.
- Orchestrator — manages the sequence of rounds, passes context, resolves knowledge base links. This can be a coding agent, a script, or any multi-agent framework.
- Session Store — a complete record of the discussion + artifacts. One session = one problem. Lives in your knowledge base, available for retrospective review.
Key Principles
1. Cognitive diversity > number of agents
Three agents with genuinely different ways of thinking are worth more than ten that differ only in phrasing. The minimum panel composition is about balance: constructive (see opportunities) + destructive (see holes) + neutral (see trade-offs). Typical ratio: 2 constructive + 1 destructive + 1 neutral.
Example archetypes:
- Disruptor — inverts the problem, finds workarounds, steals solutions from other industries
- Visionary — sees scale, potential, the constructive path forward
- Critic — stress-tests: pre-mortem, devil’s advocate, deconstructing assumptions
- Rationalist — calculates trade-offs, second-order consequences, evaluates strategy
These are examples, not prescriptions. A technical review needs different archetypes. A creative task — yet another set.
2. Independence in the first round
This is the most important principle. If agents see each other from the start — they anchor on the first answer and converge. The first round must be fully isolated: each agent receives the same problem but works in a vacuum. The result — a set of uncontaminated perspectives.
3. Character voice = defense against averaging
Each agent is not “an analyst with a different focus.” It’s a character with its own voice: metaphors, tone, stylistic quirks. Character voice isn’t decoration. It’s a mechanism: when the agent is “in character,” it doesn’t slide into a generic AI answer. The role protects diversity.
4. Confrontation, not politeness
The second round is a debate, not “great point, and I’d add…” Each agent gets an explicit instruction: attack the weak spots of the others, defend your own position, don’t agree out of politeness. Confrontation isn’t aggression — it’s respect for the idea: a weak idea that was never attacked is more dangerous than one that was rejected.
5. Artifacts > opinions
The consilium’s ultimate value isn’t that the agents talked. It’s the structured artifacts:
- Tension Map shows where there’s confidence and where there’s a choice to make
- Risk-scored Ideas turn proposals into scored options with failure modes
- Decision Brief gives an actionable framework: “if your priority is X — do A”
- Blind Spots surface questions that nobody asked
Without artifacts, debates are entertainment. With artifacts — a decision-making tool.
6. The problem defines the quality of the debate
Garbage in — garbage out. A vague problem (“how to become successful?”) produces vague debates. A good problem contains three elements: tension (what pulls in different directions), context (numbers, constraints, what’s been tried), frame (a specific question that sets the direction).
Workflow
Scenario A: Strategic Crossroads
“Scale the current product or pivot to a new market?”
Formulation: Describe both paths, provide numbers (current revenue, new market size, resources), state constraints (budget, team, time), link to strategic documents via references.
What to look for in artifacts: Decision Brief will give you a fork — “if your priority is growth — A, if stability — B.” Blind Spots will show which assumptions are unverified. Risk-scored Ideas will give concrete steps with ratings.
Scenario B: Stress-Testing a Plan
“We’ve decided to launch the product in 3 months. Where are the holes?”
Formulation: Describe the plan in detail, attach the timeline and dependencies. Question: “What will go wrong? Where’s the single point of failure? Which assumptions are unverified?”
What to look for: Tension Map will show where they agree (reliable) and where they diverge (risky). The Critic’s Closing Statements will point to the most likely failure scenario.
Scenario C: Creative Exploration
“How can we monetize a community without turning it into a paid club?”
Formulation: Describe the current model, audience, what members value. Don’t constrain the direction — let the agents diverge.
What to look for: The Disruptor will propose unexpected options. The Visionary will show the scale. Risk-scored Ideas will filter viable from reckless.
Solution Components
Personas
What it is: A file describing a cognitive archetype — not an instruction to “be an analyst,” but a full character profile: voice, style, thinking techniques, rules of engagement in debates.
Why character voice matters: Without it, the agent slides into generic output. Character voice is a constraint that forces the model to generate genuinely different responses, not variations of one.
Inputs: Problem description + (optionally) context from the knowledge base.
Outputs: An extended position (800-1500 words in R1, 600-1200 in R2, 5-7 key points in R3).
Balance: Minimum 3 personas, optimally 4. The ratio of constructive, destructive, and neutral — tuned to your domain.
Orchestrator
What it is: The logic that manages the sequence of rounds, passes context, and collects results.
Key requirements:
- Parallel agent execution within a single round
- Strictly sequential execution between rounds (R2 depends on R1)
- Full context passing: in R2 each agent sees their own R1 + others’ R1; in R3 — the entire discussion
- Link resolution: if the problem contains links to knowledge base files — read and include them in the prompt
- Writing each round’s results to the session file
Implementation: Can be a coding agent (Claude Code, Cursor), a Python script with API calls, or any multi-agent framework that supports parallel tasks.
Session Store
What it is: A structured file capturing the full discussion and artifacts.
Format: One file per problem. Contains: metadata (date, problem, participants), problem text, three rounds with each agent’s responses, synthesis artifacts.
Archive value: Three months later you can return to a session and see not just the decision, but the full logic of the debate — why some arguments won and others didn’t. This is institutional memory.
Synthesizer
What it is: A separate role (not one of the personas) that reads the full discussion and generates the artifacts.
Why separate: The synthesizer must be objective — not pull toward any participant. That’s why it has no persona, no character voice, no position. Only structured analysis.
Inputs: Full discussion (R1 + R2 + R3) + problem description.
Outputs: 4 artifacts.
| Artifact | Contents |
|---|---|
| Tension Map | Agreement (reliable signal), disagreement (choice zone), unique insights |
| Risk-scored Ideas | Table: idea, author, risk, failure mode, mitigation |
| Decision Brief | “If your priority is X — do A. Ready to take a risk — B. Avoid C.” |
| Blind Spots | Questions that weren’t asked but should have been |
Adaptation Questions
The agent asks these questions during the initial system setup.
Domain and Context
- What domain will you use the consilium in? (business strategy, product decisions, technical architecture, creative work, other)
- What level of problems is typical? (tactical, strategic, existential)
- What language should the debates be conducted in?
Models and Tools
- What orchestrator are you using? (Claude Code, Cursor, API script, other)
- What models are available? (important for role distribution: stronger models for constructive roles, mid-tier for destructive ones)
- Are there context window limitations? (affects response length per round)
- How many parallel requests are supported?
Personas
- Use default archetypes (disruptor, visionary, critic, rationalist) or create custom ones?
- Are there domain-specific roles? (e.g., for tech review: security expert, performance engineer)
- What tone for the debates? (aggressive, academic, direct)
Output and Integration
- Where to store sessions? (folder, format, naming convention)
- Which artifacts are most valuable to you? (you can remove/add)
- Do you need link resolution to knowledge base files?
- Will problems come as text or through template files?
Pitfalls & Edge Cases
Agents converge to a single opinion
Symptom: In R1 everyone says roughly the same thing in different words.
Cause: Weak personas. If the persona description is two paragraphs of “be creative,” the model ignores it.
Fix: The persona must be detailed: voice (tone, metaphors, stylistic quirks), thinking techniques (specific methods), rules of engagement in debates. 500+ words per persona.
Vague problem — flabby debate
Symptom: Agents reason about abstract things, give no specifics.
Cause: A problem without tension or context. “How to improve the product?” is not a problem.
Fix: Require: what pulls in different directions + numbers/constraints + a specific question. A separate guide on formulating problems is a good investment.
The Critic dominates
Symptom: Everything’s torn apart, nothing’s proposed. Other agents in R2 start making excuses.
Cause: The destructive role is too powerful, the constructive ones are too weak. Or the critic is on a stronger model than the rest.
Fix: Balance the models (constructive roles on stronger models). Add an explicit rule to the critic’s persona: “If you attack — propose an alternative.”
Synthesis loses nuance
Symptom: Artifacts look like an “average” of the discussion, not a synthesis.
Cause: The synthesizer wasn’t instructed to preserve tension. Or the discussion is too long and doesn’t fit in context.
Fix: Explicit requirement: “The Tension Map must show WHERE EXACTLY opinions diverged and what that means. Don’t smooth it over.”
Context overflow
Symptom: R3 or Synthesis can’t fit the full discussion.
Cause: Multiple agents x 3 rounds x 1000 words = ~12,000 words, plus the problem, plus knowledge base context.
Fix: Calibrate response length to the available context. R3 — key points only. For Synthesis, you can use a model with a larger context window.
Debate for debate’s sake
Symptom: The discussion is interesting, but the Decision Brief is useless.
Cause: The problem was exploration (“what do you all think?”), not decision (“A or B?”).
Fix: Distinguish two modes: exploration (Tension Map + Blind Spots) and decision (all four artifacts). Not every problem needs a Decision Brief.
Scaling
The pattern “a panel of cognitively diverse agents + rounds + artifacts” applies well beyond strategic decisions:
- Technical Review Board — architect + security expert + performance engineer + UX advocate. Stress-test architecture from four sides
- Content Review — editor + target reader + SEO analyst + brand voice guardian. Tear apart an article before publication
- Product Discovery — skeptical user + enthusiast + business analyst + engineer. Evaluate a feature
- Hiring Committee — culture fit + technical depth + growth potential + risk assessment. Structure the candidate discussion
In all cases the core is the same: independence –> confrontation –> synthesis. Only the personas and artifacts change.
Output Artifacts
When the system is initialized, the agent creates:
| Artifact | Description | How to verify |
|---|---|---|
| Persona files (3-5) | Cognitive archetype description: voice, techniques, rules | Each file 500+ words, style is unique |
| Problem template | Structure: tension + context + question | Contains formulation prompts |
| Session template | Sections for each round + artifacts | All rounds and artifacts are accounted for |
| Orchestration config | Instructions for the orchestrator: sequence, prompts, models | Run a test session on a simple problem |
| Problem formulation guide | What works, what doesn’t, examples | Reads in 5 minutes, gives a clear checklist |