The new clink (CLI + Link) tool connects external AI CLIs directly into your workflow:

• Connect external CLIs like Gemini CLI, Codex CLI, and Claude Code directly into your workflow
• CLI Subagents - Launch isolated CLI instances from within your current CLI! Claude Code can spawn Codex subagents, Codex can spawn Gemini CLI subagents, etc. Offload heavy tasks (code reviews, bug hunting) to fresh contexts while your main session's context window remains unpolluted. Each subagent returns only final results.
• Context Isolation - Run separate investigations without polluting your primary workspace
• Role Specialization - Spawn planner, codereviewer, or custom role agents with specialized system prompts
• Full CLI Capabilities - Web search, file inspection, MCP tool access, latest documentation lookups
• Seamless Continuity - Sub-CLIs participate as first-class members with full conversation context between tools

# Codex spawns Codex subagent for isolated code review in fresh context
clink with codex codereviewer to audit auth module for security issues
# Subagent reviews in isolation, returns final report without cluttering your context

# Consensus from different AI models → Implementation handoff with full context preservation
Use consensus with gpt-5.5 and gemini-3.1-pro-preview to decide: dark mode or offline support next
Continue with clink gemini - implement the recommended feature
# Gemini receives full debate context and starts coding immediately

👉 Learn more about clink

Why rely on one AI model when you can orchestrate them all?

A Model Context Protocol server that supercharges tools like Claude Code, Codex CLI, and IDE clients such as Cursor or the Claude Dev VS Code extension. Panel MCP connects your favorite AI tool to multiple AI models for enhanced code analysis, problem-solving, and collaborative development.

Panel supports conversation threading so your CLI can discuss ideas with multiple AI models, exchange reasoning, get second opinions, and even run collaborative debates between models to help you reach deeper insights and better solutions.

Your CLI always stays in control but gets perspectives from the best AI for each subtask. Context carries forward seamlessly across tools and models, enabling complex workflows like: code reviews with multiple models → automated planning → implementation → pre-commit validation.

You're in control. Your CLI of choice orchestrates the AI team, but you decide the workflow. Craft powerful prompts that bring in Gemini 3.1 Pro, GPT-5.5, Claude Opus 4.8, Grok-4.3, or local offline models exactly when needed.

Prerequisites: Python 3.10+, Git, uv installed

1. Pick how you want to authenticate — at least one of:

Free OAuth via subscription CLIs (zero API spend; CLIs use your existing logins):

• Codex CLI — codex login (uses your ChatGPT subscription)
• Gemini CLI — first run prompts Google OAuth
• Claude CLI — claude /login (uses your Claude subscription)

OAuth CLIs are the cheapest path: clink, panel, multiaudit, and bugfind all route through them automatically when available, falling back to paid API only on quota exhaustion.

Paid API keys (needed for Grok, and as the OAuth fallback safety net):

• Anthropic — Claude Opus 4.8 / Sonnet 5
• OpenAI — GPT-5.5 / 5.4 / 5.1-codex
• Gemini — Gemini 3.1 Pro
• X.AI — Grok-4.3 / 4.1-fast (no OAuth path; API only)
• OpenRouter — Access multiple models with one API
• Azure OpenAI — Enterprise OpenAI deployments
• DIAL — Vendor-agnostic model access
• Ollama — Local models (free)

Soft-landing on zero everything: if you start the server with neither API keys nor authed CLIs, it doesn't crash — it logs a friendly capability summary and the always-available tools (listmodels, version, web_url, graph queries) still work. Set or login to whatever you want, restart your MCP client, and you're off.

2. Install (choose one):

Option A: Clone and Automatic Setup (recommended)

git clone https://github.com/DanielGuru/panel-mcp-server.git
cd panel-mcp-server

# Copy and edit config
cp .env.example .env
# Edit .env and add your API keys

# Handles everything: setup, config, API keys from system environment.
# Auto-configures Claude Desktop, Claude Code, Gemini CLI, Codex CLI, Qwen CLI
./run-server.sh

Option B: Instant Setup with uvx

