Quorum — LLM Council for VS Code

Ask every Copilot model at once. Let them debate. Get one synthesized answer.

Quorum (@quorum) fans your question out to every model in your Copilot Pro/Pro+ subscription — GPT-4o, Claude, Gemini, o3, and more — runs anonymous peer review, an adversarial rebuttal round, then synthesizes a final verdict with citations. All inside VS Code. No extra API keys. No configuration required.

Version 0.5.0 — now with live audit trail, adversarial rebuttal rounds, debate trail streaming, run history tracking, one-click audit export, research & debate profiles, large-document pipeline, URL grounding, privacy mode, Deep Debate multi-round convergence engine, and research context grounding with vision figure support.

How It Works

@quorum What are the tradeoffs between REST and GraphQL?

Stage 1 — Parallel Responses

Every model on the council answers your question simultaneously. Attach files, paste URLs, or just ask — each model gets the same full context.

Stage 2 — Anonymous Peer Review + Adversarial Rebuttal

Each model reviews the others' responses without knowing who wrote them, eliminating brand bias. Then challengers issue direct adversarial rebuttals to the primary response.

Stage 3 — Chairman Synthesis

The most capable available model reads all responses, reviews, and rebuttals, then writes the definitive answer. It flags where models agreed (high confidence) and where they diverged (worth your attention), with mandatory source citations.

Live Audit Trail (new in v0.3.0)

Every pipeline event — model completions, peer review, rebuttals, synthesis — is streamed into the chat as it happens, so you watch the debate unfold in real time.

Features

Feature	What it does
Zero setup	Uses models already in your Copilot subscription
Parallel council	All models answer simultaneously — no waiting for one to finish before the next
Anonymous peer review	Models score each other without knowing who wrote what
Adversarial rebuttal round	Challenger models directly rebut the primary model's response before synthesis
Live audit trail	Every stage streams into chat as it completes — see the debate as it unfolds
Debate trail	Optionally stream all peer reviews and adversarial rebuttals inline in chat before the synthesis — full transparency into how the answer was built
Deep Debate	Multi-round adversarial convergence engine — models stake positions, challenge each other iteratively, and the chairman arbitrates until consensus is reached or max rounds hit
Research context grounding	Point Quorum at a local folder of docs and figures — all models are automatically grounded in the material before they respond, with vision figures sent to GPT-4o / Claude / Gemini
Run history	Every run is persisted with its full audit trail, debate trail, and all model responses — survives restarts
Audit export	Export any run as a Markdown or JSON file from the Command Palette or with `@quorum /exportAudit`
Task-aware role routing	Auto-detects 8 task profiles and assigns primary/challenger/chairman roles accordingly
Research & debate profiles	Structured output enforcement — methodology, limitations, evidence tables, steelman, cross-examination, decision matrix
URL-grounded council	Include any URL in your prompt and Quorum fetches shared evidence for every model
Large-document pipeline	Chunked packet processing for documents too large for a single model pass
File & code context	Attach `.ts`, `.py`, `.md`, `.json`, or any file — every model sees it
Citation enforcement	Chairman is required to cite which model said what in the final synthesis
Privacy mode	Strict no-retention/no-training directive prepended to every model call
Live side panel	Per-model responses stream in real time in the Quorum panel
Auto model discovery	Picks up new Copilot models automatically as they roll out

Installation

From the VS Code Marketplace: Search for Quorum or visit the Marketplace page.

From a .vsix file:

Download quorum-ai-0.3.0.vsix
In VS Code: Extensions → ⋯ → Install from VSIX…

Requirements: VS Code 1.99+ · GitHub Copilot Pro or Pro+

Usage

Command	What it does
`@quorum <question>`	Run the full council
`@quorum /models`	List current council models and chairman
`@quorum /refreshModels`	Refresh roster with current filter settings
`@quorum /setProfile <profile>`	Set role-routing profile
`@quorum /setChairman <model-id>`	Change the synthesis model
`@quorum /history`	List all recorded runs — run ID, date, profile, members, token count
`@quorum /exportAudit`	Export the most recent run's full audit to a Markdown file
`@quorum /exportAudit <run-id>`	Export a specific run by run ID
`@quorum /deepDebate <question>`	Run a multi-round convergence debate on any question

