Skip to main content
Glama

code-quorum

Purpose: what code-quorum is, how to install it, how to use it. Use: read this first when new here; update it in the same PR as any change to install or usage. Layout and reasons are in ARCHITECTURE.md; agent conventions in CLAUDE.md.

Independent reviews have become an important part of how I use agentic tools. Inspired by similar work, I built Code Quorum for my own use and am sharing it in case others find it useful.

Code Quorum is a macOS multi-agent council for Claude Code and Codex. The active host writes its own review, assessment, or plan while external seats work in parallel. A structural anti-bias gate keeps every perspective independent until the final synthesis.

It can use existing Claude Code, ChatGPT/Codex, and Gemini/Antigravity subscriptions. The OpenCode seat uses OpenRouter, with DeepSeek V4.1 Flash as its default model. Both CLI hosts are supported, along with Codex in the ChatGPT desktop app and the Code surface in the Claude desktop app.

Host

Default external council

Claude Code

Codex + Gemini + OpenCode

Codex

Claude subscription + Gemini + OpenCode

The host is never also a subprocess seat. The start/await split requires the host to form its own answer before q_await exposes peer output, and every council skill calls the blocking completion notification in the same turn as its start.

External seats are read-only, but read-only does not mean data-local. Review Security and data boundaries before using Code Quorum on private material.

Every repository-reading MCP council start requires an explicit absolute project cwd. The MCP tools reject an omitted or blank value rather than falling back to the server's own directory, and the host skills supply it during normal /q-* and $code-quorum:q-* use. Plan and scope files must resolve inside that directory; a path outside it, .. traversal, and symlink escapes are rejected before any read.

Workflows

The host can select a workflow from a matching plain-language request. Use the forms below to select one explicitly:

Workflow

Claude Code

Codex

Shell

Plan

/q-plan <task>

$code-quorum:q-plan <task>

uv run quorum q-plan <task>

Brainstorm

/q-brainstorm <topic>

$code-quorum:q-brainstorm <topic>

uv run quorum q-brainstorm <topic>

Skystorm

/q-skystorm <topic>

$code-quorum:q-skystorm <topic>

host-only skill

Validate

/q-validate <plan-path>

$code-quorum:q-validate <plan-path>

uv run quorum q-validate <plan-path>

Review

/q-review [target]

$code-quorum:q-review [target]

uv run quorum q-review [target]

Research

/q-research <topic>

$code-quorum:q-research <topic>

uv run quorum research <topic>

Help

/q-help

$code-quorum:q-help

host-only skill

uv run quorum --help lists the exact shell surface. The main modifiers are:

Option

Effect

--extended

Two-pass host brainstorm (visionary/pioneer/architect, then analyst/maintainer/skeptic), or validation/review in 4 rounds with stance rotation.

--mode critique

Makes later validation/review rounds attack peer positions instead of revising toward agreement.

--scope <doc>

Declares in-bounds, out-of-bounds, and accepted-risk areas for a whole-codebase review.

--exploratory

Makes host research hunt for cross-domain analogies instead of direct prior art.

--no-research

Runs brainstorming or skystorm from model priors alone.

Research sources and credentials

q-research queries all seven sources by default. Repeat --source <name> to restrict a run. It accepts up to three --query-lane formulations and reports a Source/lane status table so a strong source cannot hide a collision elsewhere. Use --purpose methods (default) for balanced all-time and recent OpenAlex strata, or --purpose currency for the recent five-year stratum only. Literature sources search every lane; artifact sources (Context7, GitHub, and Hugging Face) search only the primary lane to avoid redundant results and API traffic. The per-source result limit stays fixed across lanes, so extra lanes broaden coverage without inflating the digest.

Source

Target

Credential policy

arXiv (arxiv)

Scholarly papers and preprints from arXiv search.

None.

OpenAlex (openalex)

Methods searches balance all-time relevance/canonical candidates with recent five-year candidates and retain the stratum labels; currency searches use only the recent stratum. Exploratory mode also produces a subfield map.