// Add to ~/.claude/settings.json or .mcp.json
// Set whichever keys you have — at least one is enough.
// (If you only have authed OAuth CLIs, you can leave keys empty and
// still use clink/panel/multiaudit/bugfind via the free OAuth path,
// modulo the grok-4.3 caveat above.)
{
  "mcpServers": {
    "panel": {
      "command": "bash",
      "args": ["-c", "for p in $(which uvx 2>/dev/null) $HOME/.local/bin/uvx /opt/homebrew/bin/uvx /usr/local/bin/uvx uvx; do [ -x \"$p\" ] && exec \"$p\" --from git+https://github.com/DanielGuru/panel-mcp-server.git panel-mcp-server; done; echo 'uvx not found' >&2; exit 1"],
      "env": {
        "PATH": "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:~/.local/bin",
        "ANTHROPIC_API_KEY": "your-anthropic-key-or-empty",
        "OPENAI_API_KEY": "your-openai-key-or-empty",
        "GEMINI_API_KEY": "your-gemini-key-or-empty",
        "XAI_API_KEY": "your-xai-key-or-empty",
        "DISABLED_TOOLS": "analyze,refactor,testgen,secaudit,docgen,tracer",
        "DEFAULT_MODEL": "auto"
      }
    }
  }
}

3. Start Using!

Magic phrases — the killer features:

"multiaudit it"          # right before commit/push: 4-way panel reviews the diff
"bugfind it: <bug>"      # describe a bug; the panel investigates + proposes a fix

Direct multi-model orchestration:

"Use panel to analyze this code for security issues with gemini-3.1-pro-preview"
"Debug this error with grok-4.3 and then get gpt-5.5 to suggest optimizations"
"Plan the migration strategy with panel, get consensus from multiple models"
"clink with cli_name=\"gemini\" role=\"planner\" to draft a phased rollout plan"

👉 Complete Setup Guide with detailed installation, configuration for Gemini / Codex / Qwen, and troubleshooting
👉 Cursor & VS Code Setup for IDE integration instructions

Panel activates any provider that has credentials in your .env. Copy .env.example to .env and add your keys. See .env.example for the full list of options.

Note: Each tool comes with its own multi-step workflow, parameters, and descriptions that consume valuable context window space even when not in use. To optimize performance, some tools are disabled by default. See Tool Configuration below to enable them.

Collaboration & Planning (Enabled by default)

• clink - Bridge requests to external AI CLIs (Gemini planner, codereviewer, etc.)
• chat - Brainstorm ideas, get second opinions, validate approaches. With capable models (GPT-5, Gemini 3.1 Pro), generates complete code / implementation
• thinkdeep - Extended reasoning, edge case analysis, alternative perspectives
• planner - Break down complex projects into structured, actionable plans
• consensus - Get expert opinions from multiple AI models with stance steering
• panel - Fan-out one prompt to N models in parallel, with optional adversarial debate rounds and judge synthesis

Code Analysis & Quality

• debug - Systematic investigation and root cause analysis
• precommit - Validate changes before committing, prevent regressions
• codereview - Professional reviews with severity levels and actionable feedback
• analyze (disabled by default - enable) - Understand architecture, patterns, dependencies across entire codebases

Development Tools (Disabled by default - enable)

• refactor - Intelligent code refactoring with decomposition focus
• testgen - Comprehensive test generation with edge cases
• secaudit - Security audits with OWASP Top 10 analysis
• docgen - Generate documentation with complexity analysis

Async Task System

• start_task - Kick off a long-running tool call in the background (non-blocking)
• task_status - Poll whether a background task is still running
• task_result - Retrieve the result of a completed background task
• cancel_task - Cancel a running background task

Execution Graph (SQLite-backed, survives restarts)

• list_runs - List recent tool dispatches; filter by status or tool name
• get_run - Full details for a single run: events, cost, timing, result
• run_tree - Show the parent→child lineage of a run (panel → panelists → clink fallbacks)

Utilities

• apilookup - Forces current-year API/SDK documentation lookups in a sub-process (saves tokens within the current context window), prevents outdated training data responses
• challenge - Prevent "You're absolutely right!" responses with critical analysis
• tracer (disabled by default - enable) - Static analysis prompts for call-flow mapping
• listmodels - List all available AI models across configured providers
• version - Show server version and system information

