ModelCouncil for Claude Desktop, Claude.ai, Cursor, and ChatGPT

What you get

• Council queries — ask one question, get parallel responses from Claude, GPT, and Gemini synthesized into a Decision Board (recommendation, risks, consensus, disagreements, rare finds).
• Diamond mode — for high-stakes decisions, have the models cross-review each others' responses before synthesis. Async — runs in the background, you get an email when it's done if you disconnect.
• Project context — every query runs against your uploaded project documents, automatically. No copy-pasting.
• Full web-UI mirror — every MCP query appears in your ModelCouncil dashboard with a thread, just like web queries.

What NOT to expect

Honest about the edges — these are common misconceptions worth clearing up before you set up.

• Not an automatic import of your Claude.ai (or ChatGPT) thread. The MCP tool sees what you pass it: project_id, question, and optional additional_context. If you want chat history factored in, paste the relevant chunk into additional_context.
• Not a live workspace sync. Documents you uploaded to a ModelCouncil project are available. Documents you have open in your editor are not — unless your editor exposes them as its own MCP tools.
• Not (yet) in the Anthropic or OpenAI app directories. Setup is self-serve via paste-a-URL. We're working on verification.
• Not magically faster than the web app. Same models, same call paths. Diamond Mode still takes 30s–a few minutes — that's why it's async with a poll-by-query-id pattern.
• Not free or unlimited. Same per-query economics as the dashboard. The $10 per-call hard cap below is a safety net, not a budget.

Step 1: Get an API key

1. Sign in at modelcouncil.co/settings and scroll to API Keys & MCP.
2. Click New key. Give it a descriptive name like "Cursor on my laptop" or "Claude Desktop home".
3. Copy the key immediately. It's shown once — we don't store the full value. If you lose it, revoke and create a new one.

Step 2: Configure your MCP client

ModelCouncil's MCP server speaks Streamable HTTP. Configure it once per client; the same key works across clients.

Name: ModelCouncil
URL: https://modelcouncil.co/api/mcp

(Leave OAuth Client ID and Client Secret BLANK — Claude handles
OAuth automatically via Dynamic Client Registration. You do NOT need
to generate an API key in Settings for this flow; that's only for
Cursor and Claude Code CLI below.)

Name: ModelCouncil
URL: https://modelcouncil.co/api/mcp
Authentication: OAuth (default)

(Leave Client ID and Client Secret BLANK — ChatGPT handles OAuth via
Dynamic Client Registration, same as Claude.)

{
  "mcpServers": {
    "modelcouncil": {
      "url": "https://modelcouncil.co/api/mcp",
      "headers": {
        "Authorization": "Bearer mc_live_paste_your_key_here"
      }
    }
  }
}

{
  "mcpServers": {
    "modelcouncil": {
      "url": "https://modelcouncil.co/api/mcp",
      "headers": {
        "Authorization": "Bearer mc_live_paste_your_key_here"
      }
    }
  }
}

Two auth flows — and which to use

ModelCouncil supports both auth flows the MCP ecosystem uses:

• OAuth 2.1 + PKCE (Claude Desktop, Claude.ai web, ChatGPT) — the client handles registration + authorization automatically. You only see a consent screen. Tokens expire after 30 days and auto-refresh. This is the default for the Claude and ChatGPT desktop/web apps.
• Static Bearer token (Cursor, Claude Code CLI) — you generate a key in Settings, paste it into a JSON config file. The token is long-lived (never expires) and survives across app restarts. CLI / IDE tools that don't have a browser-redirect flow use this.

You don't have to choose — they coexist. Manual keys appear in Settings; OAuth-authorized apps appear under Connected apps. Revoke either at any time.

Advanced: legacy claude_desktop_config.json

Claude Desktop still accepts a static-Bearer JSON config alongside the Connectors UI. Most users should use the Connectors flow above, but the JSON path is useful for sharing a config across machines or scripting it into a setup tool.

// ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
// %APPDATA%\Claude\claude_desktop_config.json (Windows)
{
  "mcpServers": {
    "modelcouncil": {
      "url": "https://modelcouncil.co/api/mcp",
      "headers": {
        "Authorization": "Bearer mc_live_paste_your_key_here"
      }
    }
  }
}

Quit and reopen Claude Desktop after editing. If both the Connectors UI and a JSON entry are configured for the same URL, the Connectors entry wins.

Other MCP clients