OPENALEX_API_KEY or QUORUM_OPENALEX_API_KEY is required for normal OpenAlex use. QUORUM_OPENALEX_EMAIL identifies the client but does not replace the key.

Europe PMC published (europepmc-published)

Published life-sciences literature, including PubMed/MEDLINE records, reviews, MeSH metadata, and full-text availability. Exact matches have priority; MeSH synonym expansion only backfills a thin exact result set.

None.

Europe PMC preprints (europepmc-preprints)

Life-sciences preprints from bioRxiv, medRxiv, Research Square, and similar sources; arXiv records are excluded.

None.

Context7 (context7)

High-trust library matches and documentation snippets.

CONTEXT7_API_KEY is recommended because anonymous requests can be rate-limited.

GitHub (github)

Public repositories matched by name, description, and topics, then ranked by stars.

GH_TOKEN, GITHUB_TOKEN, or a signed-in gh raises limits. Private repositories are excluded.

Hugging Face (huggingface)

Public model IDs ranked by card-text relevance. Term-fallback results carry [broadened].

HF_TOKEN or QUORUM_HF_TOKEN raises Hub limits. Private models are filtered out.

Credentials come from the environment, or gh for GitHub, and go out only in authorization headers. The generated Codex adapter forwards the named variables and does not store their values. Only OpenAlex needs a key for normal use; the other keys raise rate limits.

Verify Hugging Face search from a checkout with:

uv run quorum research "sentence embedding" --source huggingface --limit 5
uv run pytest tests/test_research_live.py -m live -k huggingface -q

The CLI check must return model links and a nonzero HuggingFace source count. Without a token, the authentication test skips and the anonymous checks still run.

Related MCP server: Moderator MCP Server

Requirements

Code Quorum requires Python 3.13+, the uv package manager, and the binaries for the seats you use. Each seat relies on its own login or key; Code Quorum does not write credential values into plugin artifacts. Seat CLIs retain their own authentication and runtime state, described in SECURITY.md.

Seat

Binary

Auth

Cost

codex

codex

the CLI's own login (codex login; --with-api-key for metered use)

ChatGPT subscription or metered API key

gemini

agy

Google OAuth via agy

Google AI subscription; metered GEMINI_API_KEY is an explicit SDK opt-in

opencode

opencode

OPENROUTER_API_KEY or optional macOS Keychain item

metered through OpenRouter

claude (Codex host only)

claude

the CLI's own claude.ai login

Claude subscription only; API-key routing is stripped

The Gemini seat depends on the macOS Seatbelt sandbox; Claude uses a read-tool allowlist instead. A Codex host also needs a narrowly scoped LaunchAgent helper for its Claude and Gemini seats. Codex and OpenCode have no Seatbelt dependency but are untested on other platforms.

Install

Clone the stable checkout and configure the seats:

git clone https://github.com/sdewell/code-quorum.git
cd code-quorum
uv sync
agy  # complete Google OAuth login, then exit
uv run quorum setup-agy                    # one-time Gemini seat config
uv run quorum setup-models --host claude   # use --host codex for Codex
uv run quorum doctor --host claude         # or codex / both
uv run quorum auth-check --seat gemini --host claude

doctor checks binaries, configuration shape, and sandbox readiness. It does not test live credentials. auth-check runs agy models inside the same sandbox used by the seat and requires at least one valid model row without sending a model prompt. A missing or revoked login directs the user back to interactive agy; Code Quorum never silently changes to a metered API route.

On a Codex host, install and verify the helper from a real terminal before the Codex authentication check:

uv run quorum install-seat-helper-launchagent   # --allowed-root <dir> to widen
uv run quorum seat-helper-status
uv run quorum auth-check --seat gemini --host codex

Every MCP workflow permits cwd under ~/Code/~/src/~/.codex/agent-worktrees, or in a git worktree of a repository under one; the Codex helper applies the same rule before accepting Claude or Gemini requests. Set CODE_QUORUM_HELPER_ALLOWED_ROOTS or install the helper with --allowed-root options to use other roots. Reinstall it from the stable checkout after every Code Quorum upgrade. Incompatible helper protocols fail closed, and installation from Codex's replaceable plugin cache is rejected.

