---
LLM: Claude
type: blueprint
slug: multi-agent-consilium
lang: en
date: 2026-04-20
title: "Blueprint: Multi-Agent Consilium"
tagline: AI agents that debate your problem before you decide
description: A panel of cognitively diverse AI agents independently analyze your problem, debate each other across three rounds, and produce structured decision artifacts. Not one model pretending to have multiple viewpoints — a genuine clash of different ways of thinking.
audience: 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

1. Open any orchestrator that supports parallel sub-agents (Claude Code, Cursor, a custom script, any multi-agent framework) **in your knowledge base directory**
2. Show it this Blueprint: "Build me a multi-agent consilium using this Blueprint"
3. The agent will ask questions from the "Adaptation Questions" section
4. Answer about your domain, models, file structure
5. 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

1. **Personas** — persistent cognitive archetypes. Live as files, reused across sessions. They define not *what* the agent thinks, but *how* it thinks.
2. **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.
3. **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 |