panel fans out a single prompt to N models simultaneously, runs optional adversarial debate rounds between them, and synthesises a final verdict via a judge model — all in one tool call.

"Use panel with gemini-3.1-pro-preview, gpt-5.5, and grok-4.3 to evaluate three caching strategies,
 then run a debate round and have gemini judge the outcome"

Each panelist gets the same prompt, responds independently, and (in debate mode) sees the other responses before giving a revised stance. The judge synthesises the final answer. Results are written to the SQLite execution graph so you can query them later with get_run / run_tree.

Special panelist host: Panel routes the agent name host through the MCP sampling/createMessage primitive, asking the connected MCP client (Claude Code, etc.) to invoke its own LLM as a peer panelist. Means Claude Code can be a true participant in a debate of its own PR, not just the dispatcher. No paid API call — the host's tokens are the host's problem. Cost tier reports as host_sampling.

Say one of these to Claude Code (or whatever MCP client you're driving) and Panel fires a 4-way audit panel against the current branch's diff:

"OK multiaudit it now" "audit this PR" "panel this branch" "review with all models before I push"

The multiaudit tool reads git diff (vs main, falling back to uncommitted/staged), packages it with recent commit messages for intent context, and dispatches a start_task('panel', ...) with [codex, gemini, claude, grok-4.3], 1 debate round, codex as judge. Returns the task_id + the live web viewer URL so the user can watch the debate unfold while Claude Code stays available to follow up.

host (Claude Code as a peer panelist via MCP sampling) is opt-in, not default — pass panelists=["host", "codex", ...] explicitly. Most MCP hosts (including Claude Code today) don't advertise the sampling capability, so host would fail; the implementation excludes it from defaults to keep the magic-phrase path reliable.

No XAI_API_KEY? The default panelist set includes grok-4.3, which has no OAuth path. If you don't want to set an X.AI key, drop it from the panel: multiaudit panelists=["codex","gemini","claude"] (or set PANEL_MULTIAUDIT_PANELISTS=codex,gemini,claude once in .env to make that the global default).

Default audit rubric (built into the prompt): VERDICT / BUGS / DESIGN CONCERNS / SECURITY / MISSING TESTS / WHAT YOU'D ATTACK. Diff truncated at 60KB with a clear marker so panelists know they're reasoning about a subset.

multiaudit                                  # default panelists, 1 debate round
multiaudit extra_context="focus on the    # narrow the audit
            new auth flow specifically"
multiaudit panelists=["host","gpt-5.5"]   # override panelist set
multiaudit base_branch="HEAD"             # audit only uncommitted changes
multiaudit debate_rounds=2                # deeper pressure-testing

Sister tool to multiaudit, but bug-shaped. Say one of these and Panel fires a 4-way investigation panel against your bug description:

"bugfind it" "find this bug" "use panel to find the bug" "what's breaking, panel debug it"

The bugfind tool takes the user's bug description, auto-attaches debugging context (recent commits, the tail of logs/mcp_server.log filtered to ERROR/Traceback/Failed/Exception, optionally explicitly attached files), and dispatches a start_task('panel', ...) with [codex, gemini, claude, grok-4.3], 1 debate round, codex as judge. Returns the task_id + live viewer URL.

The investigation rubric is intentionally different from multiaudit's audit rubric: REPRO (exact steps) → ROOT CAUSE (file:line + reasoning) → MINIMAL FIX (smallest diff, with code snippet, ideally as a unified diff) → REGRESSION TEST (the test that would have caught it, with assertion specifics) → BLAST RADIUS (what else this affects) → WHAT YOU MISSED (what the original implementer likely didn't consider).

The judge synthesises a single fix proposal you can review and apply. When file paths or symbols appear in the description, pass attached_files=[<absolute paths>] so the panelists can read the actual code rather than guessing. Skip the log tail (skip_log_tail=true) for UI/doc bugs that aren't reflected in logs.