Profiles: auto · coding · security · architecture · docs · analysis · research · debate

With file context: Attach a file using the paperclip icon in Copilot Chat — all models receive the file contents automatically.

With URL grounding: Paste any URL in your prompt — Quorum fetches it and injects the same content into every model's context before they respond.

Live Audit Trail

When quorum.enableAuditLog is true (default), the chat window shows a live timeline like:

🔎 Audit Trail · run 3k7x2-a9f1c

🗂️ Pipeline start — 5 models · profile: research · chairman: claude-opus-4
✅ Stage 1 — GPT-4o — responded (1,842 chars)
✅ Stage 1 — Claude 3.7 Sonnet — responded (2,104 chars)
✅ Stage 1 — Gemini 2.0 Flash — responded (1,677 chars)
✅ Stage 1 — o3 — responded (2,391 chars)
✅ Stage 1 — Mistral Large — responded (1,520 chars)
🔬 Stage 2 — Peer review — 5 models cross-reviewing anonymised responses
⚔️  Stage 2b — Adversarial rebuttal round — 4 challengers
👑 Stage 3 — Chairman synthesis — claude-opus-4 synthesizing
🏁 Pipeline complete — 5/5 succeeded · 5 reviews · 4 rebuttals · 18.4s · 48,231 tokens

Disable with "quorum.enableAuditLog": false for a cleaner output.

Debate Trail

When quorum.enableDebateTrail is true, Quorum streams the full debate into chat — all Stage 2 peer reviews and all Stage 2b adversarial rebuttals — as collapsible blocks before the chairman synthesis:

🗣️ Debate Trail

Stage 2 — Peer Reviews
  🔬 o3 peer review       ▶ (click to expand)
  🔬 gpt-4o peer review   ▶ (click to expand)
  🔬 gemini peer review   ▶ (click to expand)

Stage 2b — Adversarial Rebuttals
  ⚔️ o3 rebuttal          ▶ (click to expand)
  ⚔️ gpt-4o rebuttal      ▶ (click to expand)
  ⚔️ gemini rebuttal      ▶ (click to expand)

Useful for research documents where you want full provenance of how the synthesis was reached.

Disable with "quorum.enableDebateTrail": false (default).

Run History & Export

Every completed run is persisted to extension storage (survives VS Code restarts) with its full audit log, all Stage 1 responses, peer reviews, rebuttals, and synthesis.

Chat commands

@quorum /history

Shows a table of all stored runs with run ID, date, profile, members, and token count.

@quorum /exportAudit
@quorum /exportAudit 1hx7z-k9m2p

Exports the most recent run (or a specific run by ID) as a Markdown file — opens a Save dialog.

Command Palette

Command	Action
Quorum: Export Last Run Audit (Markdown)	Export the most recent run as `.md`
Quorum: Export Last Run Audit (JSON)	Export the most recent run as `.json`
Quorum: Export Run from History	QuickPick from all stored runs → choose Markdown or JSON → Save dialog
Quorum: Clear Run History	Wipe all stored runs (with confirmation)

Export format

Markdown — a human-readable document with question, audit trail, per-model Stage 1 responses, peer reviews, rebuttals, and synthesis. Ready to commit to a repo or share as a report.

JSON — the full raw RunRecord object — useful for programmatic processing, diffing runs, or building your own tooling on top.

Task Profiles

Quorum auto-detects task profile from your prompt (quorum.taskProfile: "auto"), or you can set it manually.

Profile	Best for	Roles
`coding`	Code review, debugging, refactoring	Code-specialist primary, diverse challengers
`security`	Threat modeling, CVE review, auth	Security-focused primary
`architecture`	System design, tradeoffs	Architecture-specialist primary
`docs`	Documentation, README, API docs	Writing-specialist primary
`analysis`	Data, research analysis, SWOT	Analytical primary
`research`	Academic synthesis, literature review	Evidence + methodology enforcement
`debate`	Controversial decisions, tradeoffs	Steelman + cross-examination enforcement
`auto`	Everything else	Automatically infers the above