ModelCouncil uses standard MCP Streamable HTTP transport. Any spec-compliant client can connect. For static-Bearer clients, the minimum config is the URL https://modelcouncil.co/api/mcp and an Authorization: Bearer mc_live_... header. For OAuth clients, point them at the URL and let them probe /.well-known/oauth-authorization-server for registration + auth endpoints.

Step 3: Use the tools

The AI client follows a find-or-create flow: list_projects first to discover existing projects, create_project if none match the topic, then query_council or query_diamond_mode against the chosen id.

(no arguments)

name: string (required, 3-80 chars, trimmed) — topic-shaped noun phrase
description: string (optional, ≤500 chars) — 1-2 sentences explaining the project's scope

project_id: UUID (required, from list_projects or create_project)
question: string (required, ≤10000 chars)
model_tier: "pro" (default — $0.10-0.20 per query) | "fast" ($0.04-0.08 per query)
model_selection: array of "anthropic" | "openai" | "google" | "xai" (optional, 2-3)
additional_context: string (optional, ≤500K chars) — conversation history to send alongside
allow_web_search: boolean (optional, default false) — when true, runs one Google-grounded search (Gemini Flash) before dispatching; every model deliberates over the same evidence block. ~$0.003 extra, rolled into the $10 cap. Use for questions about current/recent info not in your docs.

project_id: UUID (required, from list_projects or create_project)
question: string (required, ≤10000 chars)
model_tier: "fast" | "pro" (default: "pro" — recommended for high-stakes)
model_selection: array of "anthropic" | "openai" | "google" | "xai" (optional, 2-3)
allow_web_search: boolean (optional, default false) — when true, runs one Google-grounded search (Gemini Flash) before Round 1; every R1 model deliberates over the same evidence block, R2 cross-review and synthesis inherit it. ~$0.003 extra, folded into the final Diamond bill. Use for questions about current/recent info not in your docs.

query_id: UUID (required, from query_diamond_mode response or query_council)

Getting the full response back

Claude.ai and ChatGPT often summarize the council's response rather than quoting it verbatim — that's the AI client's choice, not a ModelCouncil truncation. The tool itself returns the complete output every time. Four ways to see everything:

• Click the "View on ModelCouncil →" link. Every tool response prepends a deep-link to the specific Decision Board / project in your dashboard. The link survives AI summarization — even when Claude truncates the rest, you can one-click open the full untruncated board.
• Ask explicitly: "Show me the full Decision Board verbatim" or "Quote the entire tool response — don't summarize."
• Open your dashboard: every MCP query mirrors into ModelCouncil with the full content untouched. Visit your projects at modelcouncil.co/projects.
• Re-fetch via query_id: ask the AI to call get_query_status with the query_id from the original response.

Billing & limits

Same per-query economics as the web dashboard. The numbers below are observed production ranges as of May 2026 — your actual cost scales with context size and selected model tier.

• Standard queries: typically $0.04–$0.20 per call. Lower end is Fast tier on a small project; upper end is Pro tier with significant context.
• Diamond Mode: typically $0.20–$1.00 per call, up to ~$2 on very large 200K-token projects. Diamond makes ~3× the gateway calls of a standard query (R1 + R2 cross-review + synthesis).
• $10 per-query hard cap. MCP queries estimated above $10 are rejected before dispatch (no interactive UI to confirm higher-cost runs). For exceptional cases, use the web app.
• $50/day default cap per key. Adjust up to $200/day in Settings → API Keys & MCP → Edit. The daily cap is a safety net, not a fraud-prevention mechanism.
• Insufficient-balance pre-check. If your remaining balance can't cover the estimated cost of the query, you'll get a structured insufficient_balance error — no half-finished bill. Top up and retry.
• 60 requests/minute rate limit per key. Independent from your web-UI rate limit — a leaked key won't exhaust your web budget.
• 1 concurrent query per user. If you fire a second query (from any client) while one is in-flight, you'll get a 409. Use get_query_status to check status.
• Credit-balance footer. Every tool response includes your remaining balance — your MCP client renders it inline.

Security

• Treat your API key like a password. Anyone with it can spend your credits up to the daily cap. Store it in your MCP client config or a password manager.
• Rotate quarterly. Generate a new key in Settings, update your MCP client config, then revoke the old one. Revoked keys stop working immediately.
• Revoke if a device is lost. Settings → API Keys & MCP → trash icon. One click.
• Cross-account isolation. Your API key can only query your projects. Even with another user's project ID, the call returns 404.
• We log query attribution (user ID, project ID, cost, latency) but never log your raw API key, question, document content, or model responses.

Troubleshooting