Read-only boundaries

Every external seat is read-only and refuses to run if its boundary cannot be applied. Enforcement differs by seat: Codex uses its native read-only sandbox, Claude exposes only read tools, Gemini uses macOS Seatbelt, and OpenCode uses an isolated HOME with restricted permissions.

Gemini's Seatbelt profile denies reads of home, volume, and temp directories outside cwd, except agy's own authentication and state. System paths stay readable. Code Quorum provides no universal path fence for Claude, Codex, or OpenCode. Council material can leave the machine under the user's configured provider accounts. The full boundary table, data-egress map, strict-isolation guidance, and credential handling are in SECURITY.md.

Data and approvals on Codex

Codex treats tool approval, filesystem containment, and authorization to send material off-machine as separate decisions. A target such as main...HEAD bounds the prepared review diff; it does not restrict an external seat's read-only access to the working directory.

When approvals_reviewer = "auto_review" is enabled, a council start may need explicit authorization naming the payload and recipients. Users who want unattended access can opt in per tool, but Code Quorum never writes those approval entries itself.

SECURITY.md contains the one-off authorization example, all six Codex approval blocks (including the shared q_await tool), project AGENTS.md guidance, path-confinement limits, and the approval-preserving update procedure. Review it before enabling unattended workflows.

Configuration

Each seat resolves its model through one ladder, first hit wins: per-run flag -> environment variable -> the choice recorded by quorum setup-models -> the shipped pin. Recorded choices never change silently; a seat that cannot honor one fails loudly while the rest of the council continues.

uv run quorum setup-models --host claude
uv run quorum setup-models --seat codex --model gpt-5.6-terra --effort medium

Variable

Effect

CODE_QUORUM_HOST

default host profile (claude or codex)

CODE_QUORUM_GEMINI_MODEL

Gemini seat model (an id from agy models)

CODE_QUORUM_GEMINI_BACKEND

cli (subscription) or sdk (metered GEMINI_API_KEY)

CODE_QUORUM_OPENCODE_MODEL

OpenCode seat model

CODE_QUORUM_OPENCODE_DEBUG

0 disables failed-run diagnostic capture

CODE_QUORUM_OPENCODE_RELAY

0 disables the served-backend relay

CODE_QUORUM_CLAUDE_MODEL / _EFFORT

Claude seat model and effort

CODE_QUORUM_CODEX_MODEL / _EFFORT

Codex seat model and reasoning effort

OpenCode configuration

The OpenCode seat does not load your personal OpenCode configuration. It uses an isolated HOME and rebuilds this generated configuration before every run. The shipped model is openrouter/deepseek/deepseek-v4.1-flash, routed only to the Novita and Parasail backends (fp8) with OpenRouter reasoning.effort set to high; its OpenRouter chunkTimeout is 90000 milliseconds, and OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX is 256000.

Code Quorum sets OPENCODE_DISABLE_PROJECT_CONFIG=1 and OPENCODE_PURE=1. The generated council agent permits only Read, glob, and list, denies shell and mutation tools, blocks .env and .env.*, and permits .env.example. Failed or empty runs write raw stdout/stderr captures to ~/.cache/code-quorum/opencode-debug unless CODE_QUORUM_OPENCODE_DEBUG=0 is set. The directory is 0700, capture files are 0600, prompt text is omitted from command metadata, and only the newest 20 captures are retained. Raw streams can still contain reviewed material. A loopback relay records which OpenRouter backend served each request in ~/.cache/code-quorum/opencode-served.jsonl. See ARCHITECTURE.md and SECURITY.md for the full boundary design.

Environment keys win. Both hosts support this optional macOS Keychain item:

/usr/bin/security add-generic-password -U -a "$(id -un)" \
  -s code-quorum-openrouter -w

Enter the key at the prompt. OpenCode uses this item when OPENROUTER_API_KEY is absent or blank. Failed lookups report setup instructions.

Disabling a seat