Override per-profile model roles in quorum.profileConfigs:

"quorum.profileConfigs": {
  "security": {
    "primary": "o3",
    "challengers": ["claude-opus-4", "gpt-4o"],
    "chairman": "o3"
  }
}

Research Profile Output Structure

When research profile is active, every Stage 1 response is required to include:

Methodology — how claims were arrived at
Limitations — what the model is uncertain about
Evidence Table — key claims with supporting evidence

Toggle each requirement via quorum.researchRequire* settings.

Debate Profile Output Structure

When debate profile is active, every Stage 1 response includes:

Steelman — the strongest version of the opposing position
Cross-Examination — direct challenges to the other side
Decision Matrix — structured comparison of options

Toggle each requirement via quorum.debateRequire* settings.

URL Grounding

Include any http:// or https:// URL in your prompt and Quorum will:

Fetch each URL once (up to quorum.maxFetchedUrls)
Strip HTML to plain text
Trim to quorum.maxFetchedUrlChars
Inject the same fetched content into every model's context before they respond

This gives the entire council a shared factual ground before the debate.

Large-Document Pipeline

When attached context exceeds quorum.pipelineTriggerChars (default 18,000 chars), Quorum activates a per-model packet pipeline:

Splits context into chunks (quorum.pipelineChunkChars, max quorum.pipelineMaxChunks)
Each model analyzes each chunk
Each model synthesizes across its own chunk findings
Council peer review, rebuttal, and chairman synthesis continue as normal

This lets you analyze full research papers, large codebases, or long notes without hitting context limits.

Privacy Mode

When quorum.privacyMode is true (default), Quorum prepends a strict directive to every model call requesting:

No retention of prompts or responses after generation
No use for model training or fine-tuning
No non-essential telemetry

For stricter behavior, enable quorum.privacyDisableUrlFetch to prevent any external URL fetching.

All Settings

Core

Setting	Default	Description
`quorum.chairman`	`auto`	Model ID for synthesis. `auto` picks the best available
`quorum.members`	`[]`	Explicit model IDs to use (in listed order)
`quorum.includeModels`	`[]`	Only include models whose IDs match these substrings
`quorum.excludeModels`	`[]`	Remove models from the council by ID substring
`quorum.modelDisplayNames`	`{}`	Override display labels by model-id substring
`quorum.maxModels`	`6`	Max models on the council

Task Routing

Setting	Default	Description
`quorum.taskProfile`	`auto`	Role-routing profile — `auto` infers from prompt
`quorum.profileStrict`	`false`	Only use profile-assigned models (ignore extras)
`quorum.profileConfigs`	`{}`	Per-profile role overrides (`primary`, `challengers`, `chairman`)

Pipeline Behaviour

Setting	Default	Description
`quorum.skipPeerReview`	`false`	Skip Stage 2 for faster results
`quorum.enableAuditLog`	`true`	Stream live audit trail into chat as each stage completes
`quorum.enableDebateTrail`	`false`	Stream all peer reviews and rebuttals as collapsible blocks before synthesis
`quorum.requireCitations`	`true`	Chairman must cite which model said what
`quorum.enableRebuttalRound`	`true`	Challenger models rebut the primary response before synthesis
`quorum.enableRunHistory`	`true`	Persist each run's full audit and responses to extension storage
`quorum.maxRunHistory`	`50`	Maximum stored runs — oldest are dropped when limit is exceeded
`quorum.researchContextPath`	`""`	Absolute path to a folder of docs + images auto-loaded as grounding context for all models
`quorum.deepDebateMinRounds`	`2`	Minimum rounds before convergence checking starts in `/deepDebate`
`quorum.deepDebateMaxRounds`	`8`	Maximum rounds — debate stops here even without formal convergence
`quorum.enableContextPipeline`	`true`	Chunked pipeline for large context documents
`quorum.pipelineTriggerChars`	`18000`	Prompt length threshold that activates packet pipeline
`quorum.pipelineChunkChars`	`7000`	Approximate chunk size for pipeline processing
`quorum.pipelineMaxChunks`	`6`	Maximum chunks processed per model

Profile Output Styles

