Skip to content
Back to search

quorum

MarketplaceWorks with Claude CodeGitHub

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.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/detrol--quorum-cli/badge.svg)](/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)

  1. {
  2. "name": "quorum",
  3. "owner": {
  4. "name": "Detrol",
  5. "url": "https://github.com/Detrol"
  6. },
  7. "metadata": {
  8. "description": "Quorum: multi-agent debates for Claude Code and Codex."
  9. },
  10. "plugins": [
  11. {
  12. "name": "quorum",
  13. "source": "./",
  14. "description": "Multi-agent debates between claude, codex, agy and grok via MCP."
  15. }
  16. ]
  17. }
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)

  1. # Quorum
  2. <p align="center">
  3. <img src="docs/demo.gif" alt="Quorum - AI models debating in terminal" width="700">
  4. </p>
  5. <p align="center">
  6. <strong>🌐 Web Version Now Available! Try Quorum in your browser at <a href="https://quorumai.dev">quorumai.dev</a></strong>
  7. </p>
  8. <p align="center">
  9. <strong>AI War Room in your terminal.</strong><br>
  10. Watch GPT, Claude, Gemini, and Grok debate using formal methods.<br>
  11. <em>Now a Claude Code &amp; Codex plugin for debates between agent CLIs.</em>
  12. </p>
  13. <p align="center">
  14. <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>
  15. <a href="LICENSE"><img src="https://img.shields.io/badge/License-BSL_1.1-blue.svg" alt="License"></a>
  16. <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.11+-blue.svg" alt="Python 3.11+"></a>
  17. </p>
  18. ---
  19. 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.
  20. ## Quick Install (pip)
  21. ```bash
  22. pip install quorum-cli
  23. quorum
  24. ```
  25. On first run, Quorum creates `~/.quorum/.env.example`. Copy and edit it:
  26. ```bash
  27. cp ~/.quorum/.env.example ~/.quorum/.env
  28. nano ~/.quorum/.env # Add your API keys
  29. quorum
  30. ```
  31. **Upgrade:** `pip install -U quorum-cli`
  32. **Requirements:** Python 3.11+, Node.js 18+
  33. ---
  34. ## Claude Code & Codex plugin (MCP)
  35. Ask your coding agent for a Quorum and it runs a structured debate between the models you choose:
  36. - **Agent CLIs** you have installed: **claude**, **codex**, **agy** (Antigravity) and **grok**. Each runs
  37. on your own subscription and needs no API key. They can read your project (read-only) and use the
  38. web, isolated from your hooks, plugins and instruction files.
  39. - **API and local models** from your `~/.quorum/.env` (see [Configuration](#configuration)): OpenAI,
  40. Anthropic, Google, xAI, OpenRouter, LM Studio, llama-swap, custom endpoints and Ollama. They see the
  41. question and any files passed with it, but have no tool access.
  42. Agents and API models can take part in the same discussion.
  43. ```bash
  44. # Claude Code
  45. claude plugin marketplace add Detrol/quorum-cli
  46. claude plugin install quorum@quorum
  47. # Codex
  48. codex plugin marketplace add Detrol/quorum-cli
  49. codex plugin add quorum@quorum
  50. ```
  51. The plugin starts the server with `uvx --from quorum-cli quorum-mcp-server`, so [uv](https://github.com/astral-sh/uv)
  52. must be on PATH. Without the plugin, after `pip install quorum-cli`, you can still register the server
  53. yourself: `claude mcp add quorum --scope user -- quorum-mcp-server`.
  54. Then ask, for example:
  55. > "Run a Quorum on whether we should split this service"
  56. Before it starts, you get a form: one dropdown per available provider (off, or a model with an
  57. effort level) and one for the discussion method, preset to your last lineup. Clients without form
  58. support (MCP elicitation) ask in chat instead.
  59. **MCP tools:**
  60. - `quorum_list_models` - Providers with status, models, roles and effort levels
  61. - `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
  62. - `quorum_wait` - Poll a run in slices until the synthesis is ready (safe under client tool timeouts)
  63. - `quorum_check` - Real ping to every agent CLI
  64. - `quorum_discuss` - Deprecated v1.1 interface (blocking; bare model ids from `*_MODELS` still work)
  65. **Configuration:** the server always reads `~/.quorum/.env`, never a `.env` in the project you are
  66. working in. `*_MODELS` lists and Ollama auto-discovery work as in the TUI, and so do `QUORUM_METHOD`,
  67. `QUORUM_SYNTHESIZER`, `QUORUM_ROUNDS_PER_AGENT` and `QUORUM_EXECUTION_MODE`. Responses match the
  68. question's language. Effort maps to `reasoning_effort` (OpenAI, Google, xAI) and to adaptive thinking
  69. with effort (Anthropic). It is only sent when you choose one, because models without reasoning
  70. support reject it.
  71. **Defaults:** at most 4 participants, 10 min per turn, 30 min per run, one run per project at a time.
  72. Transcripts are saved to `~/.quorum/runs/`.
  73. ---
  74. ## Development Installation
  75. For contributors or those who want the latest changes:
  76. ### Requirements
  77. - Python 3.11 or higher
  78. - Node.js 18 or higher
  79. - npm
  80. - [uv](https://github.com/astral-sh/uv) (auto-installed if missing)
  81. ### Linux / macOS
  82. ```bash
  83. git clone https://github.com/Detrol/quorum-cli.git
  84. cd quorum-cli
  85. ./install.sh
  86. nano .env # Add your API keys
  87. ./quorum
  88. ```
  89. ### Windows
  90. ```cmd
  91. git clone https://github.com/Detrol/quorum-cli.git
  92. cd quorum-cli
  93. install.bat
  94. notepad .env & REM Add your API keys
  95. quorum.bat
  96. ```
  97. ### Manual installation
  98. ```bash
  99. # Install uv if not present
  100. pip install uv
  101. # Python dependencies (creates .venv automatically)
  102. uv sync
  103. # Frontend
  104. cd frontend && npm install && npm run build && cd ..
  105. # Configuration
  106. cp .env.example .env # Linux/macOS
  107. copy .env.example .env # Windows
  108. ```
  109. ## Configuration
  110. Edit `.env` and add your API keys:
  111. ```bash
  112. # OpenAI - https://platform.openai.com/api-keys
  113. OPENAI_API_KEY=sk-...
  114. OPENAI_MODELS=gpt-5.2,gpt-5.1,gpt-5
  115. # Anthropic - https://console.anthropic.com/settings/keys
  116. ANTHROPIC_API_KEY=sk-ant-...
  117. ANTHROPIC_MODELS=claude-opus-4-5-20251124,claude-sonnet-4-5-20250929
  118. # Google - https://aistudio.google.com/apikey
  119. GOOGLE_API_KEY=...
  120. GOOGLE_MODELS=gemini-3-pro,gemini-2.5-flash
  121. # xAI (Grok) - https://console.x.ai/
  122. XAI_API_KEY=xai-...
  123. XAI_MODELS=grok-4.1,grok-4
  124. # Ollama (local models) - https://ollama.com/
  125. # Models are auto-discovered, no config needed for same-machine setup
  126. # OLLAMA_BASE_URL=http://localhost:11434 # Default, change for remote
  127. # OLLAMA_API_KEY= # Optional, for proxy authentication
  128. # Optional settings
  129. QUORUM_ROUNDS_PER_AGENT=2 # Discussion rounds per agent (1-10, default: 2)
  130. QUORUM_SYNTHESIZER=first # Who synthesizes: first, random, or rotate
  131. QUORUM_DEFAULT_LANGUAGE= # Force response language (e.g., "Swedish", "English")
  132. # QUORUM_EXECUTION_MODE=auto # VRAM optimization: auto, parallel, sequential
  133. ```
  134. You only need to configure the providers you want to use. At least one provider is required.
  135. ### Finding available models
  136. - **OpenAI**: https://platform.openai.com/docs/models
  137. - **Anthropic**: https://docs.anthropic.com/en/docs/about-claude/models
  138. - **Google**: https://ai.google.dev/gemini-api/docs/models
  139. - **xAI (Grok)**: https://docs.x.ai/docs/models
  140. - **Ollama**: https://ollama.com/library
  141. ### Ollama (Local Models)
  142. Quorum supports local models via [Ollama](https://ollama.com/). Models are auto-discovered when Ollama is running.
  143. **Quick start:**
  144. ```bash
  145. # 1. Install Ollama from https://ollama.com/download
  146. # 2. Pull a model
  147. ollama pull llama3
  148. # 3. Start Quorum - Ollama models appear automatically in /models
  149. ```
  150. Models appear with `ollama:` prefix (e.g., `ollama:llama3`, `ollama:qwen3:8b`).
  151. **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.
  152. ### OpenAI-Compatible Providers
  153. 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.
  154. **OpenRouter** - Access 200+ models through one API:
  155. ```bash
  156. OPENROUTER_API_KEY=sk-or-v1-...
  157. OPENROUTER_MODELS=anthropic/claude-3-opus,openai/gpt-4o,meta-llama/llama-3.1-70b
  158. ```
  159. **LM Studio** - Local models with a GUI (no API key required):
  160. ```bash
  161. LMSTUDIO_MODELS=llama-3.2-3b,deepseek-coder-v2
  162. # LMSTUDIO_BASE_URL=http://localhost:1234/v1 # Default
  163. ```
  164. **llama-swap** - Hot-swap between local models:
  165. ```bash
  166. LLAMASWAP_BASE_URL=http://localhost:8080/v1
  167. LLAMASWAP_MODELS=llama3,mistral-7b,qwen2
  168. ```
  169. **Custom endpoint** - Any OpenAI-compatible server:
  170. ```bash
  171. CUSTOM_BASE_URL=http://localhost:5000/v1
  172. CUSTOM_MODELS=model-name-1,model-name-2
  173. CUSTOM_API_KEY=your-key # If required
  174. ```
  175. 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.
  176. **Configuration scenarios:**
  177. | Quorum runs on | Ollama runs on | Configuration |
  178. |----------------|----------------|---------------|
  179. | Windows | Windows | Works out of the box |
  180. | Linux | Linux | Works out of the box |
  181. | WSL | WSL | Works out of the box |
  182. | WSL | Windows | See [WSL + Windows Ollama](#wsl--windows-ollama) below |
  183. | Any | Remote server | Set `OLLAMA_BASE_URL` in `.env` |
  184. **Remote Ollama server:**
  185. ```bash
  186. # In .env
  187. OLLAMA_BASE_URL=http://your-server:11434
  188. OLLAMA_API_KEY=your-key # Optional, if using authentication proxy
  189. ```
  190. ## Usage
  191. ### Start Quorum
  192. ```bash
  193. quorum
  194. ```
  195. ### Select models
  196. ```
  197. > /models
  198. OPENAI
  199. [1] gpt-5.2
  200. [2] gpt-5.1
  201. ANTHROPIC
  202. [3] claude-opus-4-5-20251124
  203. GOOGLE
  204. [4] gemini-3-pro
  205. Select models (comma-separated): 1,3,4
  206. ✓ Selected: gpt-5.2, claude-opus-4-5-20251124, gemini-3-pro
  207. ```
  208. ### Ask a question
  209. ```
  210. > What is the best programming language for beginners?
  211. ╭─ gpt-5.2 ─────────────────────────────────────────╮
  212. │ I would recommend Python for beginners... │
  213. ╰───────────────────────────────────────────────────╯
  214. ╭─ claude-opus-4-5-20251124 ────────────────────────╮
  215. │ I agree with the recommendation of Python... │
  216. │ CONSENSUS: Python is the best choice because... │
  217. ╰───────────────────────────────────────────────────╯
  218. ╭─ gemini-3-pro ────────────────────────────────────╮
  219. │ CONSENSUS: Python is recommended for beginners... │
  220. ╰───────────────────────────────────────────────────╯
  221. ──────────────────────────────────────────────────────
  222. ╭─ Result ──────────────────────────────────────────╮
  223. │ CONSENSUS REACHED! │
  224. │ │
  225. │ All 3 agents agreed. │
  226. │ Messages exchanged: 3 │
  227. │ │
  228. │ Final Answer: │
  229. │ Python is recommended for beginners... │
  230. ╰───────────────────────────────────────────────────╯
  231. ```
  232. ### Commands
  233. | Command | Description |
  234. |---------|-------------|
  235. | `/models` | Select AI models for discussion |
  236. | `/method [name]` | Show or set discussion method |
  237. | `/advisor` or **Tab** | Get AI-powered method recommendation |
  238. | `/synthesizer` | Set synthesizer mode (first/random/rotate) |
  239. | `/status` | Show current settings |
  240. | `/export [format]` | Export discussion (md, text, pdf, json) |
  241. | `/clear` | Clear screen |
  242. | `/help` | Show help |
  243. | `/quit` or `/exit` | Exit Quorum |
  244. ## Discussion Methods
  245. Quorum supports seven discussion methods that change how the discussion phase works. Each method has specific requirements for the number of models.
  246. ### Standard (default)
  247. **Requires:** 2+ models
  248. 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.
  249. **How it works:**
  250. - Models take turns responding to the ongoing discussion
  251. - Each model sees all previous answers and critiques
  252. - Focus is on collaboration and synthesis
  253. **Flow:**
  254. ```
  255. Phase 1 Phase 2 Phase 3 Phase 4 Phase 5
  256. ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
  257. │ Answer │ → │Critique │ → │ Discuss │ → │Position │ → │Synthesis│
  258. │(parallel)│ │(parallel)│ │(turns) │ │(parallel)│ │(single) │
  259. └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘
  260. All models Review each Round-robin Final stance Synthesizer
  261. respond other's work discussion + confidence aggregates
  262. ```
  263. **Best for:** General questions, collaborative problem-solving, finding balanced answers.
  264. ```
  265. > What's the best approach to error handling in this codebase?
  266. ```
  267. ---
  268. ### Oxford
  269. **Requires:** Even number of models (2, 4, 6...)
  270. 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.
  271. **How it works:**
  272. 1. **Opening statements** - Each side presents their strongest case
  273. 2. **Rebuttals** - Directly address and counter the opposing side's arguments
  274. 3. **Closing statements** - Summarize position and make final case
  275. Models are assigned roles by index:
  276. - Even indices (0, 2, 4...) argue **FOR**
  277. - Odd indices (1, 3, 5...) argue **AGAINST**
  278. **Flow:**
  279. ```
  280. Phase 1 Phase 2 Phase 3 Phase 4
  281. ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
  282. │ Opening │ → │ Rebuttals │ → │ Closing │ → │ Synthesis │
  283. │Statements │ │ │ │Statements │ │ │
  284. └───────────┘ └───────────┘ └───────────┘ └───────────┘
  285. FOR presents FOR counters FOR summarizes Judge decides
  286. AGAINST presents AGAINST counters AGAINST summarizes winner
  287. ```
  288. **Best for:** Binary decisions, exploring both sides thoroughly, devil's advocate analysis.
  289. ```
  290. > /oxford Should we migrate to microservices or keep the monolith?
  291. ```
  292. ---
  293. ### Advocate
  294. **Requires:** 3+ models
  295. 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.
  296. **How it works:**
  297. 1. AI analyzes initial answers to identify the majority position
  298. 2. The last model becomes the "devil's advocate"
  299. 3. Advocate challenges the consensus, finding flaws and edge cases
  300. 4. Other models must defend and justify their reasoning
  301. **Flow:**
  302. ```
  303. Phase 1 Phase 2 Phase 3
  304. ┌─────────────┐ ┌─────────────────┐ ┌─────────────┐
  305. │ Positions │ → │Cross-Examination│ → │ Synthesis │
  306. │ │ │ │ │ │
  307. └─────────────┘ └─────────────────┘ └─────────────┘
  308. Defenders state Advocate challenges Final verdict
  309. their views each defender with analysis
  310. ```
  311. **Best for:** Stress-testing ideas, avoiding groupthink, critical analysis, finding weaknesses.
  312. ```
  313. > /advocate Is our authentication system secure enough?
  314. ```
  315. ---
  316. ### Socratic
  317. **Requires:** 2+ models
  318. Question-driven Socratic dialogue. Instead of stating positions, models take turns as the "questioner" who probes assumptions and reasoning.
  319. **How it works:**
  320. 1. Each round, one model becomes the **Questioner**
  321. 2. The Questioner asks ONE probing question targeting a specific claim
  322. 3. All other models respond as **Respondents**
  323. 4. The Questioner role rotates each round
  324. **Flow:**
  325. ```
  326. Phase 1 Phase 2 Phase 3
  327. ┌───────────┐ ┌──────────────┐ ┌───────────┐
  328. │ Thesis │ → │ Elenchus │ → │ Synthesis │
  329. │ │ │ (Q&A Rounds)│ │ │
  330. └───────────┘ └──────────────┘ └───────────┘
  331. Respondent Questioners probe Refined
  332. states view assumptions understanding
  333. ```
  334. **Best for:** Deep exploration, exposing hidden assumptions, understanding complex topics, learning.
  335. ```
  336. > /socratic What assumptions are we making about user behavior?
  337. ```
  338. ---
  339. ### Delphi
  340. **Requires:** 3+ models
  341. Iterative consensus-building for estimates and forecasts. Models provide independent estimates, then revise after seeing others' reasoning across multiple rounds.
  342. **How it works:**
  343. 1. **Round 1** - Each model provides an independent estimate with confidence level
  344. 2. **Round 2** - Models see anonymized group estimates and may revise
  345. 3. **Round 3** - Final revision opportunity before aggregation
  346. 4. **Synthesis** - Aggregates final estimates into consensus range
  347. **Flow:**
  348. ```
  349. Phase 1 Phase 2 Phase 3 Phase 4
  350. ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
  351. │ Round 1 │ → │ Round 2 │ → │ Round 3 │ → │ Aggregate │
  352. │ Estimates │ │ Revisions │ │ Final Rev │ │ Consensus │
  353. └───────────┘ └───────────┘ └───────────┘ └───────────┘
  354. Independent See group, Last chance Synthesize
  355. estimates may revise to revise final range
  356. ```
  357. **Best for:** Time estimates, cost projections, risk assessments, quantitative forecasting.
  358. ```
  359. > /delphi How long would it take to migrate this codebase to Python 3?
  360. ```
  361. ---
  362. ### Brainstorm
  363. **Requires:** 2+ models
  364. 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.
  365. **How it works:**
  366. 1. **Diverge** - Generate as many ideas as possible, no criticism allowed
  367. 2. **Build** - Combine and expand on the most promising ideas from others
  368. 3. **Converge** - Evaluate and select the top 3 ideas with justification
  369. **Flow:**
  370. ```
  371. Phase 1 Phase 2 Phase 3 Phase 4
  372. ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
  373. │ Diverge │ → │ Build │ → │ Converge │ → │ Synthesis │
  374. │ │ │ │ │ │ │ │
  375. └───────────┘ └───────────┘ └───────────┘ └───────────┘
  376. Generate wild Combine and Evaluate and Present top
  377. ideas, no expand on select top 3 ideas with
  378. judgment others' ideas ideas details
  379. ```
  380. **Best for:** Creative problem-solving, feature ideation, exploring possibilities, innovation.
  381. ```
  382. > /brainstorm How might we improve user onboarding?
  383. ```
  384. ---
  385. ### Tradeoff
  386. **Requires:** 2+ models
  387. Structured comparison of alternatives using explicit criteria. Models define options, establish evaluation dimensions, score each option, then synthesize a recommendation.
  388. **How it works:**
  389. 1. **Frame** - Define the alternatives to compare
  390. 2. **Criteria** - Establish evaluation dimensions with weights
  391. 3. **Evaluate** - Score each alternative on each criterion (1-10)
  392. 4. **Synthesize** - Recommend based on weighted analysis
  393. **Flow:**
  394. ```
  395. Phase 1 Phase 2 Phase 3 Phase 4
  396. ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
  397. │ Frame │ → │ Criteria │ → │ Evaluate │ → │ Recommend │
  398. │ │ │ │ │ │ │ │
  399. └───────────┘ └───────────┘ └───────────┘ └───────────┘
  400. Define the Establish Score each Synthesize
  401. alternatives evaluation alternative recommendation
  402. to compare dimensions (1-10 scale) with tradeoffs
  403. ```
  404. **Best for:** Technology choices, architecture decisions, vendor selection, A vs B comparisons.
  405. ```
  406. > /tradeoff Should we use PostgreSQL or MongoDB for this project?
  407. ```
  408. ---
  409. ### Method Requirements Summary
  410. | Method | Models Required | Role Assignment |
  411. |--------|-----------------|-----------------|
  412. | Standard | 2+ | Equal participation |
  413. | Oxford | 2, 4, 6... (even) | FOR / AGAINST teams |
  414. | Advocate | 3+ | 1 challenger + defenders |
  415. | Socratic | 2+ | Rotating questioner |
  416. | Delphi | 3+ | Anonymous panelists |
  417. | Brainstorm | 2+ | Equal ideators |
  418. | Tradeoff | 2+ | Equal evaluators |
  419. ---
  420. ### When to Use Each Method
  421. Choose your method based on the type of question:
  422. | Method | Best For | Example Questions |
  423. |--------|----------|-------------------|
  424. | **Standard** | Technical questions, best practices, problem-solving | "How should we handle errors?", "What architecture fits this use case?" |
  425. | **Oxford** | Binary decisions, controversial topics, pros/cons analysis | "Motion: We should migrate to microservices", "Motion: AI should be regulated" |
  426. | **Advocate** | Consensus-prone topics where critical thinking is needed | "Is our security good enough?", "Should we use TypeScript?" |
  427. | **Socratic** | Philosophical questions, exploring definitions and assumptions | "What is good code?", "What assumptions are we making about users?" |
  428. | **Delphi** | Estimates, forecasts, quantitative predictions | "How long will migration take?", "What's the project risk level?" |
  429. | **Brainstorm** | Creative ideation, exploring possibilities, innovation | "How might we improve UX?", "What features should we add?" |
  430. | **Tradeoff** | Technology choices, A vs B decisions, vendor selection | "PostgreSQL or MongoDB?", "AWS or GCP for this workload?" |
  431. **Tips:**
  432. - **Not sure?** Press **Tab** to get AI-powered method recommendations based on your question
  433. - Use **Standard** as your default for most technical discussions
  434. - Use **Oxford** with "Motion:" prefix to signal a formal debate proposition
  435. - Use **Advocate** when you suspect everyone will agree too easily — it forces critical scrutiny
  436. - Use **Socratic** when there's no clear right/wrong answer and you want to explore deeper
  437. - Use **Delphi** when you need a numerical estimate or forecast with confidence ranges
  438. - Use **Brainstorm** when you want creative ideas without early criticism
  439. - Use **Tradeoff** when comparing specific alternatives with clear criteria
  440. ---
  441. ### Selecting a Method
  442. **Via config (.env):**
  443. ```bash
  444. QUORUM_METHOD=oxford
  445. ```
  446. **Via command (session override):**
  447. ```
  448. > /method oxford
  449. ✓ Method set to: oxford
  450. ```
  451. **Via inline syntax (one-time use):**
  452. ```
  453. > /oxford Should we use microservices or a monolith?
  454. > /advocate Is this architecture scalable?
  455. > /socratic What assumptions are we making?
  456. > /delphi How long will this refactoring take?
  457. > /brainstorm How can we improve performance?
  458. > /tradeoff React vs Vue for this project?
  459. ```
  460. **Via AI advisor (recommended for new users):**
  461. Press **Tab** to analyze your question and get method recommendations.
  462. **Note:** If you try to use a method with an incompatible number of models, Quorum will show an error:
  463. ```
  464. > /oxford What should we do?
  465. Error: Oxford requires an even number of models for balanced FOR/AGAINST teams
  466. ```
  467. ---
  468. ### Method Advisor
  469. **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.
  470. **How it works:**
  471. 1. Press **Tab** in the input field
  472. 2. Enter your question (or press Enter if already typed)
  473. 3. Review AI recommendations with confidence scores
  474. 4. Select the recommended method or choose an alternative
  475. 5. Press Esc to cancel and return to manual selection
  476. **Example:**
  477. ```
  478. Press Tab → Opens Method Advisor
  479. METHOD ADVISOR
  480. What's your question?
  481. › How long will it take to migrate our database to PostgreSQL?
  482. [Analyzing with gpt-5.1...]
  483. RECOMMENDED:
  484. ● Delphi (95%)
  485. Best for time estimates and forecasts. Multiple models provide
  486. independent estimates, then revise based on group feedback to
  487. converge on a consensus range.
  488. ○ Tradeoff (70%)
  489. Could work if comparing PostgreSQL migration strategies
  490. ○ Standard (60%)
  491. Fallback for general technical discussion
  492. ↑↓ Navigate • Enter Select • Backspace Back • Esc Cancel
  493. ```
  494. **Key features:**
  495. - Uses your first validated model as the analyzer
  496. - Returns primary recommendation plus 1-2 alternatives
  497. - Includes confidence scores (0-100) and reasoning
  498. - Requires at least one validated model to work
  499. - Smart method selection based on question patterns
  500. **Keyboard shortcuts:**
  501. - **Tab** - Open Method Advisor
  502. - **Enter** - Analyze question / Select method
  503. - **↑/↓** - Navigate recommendations
  504. - **Backspace** - Return to question input
  505. - **Esc** - Cancel and close advisor
  506. ---
  507. ## Advanced Settings
  508. ### Synthesizer Mode
  509. Controls which model creates the final synthesis:
  510. | Mode | Behavior |
  511. |------|----------|
  512. | `first` | First selected model always synthesizes (default) |
  513. | `random` | Random model chosen each time |
  514. | `rotate` | Cycles through models across discussions |
  515. ```bash
  516. # In .env
  517. QUORUM_SYNTHESIZER=rotate
  518. ```
  519. ### Discussion Length
  520. `QUORUM_ROUNDS_PER_AGENT` controls how many turns each model gets in the discussion phase. Higher values = longer, deeper discussions but more API costs.
  521. | Setting | Effect |
  522. |---------|--------|
  523. | `1` | Quick discussions, 1 turn per model |
  524. | `2` | Default, balanced depth |
  525. | `3-5` | Extended discussions for complex topics |
  526. ### Response Language
  527. By default, Quorum matches the language of your question. Use `QUORUM_DEFAULT_LANGUAGE` to force all responses in a specific language:
  528. ```bash
  529. # Force Swedish responses
  530. QUORUM_DEFAULT_LANGUAGE=Swedish
  531. # Force English responses
  532. QUORUM_DEFAULT_LANGUAGE=English
  533. ```
  534. ### Execution Mode (VRAM Optimization)
  535. When running multiple local Ollama models, they compete for GPU VRAM which can cause crashes or slowdowns. Quorum handles this automatically:
  536. | Mode | Behavior |
  537. |------|----------|
  538. | `auto` | **Default.** Cloud APIs run in parallel, Ollama runs sequentially |
  539. | `parallel` | Always run all models simultaneously (cloud-only setups) |
  540. | `sequential` | Always run models one at a time (safest for limited VRAM) |
  541. ```bash
  542. # In .env (usually not needed - auto works for most users)
  543. QUORUM_EXECUTION_MODE=auto
  544. ```
  545. **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.
  546. ### UI Language
  547. The terminal UI is available in 6 languages, controlled by `QUORUM_DEFAULT_LANGUAGE`:
  548. | Language | Values |
  549. |----------|--------|
  550. | English | `en`, `English` (default) |
  551. | Swedish | `sv`, `Swedish`, `Svenska` |
  552. | German | `de`, `German`, `Deutsch` |
  553. | French | `fr`, `French`, `Francais` |
  554. | Spanish | `es`, `Spanish`, `Espanol` |
  555. | Italian | `it`, `Italian`, `Italiano` |
  556. ### Discussion Logging & Export
  557. Quorum supports two ways to save discussions:
  558. **Manual export** - Use the `/export` command to save the current discussion:
  559. ```bash
  560. /export # Export with default format (md)
  561. /export md # Markdown format
  562. /export text # Plain text (for social media)
  563. /export pdf # PDF format
  564. /export json # JSON format (for ML/RAG pipelines)
  565. ```
  566. Configure default export location and format:
  567. ```bash
  568. QUORUM_EXPORT_DIR=~/.quorum/exports # Directory (default: home)
  569. QUORUM_EXPORT_FORMAT=md # Default format: md, text, pdf, json
  570. ```
  571. | Format | Best For |
  572. |--------|----------|
  573. | `md` | GitHub, Discord, documentation |
  574. | `text` | Social media, plain copy-paste |
  575. | `pdf` | Formatted sharing, printing |
  576. | `json` | ML training data, RAG datasets, API integrations |
  577. **Auto-save** - All discussions are automatically saved as markdown. Configure the directory:
  578. ```bash
  579. # Auto-save directory (default: ~/reports)
  580. QUORUM_REPORT_DIR=~/reports
  581. ```
  582. Files are saved as `quorum-{question}-{timestamp}.{ext}`.
  583. ## Troubleshooting
  584. ### WSL + Windows Ollama
  585. If you run Quorum in WSL but Ollama on Windows, WSL cannot reach Windows `localhost` by default. Follow all three steps:
  586. **Step 1: Make Ollama listen on all interfaces (Windows)**
  587. ```powershell
  588. # PowerShell (run before starting Ollama)
  589. $env:OLLAMA_HOST = "0.0.0.0"
  590. ollama serve
  591. ```
  592. Or set it permanently: System Properties → Environment Variables → New System variable: `OLLAMA_HOST` = `0.0.0.0`
  593. **Step 2: Allow Ollama through Windows Firewall (run as Administrator)**
  594. ```powershell
  595. New-NetFirewallRule -DisplayName "Ollama" -Direction Inbound -LocalPort 11434 -Protocol TCP -Action Allow
  596. ```
  597. **Step 3: Configure Quorum with the gateway IP (WSL)**
  598. ```bash
  599. # Find your Windows host IP from WSL
  600. ip route show default | awk '{print $3}'
  601. # Example output: 172.29.0.1
  602. ```
  603. ```bash
  604. # Add to .env in Quorum
  605. OLLAMA_BASE_URL=http://172.29.0.1:11434 # Use YOUR gateway IP
  606. ```
  607. **Verify it works:**
  608. ```bash
  609. 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
  610. ```
  611. **Note:** The gateway IP is stable within WSL. Do NOT use the IP from `/etc/resolv.conf` — it often doesn't work.
  612. ### Ollama models not showing in /models
  613. 1. **Check Ollama is running:** `ollama list` should show your models
  614. 2. **Check connectivity:** `curl http://localhost:11434/api/tags` should return JSON
  615. 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)
  616. ### "Frontend not found" or "node_modules not found"
  617. Run the install script or manually build frontend:
  618. ```bash
  619. cd frontend && npm install && npm run build && cd ..
  620. ```
  621. ### "No API keys configured"
  622. Make sure you have created `.env` in the project directory with at least one API key.
  623. ### "Insufficient credits" error
  624. Your API credits are exhausted. Add credits at:
  625. - Anthropic: https://console.anthropic.com/settings/plans
  626. - OpenAI: https://platform.openai.com/settings/organization/billing
  627. ### "Quorum is not installed" error
  628. Run the install script first:
  629. - Windows: `install.bat`
  630. - Linux/macOS: `./install.sh`
  631. ### uv installation fails (corporate/restricted environments)
  632. If `pip install uv` fails due to network restrictions, install uv manually:
  633. ```bash
  634. # Alternative: download uv directly
  635. curl -LsSf https://astral.sh/uv/install.sh | sh # Linux/macOS
  636. # Or on Windows PowerShell:
  637. irm https://astral.sh/uv/install.ps1 | iex
  638. ```
  639. Or use pip with venv manually (slower but works offline):
  640. ```bash
  641. python -m venv .venv
  642. .venv/bin/pip install -e . # Linux/macOS
  643. .venv\Scripts\pip install -e . # Windows
  644. ```
  645. ### Updating after code changes
  646. ```bash
  647. git pull
  648. uv sync
  649. cd frontend && npm run build && cd ..
  650. ```
  651. ## Data Storage
  652. Quorum stores user data in `~/.quorum/`:
  653. - `history.json` - Input history
  654. - `settings.json` - Saved model selections and settings
  655. - `validated_models.json` - Cached model validations (avoids repeated API checks)
  656. ## Contributing
  657. Contributions are welcome! Please see [CONTRIBUTING.md](.github/CONTRIBUTING.md) for guidelines.
  658. ## License
  659. Business Source License 1.1 - see [LICENSE](LICENSE) for details.
  660. **What this means:**
  661. - Free for personal use, internal company use, and contributions
  662. - Commercial SaaS offerings based on Quorum require a separate license
  663. - Converts to Apache 2.0 on 2029-12-07

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.