User Guide

Getting Started

ModelCouncil is a multi-model AI decision tool that helps executives and founders make better decisions by querying Claude, GPT, Gemini, and Grok simultaneously against your project documents.

Projects & Documents

Projects are decision contexts — containers for documents and queries related to a specific decision or topic. Each project has its own set of documents that provide context to the AI models.

Supported File Types

Limits

• 10 MB maximum per file
• 20 files maximum per project
• 200,000 tokens maximum context per project

Making Queries

The Query tab lets you ask questions against your uploaded documents. Multiple AI models analyze your question and documents, then their responses are synthesized into a Decision Board.

Model Selection

Choose 2-3 models for each query. Different models have different strengths:

Decision Helper

When you ask a decision-type question (e.g., "Should we...", "Which option..."), the Decision Helper appears to help you provide structured context:

• Options being considered
• Constraints (budget, timeline, resources)
• Success criteria
• Decision timeframe

Follow-up Queries

After receiving a Decision Board, you can ask follow-up questions to dig deeper. Follow-ups include context from the previous query and recommendation.

Web search (opt-in)

Each model answers from its training knowledge plus the documents and context you've added to the project. You can also opt into a single Google-grounded web search before the council runs — the search results are added as a shared evidence block that every model reasons over, so all members of the council are working from the same sources.

What the models still can't do

One limitation to plan around:

What to do instead

• For an article or page: copy the relevant text and either paste it directly into your question, or save it as a .txt /.md /.pdf and upload it to the project. The council will then actually reason over the content.
• For current data that changes: drop a fresh export (CSV, spreadsheet, screenshot) into the project before each query. Stale uploads stay stale until you replace them.
• For time-sensitive decisions: state today's date explicitly in your question and tell the models what they may not know — e.g. "As of May 2026, our main competitor just launched X. Given that…". The models will then frame their answer around the facts you've given them rather than guessing.
• When you do paste a URL: add a short note like "I have not given you the page contents. Please don't summarize the URL — just acknowledge the source if relevant." This keeps a model from inventing details.

Understanding the Decision Board

The Decision Board synthesizes all model responses into a structured output that helps you make informed decisions.

Model Response Tabs

Click on model tabs to see the full reasoning from each AI. This helps you understand where different perspectives come from.

Exporting Results

Export your Decision Board to PDF, Excel, Word, or PowerPoint for sharing with stakeholders or archiving.

Decision Threads

Decision Threads group related queries into organized workflows. Unlike the Query tab, threads use intelligent context that stays manageable no matter how many queries you make.

Query Tab vs Threads Tab

How Intelligent Context Works

In a thread, the system automatically manages context to keep it efficient:

• Document Summary — An always-on overview of your project documents
• Relevant Chunks — Semantic search finds document sections relevant to your current question
• Thread History — Compressed summaries of previous decisions in this thread
• Cross-Thread Context — Related decisions from other threads in the same project

Organizing Queries into Threads

Queries made outside the Threads tab (in the Query tab) aren't automatically connected to threads. You can organize these standalone queries into threads at any time.

1. 1Click Organize in the query history sidebar
2. 2Select the queries you want to group (checkboxes appear on unorganized queries)
3. 3Click Add to Thread and choose an existing thread or create a new one

Branching

From any decision in a thread, you can branch to explore an alternative direction. The new thread knows where it branched from, preserving your decision tree.

Diamond Mode

How It Works

1. Round 1Initial Responses — Each model answers your question independently
2. Round 2Cross-Review — Each model reviews the other models' responses, identifying points to adopt, reject, or add
3. FinalDiamond Synthesis — A final synthesis that includes what changed, confidence levels, and unresolved disagreements

When to Use Diamond Mode

• High-stakes decisions where you want maximum confidence
• Complex questions where models might miss each other's insights
• When you want to see how models critique each other

Cost: Diamond mode costs approximately 3x a standard query (7 API calls instead of 4).

If a Diamond query gets interrupted

Diamond queries take longer than standard ones — typically 30 seconds to a few minutes — so it's normal to occasionally lose your connection partway through (closed tab, dropped Wi-Fi, etc.). Two ways to recover:

• Resume button. Open your query history (Query tab → History). Any Diamond query that's mid-flight shows a blue Resume badge — click it to pick up from where it stopped.
• Automatic recovery. Within 12 hours, our background system finishes any abandoned Diamond queries and emails you a link to the Decision Board. No action needed on your end.

See Release Notes for the full set of reliability improvements shipped May 2026.

Integrations (MCP)

ModelCouncil is available as a connector in any MCP-compatible client — Claude Desktop, Claude.ai (web), Cursor, ChatGPT, and others. Setup is self-serve: paste a URL into your client's connector settings, sign in once, and the council shows up as a tool you can call without leaving the chat or editor you're already in.

