Deliberation

by antonbabenko

450 downloads

Not rated

GitHub

About

A second opinion in Claude Code or any MCP host, from GPT, Gemini, Grok, and 400+ OpenRouter models. Seven domain experts review plans, find bugs, and weigh tradeoffs - advisory by default, or implementing when you ask.

Details

Author: antonbabenko
Downloads: 450
Categories: AI

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Deliberation

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

From the repository

Install via any MCP host using stdio: add the server configuration with npx -y @antonbabenko/deliberation-mcp. For Claude Code, use the plugin marketplace: /plugin marketplace add antonbabenko/agent-plugins, then /plugin install deliberation@antonbabenko, and run /deliberation:setup. The server automatically detects which providers are configured and routes accordingly.

`ask-all`

Fan out one question to GPT, Gemini, Grok, and any configured OpenRouter models in parallel for independent second opinions, then return all results (advisory, no cross-contamination). Pass `expert` to apply a persona to every delegate. Calls external LLM providers (each needs its key/CLI; provider rate limits apply); returns a text-wrapped JSON envelope { results[], omitted[] } and persists a session record only when sessions.persist is enabled (default off).

`consensus`

Run the FULL multi-round consensus convergence loop server-side with a provider arbiter (blind pass + peer fan-out -> adjudicate -> revise) and return the converged verdict. Default depth is `consensus.maxRounds` (config, default 5); pass `maxRounds` to override. Pass `synthesizeAlways:true` for a SINGLE arbiter synthesis pass instead of the loop (best for open questions, not plan convergence): it returns a free-text `synthesis` and `maxRounds` is ignored. Configure the arbiter via `consensus.arbiter` - a concrete provider/openrouter alias runs server-side; `host` mode returns the opinions for YOU to synthesize. Advisory; pass `expert` to apply a persona. Calls external providers (keys/CLI; rate limits apply); returns a text-wrapped JSON envelope (split verdict/synthesis, loop fields nullable) and persists a session record only when sessions.persist is enabled (default off). NOTE (Claude Code): use the `/consensus` slash command for the transcript-visible host-arbiter loop (it drives `consensus-step`); this tool is the provider-arbiter path for any host.

`consensus-step`

Client-driven consensus loop where YOU (the host model) are the arbiter, one action per call: init (returns sessionId + blind prompt) -> record_blind (your pre-commit verdict) -> dispatch_peers (server fans out to the providers) -> submit_adjudication (your verdict + per-issue accept/dismiss/defer) -> submit_revision (your revised plan), looping until converged or consensus.maxRounds rounds (default 5). Only the dispatch_peers action calls external providers; the others are local transitions on the ephemeral per-session loop store (keyed by sessionId, lost on server restart). Each call returns a text-wrapped JSON envelope with the next status/round (plus blindPrompt, opinions[], or finalReport by action). Advisory to the outside world, but mutates server loop state on every call.

`panel`

Return the names of the providers `ask-all` WOULD dispatch for the current config + expert (enabled built-ins + eligible OpenRouter aliases, fanout cap applied), WITHOUT calling them. Use this to discover the panel, then issue one `ask-one` call per provider in parallel for visible per-provider progress. Local and read-only (no provider calls); returns a text-wrapped JSON envelope { providers[], omitted[] }.

`ask-one`

Second opinion from ONE named provider in the active panel (e.g. `codex`, `gemini`, `grok`, `openrouter:<alias>` - get the names from `panel`). Issue N in parallel (one per panel name) so each renders independently as it lands. Calls one external LLM provider (needs its key/CLI; rate limits apply); returns a text-wrapped JSON envelope { result }, or { error, panel } when the name is not in the panel. Advisory, single-shot.

`analyze`