Setting	Default	Description
`quorum.enableProfilePromptStyles`	`true`	Enable profile-specific output structure enforcement
`quorum.researchRequireMethodology`	`true`	Research profile: require Methodology section
`quorum.researchRequireLimitations`	`true`	Research profile: require Limitations section
`quorum.researchRequireEvidenceTable`	`true`	Research profile: require Evidence Table
`quorum.debateRequireSteelman`	`true`	Debate profile: require steelman of both sides
`quorum.debateRequireCrossExamination`	`true`	Debate profile: require Cross-Examination section
`quorum.debateRequireDecisionMatrix`	`true`	Debate profile: require Decision Matrix

URL Fetching

Setting	Default	Description
`quorum.enableUrlFetch`	`true`	Fetch plain-text context from URLs found in the prompt
`quorum.maxFetchedUrls`	`3`	Maximum URLs fetched per prompt
`quorum.maxFetchedUrlChars`	`6000`	Max characters retained per fetched URL
`quorum.urlFetchTimeoutMs`	`12000`	Per-URL fetch timeout in milliseconds

Privacy

Setting	Default	Description
`quorum.privacyMode`	`true`	Prepend no-retention/no-training directive to all model prompts
`quorum.privacyDisableUrlFetch`	`false`	Disable URL fetching while privacy mode is on
`quorum.privacyDirective`	(string)	Custom privacy directive text prepended to every prompt

Context & Performance

Setting	Default	Description
`quorum.maxContextChars`	`22000`	Max total context characters per prompt
`quorum.maxContextItemChars`	`5000`	Max characters per attached item before excerpting
`quorum.contextHeadExcerptChars`	`2200`	Head excerpt size for large attachments
`quorum.contextTailExcerptChars`	`1600`	Tail excerpt size for large attachments
`quorum.retryPromptBudgets`	`[36000,22000,14000]`	Fallback prompt budgets on token-limit errors
`quorum.maxStage2ResponseChars`	`1600`	Max Stage 1 chars passed into peer review
`quorum.maxStage3ResponseChars`	`2200`	Max Stage 1 chars passed into synthesis
`quorum.maxStage3ReviewChars`	`1200`	Max Stage 2 review chars passed into synthesis

Why Quorum?

A single model has a single perspective, a single training distribution, and a single set of blind spots. Quorum routes your question to every model simultaneously and makes them critique each other before a chairman synthesizes the best answer. You get:

Consensus signal — when all models agree, you can act with confidence
Divergence signal — when they disagree, Quorum flags it so you know what needs your judgment
Adversarial pressure — the rebuttal round forces each model to defend its position or concede
No single-model hallucination — one model's error is caught by the others in peer review
Task-matched intelligence — the right model leads depending on whether you're writing code, reviewing a threat model, or doing academic research

Built by PSTechlabs · Developer tools at programmershop.in

Changelog

v0.5.0

Deep Debate — /deepDebate <question> runs a multi-round convergence-based debate: models stake opening positions, chairman picks the strongest challenge each round, all models respond and evolve their stance, convergence checked after deepDebateMinRounds
Research context grounding — quorum.researchContextPath points to a local docs folder; Markdown files are loaded (token-budget-limited) and figures are sent as vision context to GPT-4o / Claude / Gemini automatically
Full debate transcript in run history — /deepDebate runs save every round's positions, selected challenges, and convergence verdicts; exportable via /exportAudit
quorum.deepDebateMinRounds / quorum.deepDebateMaxRounds — tune the convergence window
quorum.researchContextPath — zero-config research grounding for long-running projects

v0.4.0

Debate trail — stream all peer reviews and rebuttals inline before synthesis (quorum.enableDebateTrail)
Run history — every run persisted with full audit, debate trail, and all model responses (quorum.enableRunHistory, quorum.maxRunHistory)
Audit export — Command Palette and @quorum /exportAudit export any run as Markdown or JSON
@quorum /history — list all stored runs in chat
@quorum /exportAudit [run-id] — export a run directly from chat

v0.3.0

Live audit trail streaming
Adversarial rebuttal round (Stage 2b)
Research & debate profile output enforcement
Large-document context pipeline
URL grounding
Privacy mode

Quorum

PS Techlabs