When MCP makes sense

• Second opinion mid-conversation. You're working through a hard call in Claude.ai. Get GPT's and Gemini's take on what Claude just told you — in the same thread.
• Council-as-a-tool while you code. From Cursor, ask the council about an architecture choice or risky migration without switching context.
• Cross-check what one model said. Surface where the models disagree before you commit to a path.

Available tools

Your AI client (Claude.ai, ChatGPT, Cursor, etc.) calls these tools on your behalf. You don't invoke them by name — you ask in plain English and the client picks the right tool.

• list_projects — enumerates your projects so the AI can pick the right one. Always called first.
• create_project — creates a new project when no existing one fits the topic (find-or-create flow). New projects start empty; for document-grounded answers, upload files in the web app or pass context inline via additional_context.
• query_council — asks the council (synchronous, single response, ~30-60s)
• query_diamond_mode — cross-model deliberation (async — kicks off in the background, status surfaced in the dashboard or emailed when complete)
• get_query_status — poll a Diamond query for completion, or re-fetch the full Decision Board for any past query

How to ask the council from a chat

Your AI client decides when to call ModelCouncil based on what you ask. The trigger phrases below work reliably across Claude.ai, ChatGPT, and Cursor. None require you to memorize tool names — but mentioning "ModelCouncil" or "the council" explicitly is the most reliable nudge.

Per-connector defaults

If you're asking the council from inside Claude.ai, getting another Claude answer back is redundant. Open Settings → API Keys & MCP → Connected Apps and edit preferences for each connector — for instance, set Claude.ai to skip the Anthropic model by default. The preference applies to every query from that connector unless the AI explicitly overrides it.

Cost expectations through MCP

Same per-query economics as the web dashboard. Through MCP you have a $10 hard cap per call (no interactive UI to confirm higher-cost queries):

• Standard queries: typically $0.04–$0.20 each depending on tier and context size
• Diamond Mode: typically $0.20–$1.00 per query, up to ~$2 on very large 200K-token projects (~3× the gateway calls of a standard query)
• Token usage and cost are reported in the tool response — the AI client surfaces it in the chat reply

Tip: getting the full response back

Claude.ai (and ChatGPT) often summarize the council's response in their own voice rather than quoting the full Decision Board verbatim. This is the AI client's choice — the MCP tool itself returns the complete output (recommendation, key reasons, risks, validate-before-committing, consensus, disagreements, rare finds, plus what each model said). Four ways to see everything:

• Click the "View on ModelCouncil →" link. Every council response includes a deep-link at the top that opens this specific Decision Board in your dashboard. Even when Claude summarizes the rest, the link survives — one click and you're looking at the full untruncated board.
• Ask explicitly. Type something like "Show me the full Decision Board verbatim" or "Quote the entire tool response — don't summarize." Claude will paste the raw output.
• Open your dashboard. Every MCP query mirrors into ModelCouncil with the full content untouched. Visit your projects and the latest query is at the top — this is the canonical record.
• Use the query_id. The tool response includes a query_id — ask Claude to call get_query_status with that id to re-fetch the full board.

For step-by-step client setup (config snippets for Claude Desktop, Claude.ai web, Cursor, ChatGPT, and Claude Code CLI) see the dedicated MCP Setup Guide →

Billing & Credits

ModelCouncil uses a credit-based system so you only pay for what you use. Credits cover the cost of AI API calls with a small markup.

Purchasing Credits

Credit purchases require an active trial or Pro subscription. If your subscription has lapsed, reactivate the Pro plan first — the Add Funds card on the Usage page will direct you there.

Platform Subscription

$99/month platform fee provides access to all features. Credits for API usage are purchased separately.

Credit Expiration & Grace Period

Credits roll over month to month while you have active platform access (during your trial or while subscribed). Your balance has two pots: purchased credits (what you bought) and bonus credits (the $10/month retention grant, up to $40 saved). Bonus credits drain first on every query, then purchased credits. If your subscription lapses — cancellation, payment failure, or trial expiry without conversion — both pots enter the same 60-day grace period.

• Reactivate within 60 days and your full balance is restored — credits are never deducted during the grace period, just paused.
• After 60 days the balance is forfeited and cannot be recovered. You can always start fresh by resubscribing — every paid month adds $10 in bonus credits to your balance, up to $40 saved.
• We'll email you reminders at 14 days, 3 days, and the day of forfeiture, plus a banner on your dashboard showing days remaining whenever the clock is running.

Viewing Usage

Visit Usage & Billing in the sidebar to see your credit balance, usage history, and purchase more credits. The Transactions tab lists every credit event including purchases, query consumption, bonuses, refunds, and expirations.

Release Notes

Recent improvements to ModelCouncil. Newest first.