quorum
Multi-agent AI discussion CLI for structured debates between LLMs
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Badge for your README
Markdown
[](/listings/detrol--quorum-cli)HTML
<a href="/listings/detrol--quorum-cli"><img src="/api/listings/detrol--quorum-cli/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
pip install quorum-cli quorum
On first run, Quorum creates `~/.quorum/.env.example`. Copy and edit it:
cp ~/.quorum/.env.example ~/.quorum/.env nano ~/.quorum/.env # Add your API keys quorum
**Upgrade:** `pip install -U quorum-cli`
**Requirements:** Python 3.11+, Node.js 18+
---
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
.claude-plugin/marketplace.json · Manifest · 17 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- {
- "name": "quorum",
- "owner": {
- "name": "Detrol",
- "url": "https://github.com/Detrol"
- },
- "metadata": {
- "description": "Quorum: multi-agent debates for Claude Code and Codex."
- },
- "plugins": [
- {
- "name": "quorum",
- "source": "./",
- "description": "Multi-agent debates between claude, codex, agy and grok via MCP."
- }
- ]
- }
README.md · README · 904 lines · 1 finding marked
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- # Quorum
- <p align="center">
- <img src="docs/demo.gif" alt="Quorum - AI models debating in terminal" width="700">
- </p>
- <p align="center">
- <strong>🌐 Web Version Now Available! Try Quorum in your browser at <a href="https://quorumai.dev">quorumai.dev</a></strong>
- </p>
- <p align="center">
- <strong>AI War Room in your terminal.</strong><br>
- Watch GPT, Claude, Gemini, and Grok debate using formal methods.<br>
- <em>Now a Claude Code & Codex plugin for debates between agent CLIs.</em>
- </p>
- <p align="center">
- <a href="https://github.com/Detrol/quorum-cli/actions/workflows/ci.yml"><img src="https://github.com/Detrol/quorum-cli/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
- <a href="LICENSE"><img src="https://img.shields.io/badge/License-BSL_1.1-blue.svg" alt="License"></a>
- <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.11+-blue.svg" alt="Python 3.11+"></a>
- </p>
- ---
- Multi-agent AI discussion system for structured debates. Ask multiple AI models (Claude, GPT, Gemini, Grok, and local models via Ollama) a question and let them debate, brainstorm, or deliberate using seven different methods.
- ## Quick Install (pip)
- ```bash
- pip install quorum-cli
- quorum
- ```
- On first run, Quorum creates `~/.quorum/.env.example`. Copy and edit it:
- ```bash
- cp ~/.quorum/.env.example ~/.quorum/.env
- nano ~/.quorum/.env # Add your API keys
- quorum
- ```
- **Upgrade:** `pip install -U quorum-cli`
- **Requirements:** Python 3.11+, Node.js 18+
- ---
- ## Claude Code & Codex plugin (MCP)
- Ask your coding agent for a Quorum and it runs a structured debate between the models you choose:
- - **Agent CLIs** you have installed: **claude**, **codex**, **agy** (Antigravity) and **grok**. Each runs
- on your own subscription and needs no API key. They can read your project (read-only) and use the
- web, isolated from your hooks, plugins and instruction files.
- - **API and local models** from your `~/.quorum/.env` (see [Configuration](#configuration)): OpenAI,
- Anthropic, Google, xAI, OpenRouter, LM Studio, llama-swap, custom endpoints and Ollama. They see the
- question and any files passed with it, but have no tool access.
- Agents and API models can take part in the same discussion.
- ```bash
- # Claude Code
- claude plugin marketplace add Detrol/quorum-cli
- claude plugin install quorum@quorum
- # Codex
- codex plugin marketplace add Detrol/quorum-cli
- codex plugin add quorum@quorum
- ```
- The plugin starts the server with `uvx --from quorum-cli quorum-mcp-server`, so [uv](https://github.com/astral-sh/uv)
- must be on PATH. Without the plugin, after `pip install quorum-cli`, you can still register the server
- yourself: `claude mcp add quorum --scope user -- quorum-mcp-server`.
- Then ask, for example:
- > "Run a Quorum on whether we should split this service"
- Before it starts, you get a form: one dropdown per available provider (off, or a model with an
- effort level) and one for the discussion method, preset to your last lineup. Clients without form
- support (MCP elicitation) ask in chat instead.
- **MCP tools:**
- - `quorum_list_models` - Providers with status, models, roles and effort levels
- - `quorum_start` - Start a run with `provider:model@effort` participants (e.g. `claude:opus@high`, `openai:gpt-5.5@medium`, `ollama:qwen3:8b`), any of the 7 methods
- - `quorum_wait` - Poll a run in slices until the synthesis is ready (safe under client tool timeouts)
- - `quorum_check` - Real ping to every agent CLI
- - `quorum_discuss` - Deprecated v1.1 interface (blocking; bare model ids from `*_MODELS` still work)
- **Configuration:** the server always reads `~/.quorum/.env`, never a `.env` in the project you are
- working in. `*_MODELS` lists and Ollama auto-discovery work as in the TUI, and so do `QUORUM_METHOD`,
- `QUORUM_SYNTHESIZER`, `QUORUM_ROUNDS_PER_AGENT` and `QUORUM_EXECUTION_MODE`. Responses match the
- question's language. Effort maps to `reasoning_effort` (OpenAI, Google, xAI) and to adaptive thinking
- with effort (Anthropic). It is only sent when you choose one, because models without reasoning
- support reject it.
- **Defaults:** at most 4 participants, 10 min per turn, 30 min per run, one run per project at a time.
- Transcripts are saved to `~/.quorum/runs/`.
- ---
- ## Development Installation
- For contributors or those who want the latest changes:
- ### Requirements
- - Python 3.11 or higher
- - Node.js 18 or higher
- - npm
- - [uv](https://github.com/astral-sh/uv) (auto-installed if missing)
- ### Linux / macOS
- ```bash
- git clone https://github.com/Detrol/quorum-cli.git
- cd quorum-cli
- ./install.sh
- nano .env # Add your API keys
- ./quorum
- ```
- ### Windows
- ```cmd
- git clone https://github.com/Detrol/quorum-cli.git
- cd quorum-cli
- install.bat
- notepad .env & REM Add your API keys
- quorum.bat
- ```
- ### Manual installation
- ```bash
- # Install uv if not present
- pip install uv
- # Python dependencies (creates .venv automatically)
- uv sync
- # Frontend
- cd frontend && npm install && npm run build && cd ..
- # Configuration
- cp .env.example .env # Linux/macOS
- copy .env.example .env # Windows
- ```
- ## Configuration
- Edit `.env` and add your API keys:
- ```bash
- # OpenAI - https://platform.openai.com/api-keys
- OPENAI_API_KEY=sk-...
- OPENAI_MODELS=gpt-5.2,gpt-5.1,gpt-5
- # Anthropic - https://console.anthropic.com/settings/keys
- ANTHROPIC_API_KEY=sk-ant-...
- ANTHROPIC_MODELS=claude-opus-4-5-20251124,claude-sonnet-4-5-20250929
- # Google - https://aistudio.google.com/apikey
- GOOGLE_API_KEY=...
- GOOGLE_MODELS=gemini-3-pro,gemini-2.5-flash
- # xAI (Grok) - https://console.x.ai/
- XAI_API_KEY=xai-...
- XAI_MODELS=grok-4.1,grok-4
- # Ollama (local models) - https://ollama.com/
- # Models are auto-discovered, no config needed for same-machine setup
- # OLLAMA_BASE_URL=http://localhost:11434 # Default, change for remote
- # OLLAMA_API_KEY= # Optional, for proxy authentication
- # Optional settings
- QUORUM_ROUNDS_PER_AGENT=2 # Discussion rounds per agent (1-10, default: 2)
- QUORUM_SYNTHESIZER=first # Who synthesizes: first, random, or rotate
- QUORUM_DEFAULT_LANGUAGE= # Force response language (e.g., "Swedish", "English")
- # QUORUM_EXECUTION_MODE=auto # VRAM optimization: auto, parallel, sequential
- ```
- You only need to configure the providers you want to use. At least one provider is required.
- ### Finding available models
- - **OpenAI**: https://platform.openai.com/docs/models
- - **Anthropic**: https://docs.anthropic.com/en/docs/about-claude/models
- - **Google**: https://ai.google.dev/gemini-api/docs/models
- - **xAI (Grok)**: https://docs.x.ai/docs/models
- - **Ollama**: https://ollama.com/library
- ### Ollama (Local Models)
- Quorum supports local models via [Ollama](https://ollama.com/). Models are auto-discovered when Ollama is running.
- **Quick start:**
- ```bash
- # 1. Install Ollama from https://ollama.com/download
- # 2. Pull a model
- ollama pull llama3
- # 3. Start Quorum - Ollama models appear automatically in /models
- ```
- Models appear with `ollama:` prefix (e.g., `ollama:llama3`, `ollama:qwen3:8b`).
- **VRAM management:** When using multiple Ollama models, Quorum automatically runs them sequentially to prevent VRAM competition. No configuration needed - it just works. See [Execution Mode](#execution-mode-vram-optimization) for advanced options.
- ### OpenAI-Compatible Providers
- Quorum supports any service that uses the OpenAI API format. This lets you use OpenRouter, LM Studio, llama-swap, vLLM, LocalAI, and other compatible servers alongside native providers.
- **OpenRouter** - Access 200+ models through one API:
- ```bash
- OPENROUTER_API_KEY=sk-or-v1-...
- OPENROUTER_MODELS=anthropic/claude-3-opus,openai/gpt-4o,meta-llama/llama-3.1-70b
- ```
- **LM Studio** - Local models with a GUI (no API key required):
- ```bash
- LMSTUDIO_MODELS=llama-3.2-3b,deepseek-coder-v2
- # LMSTUDIO_BASE_URL=http://localhost:1234/v1 # Default
- ```
- **llama-swap** - Hot-swap between local models:
- ```bash
- LLAMASWAP_BASE_URL=http://localhost:8080/v1
- LLAMASWAP_MODELS=llama3,mistral-7b,qwen2
- ```
- **Custom endpoint** - Any OpenAI-compatible server:
- ```bash
- CUSTOM_BASE_URL=http://localhost:5000/v1
- CUSTOM_MODELS=model-name-1,model-name-2
- CUSTOM_API_KEY=your-key # If required
- ```
- Models from these providers appear in `/models` just like native providers. You can use them together with OpenAI, Anthropic, Google, xAI, and Ollama in the same discussion.
- **Configuration scenarios:**
- | Quorum runs on | Ollama runs on | Configuration |
- |----------------|----------------|---------------|
- | Windows | Windows | Works out of the box |
- | Linux | Linux | Works out of the box |
- | WSL | WSL | Works out of the box |
- | WSL | Windows | See [WSL + Windows Ollama](#wsl--windows-ollama) below |
- | Any | Remote server | Set `OLLAMA_BASE_URL` in `.env` |
- **Remote Ollama server:**
- ```bash
- # In .env
- OLLAMA_BASE_URL=http://your-server:11434
- OLLAMA_API_KEY=your-key # Optional, if using authentication proxy
- ```
- ## Usage
- ### Start Quorum
- ```bash
- quorum
- ```
- ### Select models
- ```
- > /models
- OPENAI
- [1] gpt-5.2
- [2] gpt-5.1
- ANTHROPIC
- [3] claude-opus-4-5-20251124
- [4] gemini-3-pro
- Select models (comma-separated): 1,3,4
- ✓ Selected: gpt-5.2, claude-opus-4-5-20251124, gemini-3-pro
- ```
- ### Ask a question
- ```
- > What is the best programming language for beginners?
- ╭─ gpt-5.2 ─────────────────────────────────────────╮
- │ I would recommend Python for beginners... │
- ╰───────────────────────────────────────────────────╯
- ╭─ claude-opus-4-5-20251124 ────────────────────────╮
- │ I agree with the recommendation of Python... │
- │ CONSENSUS: Python is the best choice because... │
- ╰───────────────────────────────────────────────────╯
- ╭─ gemini-3-pro ────────────────────────────────────╮
- │ CONSENSUS: Python is recommended for beginners... │
- ╰───────────────────────────────────────────────────╯
- ──────────────────────────────────────────────────────
- ╭─ Result ──────────────────────────────────────────╮
- │ CONSENSUS REACHED! │
- │ │
- │ All 3 agents agreed. │
- │ Messages exchanged: 3 │
- │ │
- │ Final Answer: │
- │ Python is recommended for beginners... │
- ╰───────────────────────────────────────────────────╯
- ```
- ### Commands
- | Command | Description |
- |---------|-------------|
- | `/models` | Select AI models for discussion |
- | `/method [name]` | Show or set discussion method |
- | `/advisor` or **Tab** | Get AI-powered method recommendation |
- | `/synthesizer` | Set synthesizer mode (first/random/rotate) |
- | `/status` | Show current settings |
- | `/export [format]` | Export discussion (md, text, pdf, json) |
- | `/clear` | Clear screen |
- | `/help` | Show help |
- | `/quit` or `/exit` | Exit Quorum |
- ## Discussion Methods
- Quorum supports seven discussion methods that change how the discussion phase works. Each method has specific requirements for the number of models.
- ### Standard (default)
- **Requires:** 2+ models
- Balanced consensus-seeking discussion. All models discuss freely in a round-robin format, building on each other's ideas and critiques to find common ground.
- **How it works:**
- - Models take turns responding to the ongoing discussion
- - Each model sees all previous answers and critiques
- - Focus is on collaboration and synthesis
- **Flow:**
- ```
- Phase 1 Phase 2 Phase 3 Phase 4 Phase 5
- ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
- │ Answer │ → │Critique │ → │ Discuss │ → │Position │ → │Synthesis│
- │(parallel)│ │(parallel)│ │(turns) │ │(parallel)│ │(single) │
- └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘
- All models Review each Round-robin Final stance Synthesizer
- respond other's work discussion + confidence aggregates
- ```
- **Best for:** General questions, collaborative problem-solving, finding balanced answers.
- ```
- > What's the best approach to error handling in this codebase?
- ```
- ---
- ### Oxford
- **Requires:** Even number of models (2, 4, 6...)
- Formal Oxford-style debate with assigned positions. Models are divided into FOR and AGAINST teams and must argue their assigned position regardless of personal opinion.
- **How it works:**
- 1. **Opening statements** - Each side presents their strongest case
- 2. **Rebuttals** - Directly address and counter the opposing side's arguments
- 3. **Closing statements** - Summarize position and make final case
- Models are assigned roles by index:
- - Even indices (0, 2, 4...) argue **FOR**
- - Odd indices (1, 3, 5...) argue **AGAINST**
- **Flow:**
- ```
- Phase 1 Phase 2 Phase 3 Phase 4
- ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
- │ Opening │ → │ Rebuttals │ → │ Closing │ → │ Synthesis │
- │Statements │ │ │ │Statements │ │ │
- └───────────┘ └───────────┘ └───────────┘ └───────────┘
- FOR presents FOR counters FOR summarizes Judge decides
- AGAINST presents AGAINST counters AGAINST summarizes winner
- ```
- **Best for:** Binary decisions, exploring both sides thoroughly, devil's advocate analysis.
- ```
- > /oxford Should we migrate to microservices or keep the monolith?
- ```
- ---
- ### Advocate
- **Requires:** 3+ models
- Devil's advocate mode. The system analyzes the emerging consensus from Phase 1-2, then designates one model (the last one) to challenge that consensus while others defend it.
- **How it works:**
- 1. AI analyzes initial answers to identify the majority position
- 2. The last model becomes the "devil's advocate"
- 3. Advocate challenges the consensus, finding flaws and edge cases
- 4. Other models must defend and justify their reasoning
- **Flow:**
- ```
- Phase 1 Phase 2 Phase 3
- ┌─────────────┐ ┌─────────────────┐ ┌─────────────┐
- │ Positions │ → │Cross-Examination│ → │ Synthesis │
- │ │ │ │ │ │
- └─────────────┘ └─────────────────┘ └─────────────┘
- Defenders state Advocate challenges Final verdict
- their views each defender with analysis
- ```
- **Best for:** Stress-testing ideas, avoiding groupthink, critical analysis, finding weaknesses.
- ```
- > /advocate Is our authentication system secure enough?
- ```
- ---
- ### Socratic
- **Requires:** 2+ models
- Question-driven Socratic dialogue. Instead of stating positions, models take turns as the "questioner" who probes assumptions and reasoning.
- **How it works:**
- 1. Each round, one model becomes the **Questioner**
- 2. The Questioner asks ONE probing question targeting a specific claim
- 3. All other models respond as **Respondents**
- 4. The Questioner role rotates each round
- **Flow:**
- ```
- Phase 1 Phase 2 Phase 3
- ┌───────────┐ ┌──────────────┐ ┌───────────┐
- │ Thesis │ → │ Elenchus │ → │ Synthesis │
- │ │ │ (Q&A Rounds)│ │ │
- └───────────┘ └──────────────┘ └───────────┘
- Respondent Questioners probe Refined
- states view assumptions understanding
- ```
- **Best for:** Deep exploration, exposing hidden assumptions, understanding complex topics, learning.
- ```
- > /socratic What assumptions are we making about user behavior?
- ```
- ---
- ### Delphi
- **Requires:** 3+ models
- Iterative consensus-building for estimates and forecasts. Models provide independent estimates, then revise after seeing others' reasoning across multiple rounds.
- **How it works:**
- 1. **Round 1** - Each model provides an independent estimate with confidence level
- 2. **Round 2** - Models see anonymized group estimates and may revise
- 3. **Round 3** - Final revision opportunity before aggregation
- 4. **Synthesis** - Aggregates final estimates into consensus range
- **Flow:**
- ```
- Phase 1 Phase 2 Phase 3 Phase 4
- ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
- │ Round 1 │ → │ Round 2 │ → │ Round 3 │ → │ Aggregate │
- │ Estimates │ │ Revisions │ │ Final Rev │ │ Consensus │
- └───────────┘ └───────────┘ └───────────┘ └───────────┘
- Independent See group, Last chance Synthesize
- estimates may revise to revise final range
- ```
- **Best for:** Time estimates, cost projections, risk assessments, quantitative forecasting.
- ```
- > /delphi How long would it take to migrate this codebase to Python 3?
- ```
- ---
- ### Brainstorm
- **Requires:** 2+ models
- Creative ideation with three distinct phases. Models generate wild ideas without judgment, then build on each other's concepts before converging on the best options.
- **How it works:**
- 1. **Diverge** - Generate as many ideas as possible, no criticism allowed
- 2. **Build** - Combine and expand on the most promising ideas from others
- 3. **Converge** - Evaluate and select the top 3 ideas with justification
- **Flow:**
- ```
- Phase 1 Phase 2 Phase 3 Phase 4
- ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
- │ Diverge │ → │ Build │ → │ Converge │ → │ Synthesis │
- │ │ │ │ │ │ │ │
- └───────────┘ └───────────┘ └───────────┘ └───────────┘
- Generate wild Combine and Evaluate and Present top
- ideas, no expand on select top 3 ideas with
- judgment others' ideas ideas details
- ```
- **Best for:** Creative problem-solving, feature ideation, exploring possibilities, innovation.
- ```
- > /brainstorm How might we improve user onboarding?
- ```
- ---
- ### Tradeoff
- **Requires:** 2+ models
- Structured comparison of alternatives using explicit criteria. Models define options, establish evaluation dimensions, score each option, then synthesize a recommendation.
- **How it works:**
- 1. **Frame** - Define the alternatives to compare
- 2. **Criteria** - Establish evaluation dimensions with weights
- 3. **Evaluate** - Score each alternative on each criterion (1-10)
- 4. **Synthesize** - Recommend based on weighted analysis
- **Flow:**
- ```
- Phase 1 Phase 2 Phase 3 Phase 4
- ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
- │ Frame │ → │ Criteria │ → │ Evaluate │ → │ Recommend │
- │ │ │ │ │ │ │ │
- └───────────┘ └───────────┘ └───────────┘ └───────────┘
- Define the Establish Score each Synthesize
- alternatives evaluation alternative recommendation
- to compare dimensions (1-10 scale) with tradeoffs
- ```
- **Best for:** Technology choices, architecture decisions, vendor selection, A vs B comparisons.
- ```
- > /tradeoff Should we use PostgreSQL or MongoDB for this project?
- ```
- ---
- ### Method Requirements Summary
- | Method | Models Required | Role Assignment |
- |--------|-----------------|-----------------|
- | Standard | 2+ | Equal participation |
- | Oxford | 2, 4, 6... (even) | FOR / AGAINST teams |
- | Advocate | 3+ | 1 challenger + defenders |
- | Socratic | 2+ | Rotating questioner |
- | Delphi | 3+ | Anonymous panelists |
- | Brainstorm | 2+ | Equal ideators |
- | Tradeoff | 2+ | Equal evaluators |
- ---
- ### When to Use Each Method
- Choose your method based on the type of question:
- | Method | Best For | Example Questions |
- |--------|----------|-------------------|
- | **Standard** | Technical questions, best practices, problem-solving | "How should we handle errors?", "What architecture fits this use case?" |
- | **Oxford** | Binary decisions, controversial topics, pros/cons analysis | "Motion: We should migrate to microservices", "Motion: AI should be regulated" |
- | **Advocate** | Consensus-prone topics where critical thinking is needed | "Is our security good enough?", "Should we use TypeScript?" |
- | **Socratic** | Philosophical questions, exploring definitions and assumptions | "What is good code?", "What assumptions are we making about users?" |
- | **Delphi** | Estimates, forecasts, quantitative predictions | "How long will migration take?", "What's the project risk level?" |
- | **Brainstorm** | Creative ideation, exploring possibilities, innovation | "How might we improve UX?", "What features should we add?" |
- | **Tradeoff** | Technology choices, A vs B decisions, vendor selection | "PostgreSQL or MongoDB?", "AWS or GCP for this workload?" |
- **Tips:**
- - **Not sure?** Press **Tab** to get AI-powered method recommendations based on your question
- - Use **Standard** as your default for most technical discussions
- - Use **Oxford** with "Motion:" prefix to signal a formal debate proposition
- - Use **Advocate** when you suspect everyone will agree too easily — it forces critical scrutiny
- - Use **Socratic** when there's no clear right/wrong answer and you want to explore deeper
- - Use **Delphi** when you need a numerical estimate or forecast with confidence ranges
- - Use **Brainstorm** when you want creative ideas without early criticism
- - Use **Tradeoff** when comparing specific alternatives with clear criteria
- ---
- ### Selecting a Method
- **Via config (.env):**
- ```bash
- QUORUM_METHOD=oxford
- ```
- **Via command (session override):**
- ```
- > /method oxford
- ✓ Method set to: oxford
- ```
- **Via inline syntax (one-time use):**
- ```
- > /oxford Should we use microservices or a monolith?
- > /advocate Is this architecture scalable?
- > /socratic What assumptions are we making?
- > /delphi How long will this refactoring take?
- > /brainstorm How can we improve performance?
- > /tradeoff React vs Vue for this project?
- ```
- **Via AI advisor (recommended for new users):**
- Press **Tab** to analyze your question and get method recommendations.
- **Note:** If you try to use a method with an incompatible number of models, Quorum will show an error:
- ```
- > /oxford What should we do?
- Error: Oxford requires an even number of models for balanced FOR/AGAINST teams
- ```
- ---
- ### Method Advisor
- **Not sure which method to use?** Press **Tab** to get AI-powered recommendations based on your question. The Method Advisor analyzes your question and suggests the most suitable discussion method with confidence scores.
- **How it works:**
- 1. Press **Tab** in the input field
- 2. Enter your question (or press Enter if already typed)
- 3. Review AI recommendations with confidence scores
- 4. Select the recommended method or choose an alternative
- 5. Press Esc to cancel and return to manual selection
- **Example:**
- ```
- Press Tab → Opens Method Advisor
- METHOD ADVISOR
- What's your question?
- › How long will it take to migrate our database to PostgreSQL?
- [Analyzing with gpt-5.1...]
- RECOMMENDED:
- ● Delphi (95%)
- Best for time estimates and forecasts. Multiple models provide
- independent estimates, then revise based on group feedback to
- converge on a consensus range.
- ○ Tradeoff (70%)
- Could work if comparing PostgreSQL migration strategies
- ○ Standard (60%)
- Fallback for general technical discussion
- ↑↓ Navigate • Enter Select • Backspace Back • Esc Cancel
- ```
- **Key features:**
- - Uses your first validated model as the analyzer
- - Returns primary recommendation plus 1-2 alternatives
- - Includes confidence scores (0-100) and reasoning
- - Requires at least one validated model to work
- - Smart method selection based on question patterns
- **Keyboard shortcuts:**
- - **Tab** - Open Method Advisor
- - **Enter** - Analyze question / Select method
- - **↑/↓** - Navigate recommendations
- - **Backspace** - Return to question input
- - **Esc** - Cancel and close advisor
- ---
- ## Advanced Settings
- ### Synthesizer Mode
- Controls which model creates the final synthesis:
- | Mode | Behavior |
- |------|----------|
- | `first` | First selected model always synthesizes (default) |
- | `random` | Random model chosen each time |
- | `rotate` | Cycles through models across discussions |
- ```bash
- # In .env
- QUORUM_SYNTHESIZER=rotate
- ```
- ### Discussion Length
- `QUORUM_ROUNDS_PER_AGENT` controls how many turns each model gets in the discussion phase. Higher values = longer, deeper discussions but more API costs.
- | Setting | Effect |
- |---------|--------|
- | `1` | Quick discussions, 1 turn per model |
- | `2` | Default, balanced depth |
- | `3-5` | Extended discussions for complex topics |
- ### Response Language
- By default, Quorum matches the language of your question. Use `QUORUM_DEFAULT_LANGUAGE` to force all responses in a specific language:
- ```bash
- # Force Swedish responses
- QUORUM_DEFAULT_LANGUAGE=Swedish
- # Force English responses
- QUORUM_DEFAULT_LANGUAGE=English
- ```
- ### Execution Mode (VRAM Optimization)
- When running multiple local Ollama models, they compete for GPU VRAM which can cause crashes or slowdowns. Quorum handles this automatically:
- | Mode | Behavior |
- |------|----------|
- | `auto` | **Default.** Cloud APIs run in parallel, Ollama runs sequentially |
- | `parallel` | Always run all models simultaneously (cloud-only setups) |
- | `sequential` | Always run models one at a time (safest for limited VRAM) |
- ```bash
- # In .env (usually not needed - auto works for most users)
- QUORUM_EXECUTION_MODE=auto
- ```
- **Note:** With `auto` mode (default), you don't need to configure anything. Quorum automatically detects Ollama models and runs them sequentially to prevent VRAM competition.
- ### UI Language
- The terminal UI is available in 6 languages, controlled by `QUORUM_DEFAULT_LANGUAGE`:
- | Language | Values |
- |----------|--------|
- | English | `en`, `English` (default) |
- | Swedish | `sv`, `Swedish`, `Svenska` |
- | German | `de`, `German`, `Deutsch` |
- | French | `fr`, `French`, `Francais` |
- | Spanish | `es`, `Spanish`, `Espanol` |
- | Italian | `it`, `Italian`, `Italiano` |
- ### Discussion Logging & Export
- Quorum supports two ways to save discussions:
- **Manual export** - Use the `/export` command to save the current discussion:
- ```bash
- /export # Export with default format (md)
- /export md # Markdown format
- /export text # Plain text (for social media)
- /export pdf # PDF format
- /export json # JSON format (for ML/RAG pipelines)
- ```
- Configure default export location and format:
- ```bash
- QUORUM_EXPORT_DIR=~/.quorum/exports # Directory (default: home)
- QUORUM_EXPORT_FORMAT=md # Default format: md, text, pdf, json
- ```
- | Format | Best For |
- |--------|----------|
- | `md` | GitHub, Discord, documentation |
- | `text` | Social media, plain copy-paste |
- | `pdf` | Formatted sharing, printing |
- | `json` | ML training data, RAG datasets, API integrations |
- **Auto-save** - All discussions are automatically saved as markdown. Configure the directory:
- ```bash
- # Auto-save directory (default: ~/reports)
- QUORUM_REPORT_DIR=~/reports
- ```
- Files are saved as `quorum-{question}-{timestamp}.{ext}`.
- ## Troubleshooting
- ### WSL + Windows Ollama
- If you run Quorum in WSL but Ollama on Windows, WSL cannot reach Windows `localhost` by default. Follow all three steps:
- **Step 1: Make Ollama listen on all interfaces (Windows)**
- ```powershell
- # PowerShell (run before starting Ollama)
- $env:OLLAMA_HOST = "0.0.0.0"
- ollama serve
- ```
- Or set it permanently: System Properties → Environment Variables → New System variable: `OLLAMA_HOST` = `0.0.0.0`
- **Step 2: Allow Ollama through Windows Firewall (run as Administrator)**
- ```powershell
- New-NetFirewallRule -DisplayName "Ollama" -Direction Inbound -LocalPort 11434 -Protocol TCP -Action Allow
- ```
- **Step 3: Configure Quorum with the gateway IP (WSL)**
- ```bash
- # Find your Windows host IP from WSL
- ip route show default | awk '{print $3}'
- # Example output: 172.29.0.1
- ```
- ```bash
- # Add to .env in Quorum
- OLLAMA_BASE_URL=http://172.29.0.1:11434 # Use YOUR gateway IP
- ```
- **Verify it works:**
- ```bash
- curl http://172.29.0.1:11434/api/tags # Should return JSON with your models
- Dismissed after review: Fetches a raw IP-literal URL — ambiguous (could be legitimate internal tooling) but worth a second look
- Line 824 on GitHub
- ```
- **Note:** The gateway IP is stable within WSL. Do NOT use the IP from `/etc/resolv.conf` — it often doesn't work.
- ### Ollama models not showing in /models
- 1. **Check Ollama is running:** `ollama list` should show your models
- 2. **Check connectivity:** `curl http://localhost:11434/api/tags` should return JSON
- 3. **WSL users with Ollama on Windows:** See [WSL + Windows Ollama](#wsl--windows-ollama) above — you need all three steps (0.0.0.0, firewall rule, gateway IP)
- ### "Frontend not found" or "node_modules not found"
- Run the install script or manually build frontend:
- ```bash
- cd frontend && npm install && npm run build && cd ..
- ```
- ### "No API keys configured"
- Make sure you have created `.env` in the project directory with at least one API key.
- ### "Insufficient credits" error
- Your API credits are exhausted. Add credits at:
- - Anthropic: https://console.anthropic.com/settings/plans
- - OpenAI: https://platform.openai.com/settings/organization/billing
- ### "Quorum is not installed" error
- Run the install script first:
- - Windows: `install.bat`
- - Linux/macOS: `./install.sh`
- ### uv installation fails (corporate/restricted environments)
- If `pip install uv` fails due to network restrictions, install uv manually:
- ```bash
- # Alternative: download uv directly
- curl -LsSf https://astral.sh/uv/install.sh | sh # Linux/macOS
- # Or on Windows PowerShell:
- irm https://astral.sh/uv/install.ps1 | iex
- ```
- Or use pip with venv manually (slower but works offline):
- ```bash
- python -m venv .venv
- .venv/bin/pip install -e . # Linux/macOS
- .venv\Scripts\pip install -e . # Windows
- ```
- ### Updating after code changes
- ```bash
- git pull
- uv sync
- cd frontend && npm run build && cd ..
- ```
- ## Data Storage
- Quorum stores user data in `~/.quorum/`:
- - `history.json` - Input history
- - `settings.json` - Saved model selections and settings
- - `validated_models.json` - Cached model validations (avoids repeated API checks)
- ## Contributing
- Contributions are welcome! Please see [CONTRIBUTING.md](.github/CONTRIBUTING.md) for guidelines.
- ## License
- Business Source License 1.1 - see [LICENSE](LICENSE) for details.
- **What this means:**
- - Free for personal use, internal company use, and contributions
- - Commercial SaaS offerings based on Quorum require a separate license
- - Converts to Apache 2.0 on 2029-12-07
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.