Analyze recent runs from the opt-in debug log (latency/tokens/reasoning-effort per model) plus the session store (verdict agreement rate), and return advisory tuning suggestions (disable a slow/redundant model in ask-all, lower an OpenRouter model's reasoning, adjust maxFanout). Two lenses reported side by side - timing and agreement are NOT joined (no shared run id). Requires `debug.enabled` for the timing lens. Local and read-only (no provider calls, writes nothing); returns a text-wrapped JSON envelope with the two lenses + suggestions. The `/deliberation:analyze` slash command renders this for humans.

`ask-gpt`

Single-provider second opinion via codex (advisory, single-shot). Pass `expert` to apply one of the expert personas. Calls the external codex provider (via the Codex CLI; rate limits apply) and returns a text-wrapped JSON envelope { result }.

`ask-gemini`

Single-provider second opinion via gemini (advisory, single-shot). Pass `expert` to apply one of the expert personas. Calls the external gemini provider (via the Gemini CLI; rate limits apply) and returns a text-wrapped JSON envelope { result }.

`ask-grok`

Single-provider second opinion via grok (advisory, single-shot). Pass `expert` to apply one of the expert personas. Calls the external grok provider (needs XAI_API_KEY; rate limits apply) and returns a text-wrapped JSON envelope { result }.

`ask-openrouter`

Single-provider second opinion via openrouter (advisory, single-shot). Pass `expert` to apply one of the expert personas. Calls the external openrouter provider (needs the OpenRouter API key env; rate limits apply) and returns a text-wrapped JSON envelope { result }.

`architect`

Software architect for system design, tradeoff analysis, and complex decisions. Use for architecture, API/schema design, multi-service interactions, or when a fix has failed twice and needs a fresh perspective. Fans out to the configured provider panel with this persona (advisory; each provider needs its key/CLI, rate limits apply) and returns a text-wrapped JSON envelope { results[] }.

`plan-reviewer`

Work-plan reviewer that verifies a plan is executable before anyone builds. Use to validate an implementation plan for clarity, completeness, and gaps before starting significant work. Fans out to the configured provider panel with this persona (advisory; each provider needs its key/CLI, rate limits apply) and returns a text-wrapped JSON envelope { results[] }.

`scope-analyst`

Pre-planning consultant that catches ambiguities, hidden requirements, and pitfalls before planning begins. Use when a request is vague or could be interpreted multiple ways. Fans out to the configured provider panel with this persona (advisory; each provider needs its key/CLI, rate limits apply) and returns a text-wrapped JSON envelope { results[] }.

`code-reviewer`

Senior engineer doing code review for bugs, security holes, and maintainability - not style nitpicks. Use to review a diff or file before merging. Fans out to the configured provider panel with this persona (advisory; each provider needs its key/CLI, rate limits apply) and returns a text-wrapped JSON envelope { results[] }.

`security-analyst`

Security engineer for threat modeling and vulnerability assessment. Use for auth/authorization changes, untrusted input handling, new endpoints, or a focused security audit. Fans out to the configured provider panel with this persona (advisory; each provider needs its key/CLI, rate limits apply) and returns a text-wrapped JSON envelope { results[] }.

`researcher`

Research specialist for external libraries, frameworks, APIs, and open-source code. Use for 'how do I use X', best-practice, or 'why does this dependency behave this way' questions, with evidence and honest unverified flags. Fans out to the configured provider panel with this persona (advisory; each provider needs its key/CLI, rate limits apply) and returns a text-wrapped JSON envelope { results[] }.

`debugger`

Debugging specialist that produces ranked root-cause hypotheses and the smallest safe fix from a bug report, logs, and code - or says honestly that the evidence shows no bug. Use for crashes, failing tests, or wrong output. Fans out to the configured provider panel with this persona (advisory; each provider needs its key/CLI, rate limits apply) and returns a text-wrapped JSON envelope { results[] }.

`session-get`

Fetch a persisted consensus/ask-all session record by id (opinions, verdict, arbiter, annotations). Requires sessions.persist; local and read-only (no provider calls). Returns a text-wrapped JSON envelope { session }, or { error } when persistence is off or the id is unknown.

`session-revisit`

Re-run a persisted session's ORIGINAL question with the CURRENT providers/config, linking the new run to its source by parentId. Requires sessions.persist; re-runs through the original tool path (which dispatches external providers) and persists a linked child record on success. Returns a text-wrapped JSON envelope (the re-run payload + parentId), or { error } when persistence is off or the id is unknown.

`session-annotate`

Append a freeform note to a persisted session's audit trail - an additive local write, no provider calls. Requires sessions.persist. Returns a text-wrapped JSON envelope { session } (the updated record), or { error } when persistence is off or the id is unknown.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "deliberation": {
            "deliberation": {
                "command": "npx",
                "args": [
                    "-y",
                    "@antonbabenko/deliberation-mcp"
                ],
                "env": {
                    "XAI_API_KEY": "<optional, for Grok>",
                    "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
                }
            }
        }
    }
}