bugfind "the viewer header shows 'grok-4.3' instead of 'panel'"
bugfind "..." attached_files=["/abs/path/to/utils/web_viewer.py"]
bugfind "..." debate_rounds=2                 # deeper pressure-testing
bugfind "..." panelists=["claude","codex"]    # 2-way only
bugfind "..." skip_log_tail=true              # UI bug, logs irrelevant

Same XAI_API_KEY caveat as multiaudit — the default panelist set includes grok-4.3. Drop it via panelists=["codex","gemini","claude"] or set PANEL_BUGFIND_PANELISTS=codex,gemini,claude globally if you don't want to set an X.AI key.

Security: attached_files contents and the auto-attached log tail go verbatim to the configured panelist APIs. Panel applies a redaction pass that strips API-key shapes (sk- / sk-ant- / AIza / xai-), JWTs, Bearer headers, and user-home paths before dispatch — but defence-in-depth: don't attach files containing secrets you wouldn't want in OpenAI / Anthropic / Gemini / xAI request logs.

Every tool dispatch — including nested panel fanouts, clink subagents, async tasks, and OAuth-to-API fallbacks — is recorded in a per-repo .panel/execution_graph.db. This gives you:

• Restart-safe panels — if Panel restarts mid-panel, prior results are still readable
• Cost attribution — run_tree returns a cost-tier rollup (oauth_free / api_paid / oauth_fallback_paid / host_sampling) so you can see exactly which sub-call drove spend
• Audit trail — replay prior runs, compare model behaviour over time
• Run lineage — run_tree shows the full parent→child call graph including fallback edges

Per-repo by default. Default DB path is <cwd>/.panel/execution_graph.db — each project Claude Code opens has its own isolated debate history, so the live web viewer for one repo never shows runs from another. The .panel/ directory is gitignored.

Override with PANEL_GRAPH_DB=<absolute path> for a shared / global view (e.g. the legacy ~/.panel/execution_graph.db). Set to empty string to disable the graph entirely.