If a live probe fails because a seat is absent or logged out, quorum setup-models can mark it disabled in models.toml. Disabled seats are skipped by the default roster and reported by doctor, but an explicit --agent <seat> request still runs them.

Install as a plugin

Claude Code:

/plugin marketplace add sdewell/code-quorum
/plugin install code-quorum@code-quorum

For the Claude Code CLI environment route, load keys before starting the host:

source ~/.zshrc.local
claude

For the Claude desktop app environment route, set keys in the current macOS login session before opening it:

source ~/.zshrc.local
launchctl setenv OPENROUTER_API_KEY "$OPENROUTER_API_KEY"

The launchctl value is inherited by every subsequently launched application until it is unset, logout occurs, or the machine reboots. Start Claude Code, then remove the login-session copy; the already-running app retains its copy for plugin subprocesses:

launchctl unsetenv OPENROUTER_API_KEY

After installing or upgrading the plugin, or after changing a key, quit Claude Code completely and start a new Claude Code session. A plugin reload can pick up code changes but cannot change the environment inherited by the running host.

The Claude plugin starts its MCP server with uv run --directory ${CLAUDE_PLUGIN_ROOT} quorum-mcp, so uv and Python 3.13+ must be on PATH.

Codex:

Register the public marketplace and install the plugin:

codex plugin marketplace add sdewell/code-quorum --ref main
codex plugin add code-quorum@code-quorum
codex plugin list

For the ChatGPT desktop app, fully quit and reopen the app after registering the marketplace. Open Plugins, choose Personal, select Code Quorum, and click Install.

After either Codex surface installs the plugin, prepare the stable checkout from a real terminal:

uv sync
uv run quorum install-seat-helper-launchagent
uv run quorum seat-helper-status

The Codex launcher starts that checkout's prepared .venv directly. MCP startup therefore does not depend on a writable uv cache, network downloads, or an environment inside the replaceable plugin directory. For later upgrades, one command refreshes the checkout, plugin, environment, approvals, and helper:

uv run quorum update-codex

Fully restart Codex and start a new thread afterward. If an older checkout does not yet have update-codex, use the one-time legacy sequence in SECURITY.md.

In Codex CLI, open /hooks to review and trust each code-quorum command hook. Codex skips plugin hooks until each current definition hash is trusted. A changed definition requires re-review and trust for that changed definition.

The generated launcher recovers standard user and Homebrew binary directories (~/.local/bin, ~/.opencode/bin, /opt/homebrew/bin, and /usr/local/bin) for a desktop app with a minimal PATH.

For Codex CLI and the ChatGPT desktop app, use the optional Keychain setup above or the same environment-delivery steps shown for Claude Code.

After a plugin upgrade or key change, fully quit and reopen Codex and start a brand-new Codex thread. Do not resume a thread created before the restart; its tool registry may still refer to the prior plugin process.

For approval-preserving updates, never use codex plugin remove as the normal path. Follow the verified sequence in SECURITY.md.

Design

ARCHITECTURE.md describes the shared CLI/MCP spine, seat adapters, round model, anti-bias mechanisms, packaging, and failure boundaries. The short version: round 1 contains no peer output, later rounds anonymize peers by stance, and the host does not receive the council matrix until q_await.

Attribution

These projects inspired the workflow shape; no code, prompts, or documentation were copied:

License

MIT.

Available Tools

6 tools
q_awaitA

Block until the background council run identified by job_id completes, then return its rounds markdown. One-shot — a job_id can only be awaited once.

This is the blocking completion notification for every council start. The orchestrating host must not end its turn with a live job outstanding; it calls q_await after its independent work and remains blocked until this tool returns a result or error.

Errors:

  • job_id not found (expired, already retrieved, or invalid) → ValueError with the reason.

  • job cancelled by TTL or server shutdown → ValueError.

  • underlying council error → propagated.

Inputs: job_id (required). Returns: result

q_brainstorm_startA