McpServers

{
    "deliberation": {
        "command": "npx",
        "args": [
            "-y",
            "@antonbabenko/deliberation-mcp"
        ],
        "env": {
            "XAI_API_KEY": "<optional, for Grok>",
            "OPENROUTER_API_KEY": "<optional, for OpenRouter>"
        }
    }
}

What it is

Deliberation connects GPT (via the Codex CLI), Gemini (via the Antigravity CLI agy), Grok (xAI), and any OpenAI-compatible model through OpenRouter into one MCP server. You ask once; it routes the question to whichever providers you have configured and synthesizes their answers instead of dumping raw output. Use any subset - it detects what is set up and routes accordingly. Seven experts cover the work, each with a focus: Architect, Plan Reviewer, Scope Analyst, Code Reviewer, Security Analyst, Researcher, Debugger. GPT and Gemini can also implement changes; Grok and OpenRouter advise only.

Install

Any MCP host (stdio): ``

json
{ "mcpServers": { "deliberation": { "command": "npx", "args": ["-y", "@antonbabenko/deliberation-mcp"] } } }



In Claude Code, install the plugin instead:


/plugin marketplace add antonbabenko/agent-plugins
/plugin install deliberation@antonbabenko
/deliberation:setup



Tools


-

ask-all

 - send one question to every configured provider in parallel, then compare the answers
-

consensus

 - providers review while the host commits a blind verdict, then adjudicates; converges only when models agree
-

ask-gpt / ask-gemini / ask-grok / ask-openrouter

 - a single-provider second opinion
- the seven experts, callable directly

Requirements


You need at least one provider:

- GPT: the Codex CLI (

npm i -g @openai/codex, then codex login

)
- Gemini: the Antigravity CLI (

agy

), logged in
- Grok:

XAI_API_KEY

 (get a key at https://console.x.ai)
- OpenRouter:

OPENROUTER_API_KEY plus models declared in ~/.claude/deliberation/config.json`; works with any OpenAI-compatible endpoint (Ollama, vLLM, LM Studio) Node 18+. The server is bundled and ships with zero runtime dependencies.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

ask-all

consensus

consensus-step

panel

ask-one

analyze

ask-gpt

ask-gemini

ask-grok

ask-openrouter

architect

plan-reviewer

scope-analyst

code-reviewer

security-analyst

researcher

debugger

session-get

session-revisit

session-annotate

Claude Desktop / Cursor

McpServers

What it is

Install

Tools

Requirements

Install

More like this

Context 7

1Panel

🔎 GPT Researcher

Serena

FastMCP v2 🚀

MaxKB

`ask-all`

`consensus`

`consensus-step`

`panel`

`ask-one`

`analyze`

`ask-gpt`

`ask-gemini`

`ask-grok`

`ask-openrouter`

`architect`

`plan-reviewer`

`scope-analyst`

`code-reviewer`

`security-analyst`

`researcher`

`debugger`

`session-get`

`session-revisit`

`session-annotate`