Panel serves a tiny local HTTP server (default http://127.0.0.1:8765/) that lazy-starts on the first Panel tool call — no tab pops if you never use Panel this session. Browser opens automatically when it does start.

Single page renders the execution graph live:

• Every panel run, panelist sub-call, OAuth fallback edge, judge synthesis
• Per-leaf cost tier badges (oauth_free / oauth_fallback_paid / api_paid / host_sampling)
• Live activity feed for in-flight runs — every emit_progress event from clink subprocesses (file_read, tool_use, text_chunk, etc.) shows up in real time, colour-coded by type, max-height scrolling so it doesn't grow unbounded
• Auto-selects the most recent active run on first load — you land on the live thing without clicking
• HTML-escaped + class-name-sanitised; bad query params return 400 instead of crashing the daemon

Updates over Server-Sent Events (/events) — the viewer subscribes via EventSource and only re-fetches when the execution graph version changes; falls back to 5s polling if the SSE connection drops. All four flagship providers (Anthropic / OpenAI / xAI / Gemini) stream by default — direct-API panelists' partial responses appear in the transcript pane as they're written, throttled to ~10 Hz so SQLite stays responsive. Opt out per-provider with PANEL_OPENAI_STREAM=0 / PANEL_GEMINI_STREAM=0. Anthropic streams unconditionally.

The MCP tool web_url returns the live URL on demand so Claude Code can hand it to the user mid-conversation.

# Default configuration (from .env.example)
DISABLED_TOOLS=analyze,refactor,testgen,secaudit,docgen,tracer

# To enable specific tools, remove them from the list
# Example: Enable analyze tool
DISABLED_TOOLS=refactor,testgen,secaudit,docgen,tracer

# To enable ALL tools
DISABLED_TOOLS=

{
  "mcpServers": {
    "panel": {
      "env": {
        "DISABLED_TOOLS": "refactor,testgen,secaudit,docgen,tracer",
        "DEFAULT_MODEL": "auto",
        "DEFAULT_THINKING_MODE_THINKDEEP": "high",
        "ANTHROPIC_API_KEY": "your-anthropic-key",
        "OPENAI_API_KEY": "your-openai-key",
        "GEMINI_API_KEY": "your-gemini-key",
        "XAI_API_KEY": "your-xai-key",
        "LOG_LEVEL": "INFO",
        "CONVERSATION_TIMEOUT_HOURS": "3",
        "MAX_CONVERSATION_TURNS": "50"
      }
    }
  }
}

{
  "mcpServers": {
    "panel": {
      "env": {
        "DISABLED_TOOLS": ""
      }
    }
  }
}

AI Orchestration

• Auto model selection - Claude picks the right AI for each task
• Multi-model workflows - Chain different models in single conversations
• Conversation continuity - Context preserved across tools and models
• Context revival - Continue conversations even after context resets
• Panel debates - Fan-out to N models with adversarial rounds and judge synthesis
• Async tasks - Long-running calls run in background, poll for results

Model Support

• Multiple providers - Anthropic, Gemini, OpenAI, Azure, X.AI, OpenRouter, DIAL, Ollama
• Latest models - Claude Opus 4.8 / Sonnet 5, GPT-5.5 / 5.4 / 5.1-codex, Gemini 3.1 Pro, Grok-4.3 / 4.1-fast, local Llama
• Thinking modes - Control reasoning depth vs cost
• Vision support - Analyze images, diagrams, screenshots

Developer Experience

• Guided workflows - Systematic investigation prevents rushed analysis
• Smart file handling - Auto-expand directories, manage token limits
• Web search integration - Access current documentation and best practices
• Large prompt support - Bypass MCP's 25K token limit
• SQLite execution graph - Durable audit trail at <cwd>/.panel/execution_graph.db (per-repo)

Multi-model Code Review:

"Perform a codereview using gemini-3.1-pro-preview and gpt-5.5, then use planner to create a fix strategy"

→ Claude reviews code systematically → Consults Gemini 3.1 Pro → Gets GPT-5.5's perspective → Creates unified action plan

Collaborative Debugging:

"Debug this race condition with max thinking mode, then validate the fix with precommit"

→ Deep investigation → Expert analysis → Solution implementation → Pre-commit validation

Architecture Planning:

"Plan our microservices migration, get consensus from gemini-3.1-pro-preview and claude-opus-4-8 on the approach"

→ Structured planning → Multiple expert opinions → Consensus building → Implementation roadmap

Panel Debate:

"Use panel with gemini-3.1-pro-preview, gpt-5.5, and grok-4.3 to debate: REST vs GraphQL for our API"

→ 3 models respond independently → Debate round → Judge synthesises final recommendation

Async Long Task:

"start_task: run secaudit on the entire codebase with claude-opus-4-8"
# ... keep working ...
"task_status <task_id>" → check progress
"task_result <task_id>" → get full report when done

👉 Advanced Usage Guide for complex workflows, model configuration, and power-user features

📖 Documentation

• Onboarding - Get from git clone to a working multiaudit in 10 minutes
• Docs Overview - High-level map of major guides
• Getting Started - Complete setup guide
• Tools Reference - All tools with examples
• Advanced Usage - Power user features
• Configuration - Environment variables, restrictions
• Adding Providers - Provider-specific setup (OpenAI, Azure, custom gateways)
• Model Ranking Guide - How intelligence scores drive auto-mode suggestions

🔧 Setup & Support

• WSL Setup - Windows users
• Troubleshooting - Common issues
• Contributing - Code standards, PR process

Apache 2.0 License - see LICENSE file for details.

Panel MCP is a substantially-rewritten fork of BeehiveInnovations/pal-mcp-server (formerly zen-mcp-server). The core tool framework, provider abstraction, and several workflow tools (chat, consensus, codereview, debug, thinkdeep, planner, precommit, etc.) were inherited from upstream. Substantial new orchestration surfaces (panel debate, multiaudit, async task system, OAuth-to-API fallback, durable execution graph, live web viewer, per-token streaming, central validated dispatch, bounded provider concurrency) were added in this fork.

Also built on top of:

• MCP (Model Context Protocol)
• Codex CLI
• Claude Code
• Gemini
• OpenAI
• Anthropic
• Azure OpenAI