Start a q-brainstorm run in the background. Returns {"job_id": str} immediately. Each agent contributes 3-5 distinct ideas with rationale, trade-offs, and the cheapest test that would give signal; no synthesis. Retrieve results by calling q_await with the returned job_id.

Between the start and the await, the caller is expected to list its own ideas — this is the structural anti-bias gate.

research, when supplied, seeds round 1 with a q_research digest as EVIDENCE: agents are told to ground their ideas in it, recombine it, or extend past it. Pass the raw digest markdown (verbatim from q_research) -- never your own summary of it, and never your own ideas; those stay behind the anti-bias gate. Distinct from prior_ideas, whose do-not-repeat framing marks content to diverge AWAY from.

prior_ideas, when supplied, seeds a divergence round: the agents are told the listed ideas are already on the table and must not be repeated -- used by the --extended flow to push past round 1. Composes with research (evidence stays evidence; ideas stay do-not-repeat).

grounding, with prior_ideas, runs a validation-guide pass over the listed ideas instead of diverging past them -- used by q-skystorm Stage 2.

Optionally assign a cognitive stance per agent via roles, a list of 'stance:agent' strings (stances: skeptic, architect, security, maintainer, analyst, neutral, visionary, pioneer). Unassigned agents use their default stance.

gemini_model, when supplied, runs the gemini seat on that agy model for this invocation only (an id exactly as printed by agy models, e.g. 'claude-opus-4-6-thinking').

Expected wall-clock to completion: 30s-4min depending on the agents and topic complexity.

Inputs: cwd (required), topic (required), host, roles, +8 more. Returns: object

q_plan_startA

Start a q-plan run in the background. Returns {"job_id": str} immediately. The current host's external seats run in parallel from a structurally bias-free starting point. Retrieve results by calling q_await with the returned job_id.

Between the start and the await, the caller is expected to form its own plan — this is the structural anti-bias gate.

Optionally assign a cognitive stance per agent via roles, a list of 'stance:agent' strings (stances: skeptic, architect, security, maintainer, analyst, neutral, visionary, pioneer). Unassigned agents use their default stance.

gemini_model, when supplied, runs the gemini seat on that agy model for this invocation only -- an id exactly as printed by agy models, e.g. 'claude-opus-4-6-thinking' to get a Claude answer from the same AI Pro plan when Gemini quota is tight or a different perspective is wanted.

Expected wall-clock to completion: 30s-4min depending on the agents and codebase size.

Inputs: cwd (required), task (required), host, roles, +5 more. Returns: object

q_researchA

Fetch prior art for a topic from arXiv + OpenAlex + Europe PMC (papers), Context7 (library docs), GitHub (repos), and HuggingFace (models), and return a markdown digest.

Europe PMC covers the life-sciences preprint tier arXiv does not carry -- bioRxiv, medRxiv, Research Square -- so it is the source that earns its slot on biology/medicine topics and returns 0 on pure-software ones. Its hits are labelled by preprint server ("bioRxiv") and are NOT peer-reviewed; weigh them accordingly.

Not subject to the council's anti-bias gate -- this is external prior art, not peer output. Call it during the own-work window of a q_brainstorm or q-skystorm run to ground the synthesis. sources defaults to all six; pass a subset like ["arxiv", "openalex"] to restrict it.

Query shaping matters: pass a query that is SHORT and distinctive -- short is not the same as generic. Anchor it in 2+ domain-specific terms (the field PLUS the specific method/concept), never a bare common word ('data', 'model', 'network') or a token that doubles as an author surname -- those keyword-match unrelated work (author names, generic surveys, stray docs) and return non-zero but OFF-TOPIC noise -- sanity-check that returned titles belong to your domain, and if they are off-topic the query was too generic: re-anchor with more domain context and call q_research again rather than leaning on them. (This same-domain check assumes you want grounding in your own field -- if you are deliberately hunting cross-domain structural analogies instead, judge a hit by structural kinship to the problem, not literal subject-matter overlap; an off-domain hit is then the find, not noise.) Not a full paragraph either. Per source: arXiv parses topic as a boolean field -- a long/diffuse query loose-matches to famous-but-irrelevant papers, and boolean punctuation (parens, AND/OR, quotes) triggers a 400; OpenAlex tolerates prose but length dilutes relevance to generic surveys; Context7 wants a library/topic name and will keyword-match off-topic repos; GitHub/HuggingFace are popularity-ranked artifact searches that whiff on non-software/non-ML topics. The digest's per-source count footer shows which sources whiffed -- rework and retry those, unless the 0 is domain-legitimate (GitHub/HuggingFace on a non-software topic, Europe PMC on a non-biology one, Context7 on a topic with no matching library), which is a real answer, not a gap to close.

Treat every other digest result as provisional until it earns trust: a 0 that is NOT one of the domain-legitimate cases above is not automatically "no prior art" either (it may just be a bad query), and non-zero hits that read scattered or off-topic are not evidence -- both are a signal to reframe (sharper domain anchor, fewer/different terms) and retry, not something to build a conclusion on.

Failed sources are reported inline under 'Sources unavailable' rather than failing the call -- each with a retry hint, and the right move differs by error. An errored source is almost never a dead backend: an arXiv error (400) means YOUR query is too long or has boolean punctuation, so shorten it to a few keywords, strip operators, and call q_research again; a 401/403 or an OpenAlex 503 is a CONFIG case, not a flake -- the key was rejected, or OpenAlex is load-shedding anonymous search, so a bare retry just loops (set the source's key -- OPENALEX_API_KEY is free -- or lean on the other sources and say so); only a plain timeout/flake is transient and worth retrying as-is. Do NOT report a source unavailable, and do NOT fall back on your own knowledge, until a reworked retry has ALSO failed -- treating the first error as terminal is the failure to avoid. Bounded by per-request timeouts (~10-15s each); the GitHub and HuggingFace backends fan out one request per distinctive query term (up to 4), run sequentially, so those two sources' wall-clock can reach a few times that.

The digest OPENS with a deterministic Research status: line -- OK, RETRY-RECOMMENDED (USUALLY with a server-suggested shorter query to resubmit verbatim, shown as · try: "..."; when it is ABSENT the detail text says what to do, and the two absent cases differ -- a backend/infrastructure failure says RETRY THE SAME query, while an un-shortenable query says RE-ANCHOR with different domain terms), CONFIG (a key/anonymous-access problem no retry fixes), or (in exploratory mode) LOW-OVERLAP. Act on it before anything else: on RETRY-RECOMMENDED, resubmit the suggested query if one is given, else follow the detail (retry the same query on an infrastructure failure, or re-anchor with different domain-specific terms if it cannot be shortened) -- before concluding "no prior art". Mechanically-fixable failures (arXiv 400, a transient flake) are already retried inside the tool -- a repaired source shows a ↻ note, so a first-attempt error you never see was handled, not hidden.

mode is 'grounded' (default; brainstorm -- home-domain grounding, where a low-overlap result is a defect the verdict flags RETRY-RECOMMENDED) or 'exploratory' (skystorm -- a deliberate cross-domain method pivot, where low overlap is expected and reported as LOW-OVERLAP without forcing a retry). Exploratory mode also adds a ### Field map section (the OpenAlex subfield distribution for the query) showing which fields the method actually spans -- the skystorm topology readout. Query discipline is identical in both modes; only the low-overlap interpretation differs.

Inputs: topic (required), mode, limit, sources. Returns: result

q_review_startA

Start a q-review run in the background. Returns {"job_id": str} immediately. Each agent independently reviews real code changes, then converges across rounds. Round 1 is structurally bias-free; later rounds embed each agent's own prior plus peers' priors so sustained agreement becomes visible. Retrieve results by calling q_await with the returned job_id.

Between the start and the await, the caller is expected to form its own code review of the diff — this is the structural anti-bias gate.

target selects what to review (default: branch vs main, committed + uncommitted). 'working' = uncommitted tracked changes only; 'pr:N' or a github PR URL = an open PR (title/body orient the review); 'A..B'/'A...B' = an explicit range; 'all' = the whole codebase (agents read cwd — pair with scope_path). An empty diff (other than 'all') short-circuits: the job returns a 'nothing to review' message without running the council.

scope_path, when supplied, points at a scope doc declaring what is in/out-of-scope and which risks are accepted; it is embedded verbatim so the council does not converge on out-of-bounds findings.

extended runs 4 rounds with a stance rotation at round 3 (agents swap stances and re-examine all priors); the default is 2 rounds with no rotation. mode is 'revise' (agents soften/strengthen in light of peers) or 'critique' (agents attack peer points).

verbose defaults to false: the council writes terse output (no padding, path:line over pasted code, and later rounds collapse each still-held finding to one HELD line while preserving the agreement count). Set true only when you want the full unabridged deliberation — a much larger matrix.

Optionally assign stances per agent via roles, a list of 'stance:agent' strings (stances: skeptic, architect, security, maintainer, analyst, neutral, visionary, pioneer).

gemini_model, when supplied, runs the gemini seat on that agy model for this invocation only (an id exactly as printed by agy models, e.g. 'claude-opus-4-6-thinking').

Expected wall-clock to completion: 1-8min default; 4-15min when extended=true. Pick extended deliberately.

Inputs: cwd (required), host, mode, roles, +8 more. Returns: object

q_validate_startA

Start a q-validate run in the background. Returns {"job_id": str} immediately. Each agent independently reviews the plan file, then deliberates across rounds. Round 1 is structurally bias-free; later rounds embed each agent's own prior plus peers' priors. Retrieve results by calling q_await with the returned job_id.

Between the start and the await, the caller is expected to form its own review — this is the structural anti-bias gate.

extended runs 4 rounds with a stance rotation at round 3 (agents swap stances and re-examine all priors); the default is 2 rounds with no rotation. mode is 'revise' (agents soften/strengthen in light of peers) or 'critique' (agents attack peer points).

verbose defaults to false: the council writes terse output (no padding, path:line over pasted code, later rounds omit restating unchanged points). Set true only for the full unabridged deliberation — a much larger matrix.

Optionally assign stances per agent via roles, a list of 'stance:agent' strings (stances: skeptic, architect, security, maintainer, analyst, neutral, visionary, pioneer).

gemini_model, when supplied, runs the gemini seat on that agy model for this invocation only (an id exactly as printed by agy models, e.g. 'claude-opus-4-6-thinking').

Expected wall-clock to completion: 1-8min default; 4-15min when extended=true. Pick extended deliberately.

Inputs: cwd (required), plan_path (required), host, mode, +7 more. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 6 tools

    Disambiguation5/5

    Each tool has a clearly distinct function: planning, brainstorming, validation, code review, research, and result retrieval. There is no overlap in purpose; descriptions reinforce the boundaries.

    Naming Consistency5/5

    All tools follow a uniform 'q_' prefix with an action verb (plan_start, brainstorm_start, validate_start, review_start, research, await). The two non-start tools still share the prefix and verb style, making the pattern predictable.

    Tool Count5/5

    Six tools is well-scoped for a code-quality council suite: four distinct run types plus research and a blocking retrieval. Each tool earns its place without redundancy or bloat.

    Completeness4/5

    The core lifecycle (start runs, retrieve results) is fully covered, and research supports the workflow. Minor gaps exist—no job-listing or cancellation tool—but agents can work around them by awaiting each job, so the surface remains practical.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI coding agents to read each other's conversation history read-only and sanitized, so you can continue work across different tools without re-explaining context.
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Allows users to manage multiple remote AI coding agents from a single Claude Code session, with a controlled execution model where operations require moderator approval.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables multi-model LLM council reviews and parallel sidecar conversations within Claude, allowing Claude to orchestrate structured reviews from various AI models and fold their responses back into the session.
      739 npm
      2
      MIT
    • F
      license
      A
      quality
      B
      maintenance
      Enables coding agents to perform workspace-confined file operations, read-only Git inspection, and structured shell commands, while requiring out-of-band human approval for mutations and external executions and maintaining an audit trail.
      14
      3
      -