SynthBoard MCP help center

Before an expensive or hard-to-undo decision, your assistant can put the question to your SynthBoard board and bring back its call: the sharpest dissent, what would change the board's mind, and the first step — with a link to the whole board on SynthBoard. No key to paste: you connect once, with your own account.

1. 1
   Connect

   Claude: Customize → Connectors → Add custom connector, paste the URL https://www.synthboard.ai/api/mcp, then Add (the Free plan holds one custom connector). ChatGPT: Settings → Apps & Connectors → Advanced settings → turn on Developer mode, then Create and paste the same URL. Cursor: Add to Cursor (one tap). Any other client that speaks MCP over OAuth takes the same URL.
2. 2
   Pick a daily limit

   The SynthBoard sign-in screen says in plain words what the assistant may do and asks what it may spend each day: nothing that costs credits, one board a day, 3 boards a day, 10 boards a day (default: one board a day). Each board prints its price first — on the Free plan, about 95 credits — and bills what it really used.
3. 3
   Ask

   Say it the way you would to a person. Your assistant calls synthboard.board.call (a glance or a full board), gets the board's link at once, and fetches the call with synthboard.board.result a few minutes later.

• Past the limit, nothing runs. The assistant gets a polite refusal that says what is left today — never a partial charge.
• It never touches your other tools. An assistant can ask your board and read your boards; it cannot send, post or change anything in your other tools.
• Disconnect ends it at once. Settings → MCP and API → Connected assistants → Disconnect: the very next call is refused.

1. 1
   Create an API key

   Open the Control Center → API Keys and click Create key. The key is shown exactly once — copy it somewhere safe.
2. 2
   Paste into your client config

   Pick your client below. Each has a dedicated config file — paste the snippet and replace sb_live_... with your real key.
3. 3
   Restart the client

   Quit fully and reopen. The SynthBoard tools + prompts should appear in the client's tool menu.
4. 4
   Try a prompt

   Type /synthboard-boardroom and ask a real strategic question. The decision brief staffs the board; each expert researches alone and reacts once, and the board delivers a memo.

If Claude (or another assistant) already knows your business, it can fill in your SynthBoard world for you and run the first Consults — with you saying yes in between. Nothing lands until you keep it, and every session it starts is on your Home the moment you sign in.

1. 1
   Connect SynthBoard as a tool

   In Claude, add SynthBoard as a connector (Settings → Connectors) with the URL below and approve the scopes. If you do not have an account yet, the sign-in screen offers Sign up — one screen, then you are back in Claude. Claude cannot create the account by itself; that click is yours.
2. 2
   Say the words

   Type /synthboard-onboard, or just say: “Set up my SynthBoard world from what you know about me, ask me to confirm, then find the gaps in my business and consult the right experts.”
3. 3
   Confirm the chips

   Claude calls synthboard.world_model.bring with a brief, shows you the review chips, and only after your yes calls synthboard.world_model.confirm_transfer. Prefer the site? The same chips wait on your Home under World.
4. 4
   Get the memos

   Claude reads synthboard://world-model, names the gaps, plans a Consult for each, and brings back the expert's call, floor and dissent. Open SynthBoard whenever you like — the sessions are already there.

// 1. Bring — parks review chips, saves nothing
{ "name": "synthboard.world_model.bring",
  "arguments": { "client_name": "Claude",
    "text": "WHO I AM\n- Founder/CEO, Acme, seed stage …\nNUMBERS ON FILE\n- MRR: $42k (as of Aug 2026)\n- Churn: 3.1%/mo (as of Aug 2026)\nGOALS\n- $1M ARR by Q2 2027 …" } }
// → { "transfer_id": "…", "status": "pending", "facts": [ … ], "numbers": [ … ], "next_step": "Show these to the user …" }

// 2. Confirm — after the user's yes (drops are optional, by text / label)
{ "name": "synthboard.world_model.confirm_transfer",
  "arguments": { "transfer_id": "…", "drop_numbers": ["Churn"] } }
// → { "status": "kept", "learned": 9, "metrics_written": 1 }

No connector? Copy the same brief prompt from Home → World → Or bring it from your AI, paste the answer back, and keep what is true.

Ask a real strategic question. Your agent calls synthboard.session.plan, shows you the proposal, then starts the run. No expert-picking needed — an adaptive decision brief reads the question and seats the right experts.

// 1. Plan — nothing charged yet
{ "name": "synthboard.session.plan",
  "arguments": {
    "question": "Should we launch a free tier next quarter?",
    "session_type": "boardroom"
  } }
// → { plan_id, proposal, estimated_credits, expires_at }

// 2. Start with the approved plan
{ "name": "synthboard.session.start",
  "arguments": { "plan_id": "<plan_id>" } }
// → { session_id, task_id, session_type: "boardroom", session_url }

// 3. Wait for the run (long-poll up to 60s per call)
{ "name": "synthboard.session.get",
  "arguments": { "session_id": "<id>", "wait_ms": 60000 } }
// → { v4_phase: "done", decision_brief, memo: { verdict,
//     confidence_0_100, conditions, dissent } }

What you'll see

• Within seconds: session_id, task_id, and a link to watch live on synthboard.ai.
• Phase progress as the board moves: the brief, the seats, each expert's research, the argument, the memo (v4_phase).
• On completion: the decision memo — verdict, confidence, conditions, and the strongest dissent — or a shaped artifact for non-decision asks.

Sessions can't auto-start from a bare question. That protects users and their credit balance from runaway agent loops. You have two paths:

Bare calls (question only, no plan_id and no setup signal) return validation_error with actionable guidance.

Two rooms

Express intake & the decision brief

Sessions started over MCP/API skip the interactive intake: a single facilitator pass turns your question + context into a decision brief — the framed question, the known facts, and the seated board (which experts, which seats, why). The brief is returned on session.get as decision_brief.

Board phases

v4_phase tracks the run: intake → staffed → research → debate → memo → done. Each seated expert researches alone, then reacts once to the others — with genuinely opposed theses on a decision — and the run terminates in a deliverable.

The deliverable: memo or shaped artifact

• Decision boards deliver a decision memo: the verdict, confidence (0–100), the conditions that would flip it, and the strongest dissent — under a named author.
• Every other ask delivers a board artifact shaped to the question — a plan, forecast, comparison, research brief, diagnosis, and more. Read it via board_artifact or the synthboard://session/{id}/memo resource.

Reconvene

A finished board isn't continued — it's reconvened. When something changed, call synthboard.session.reconvene({session_id, whats_changed}). The new run opens from the board's delivered call (verdict, confidence, dissent) plus your update, re-briefs, and runs — returning a new session_id linked to the parent. (session.continue remains for legacy-engine sessions and redirects boards here.)

Consult turns

A Consult is a conversation with one named expert. Each synthboard.consult.message call sends one message to the seated expert and returns their reply — plus a composed document when the ask calls for one (a memo, an email, a plan). If wait_ms elapses, the turn keeps running server-side; re-read via session.get.

Your World & wm_scope

Your Chief of Staff keeps your world on file — identity, situation, goals, constraints, the names that matter, each with its source and date — and a searchable memory of every delivered call. Nothing is kept as still true until you say it is. Agents read it via the synthboard://world-model resource and search it with synthboard.world_model.search (decisions, memos, board artifacts, world-model facts). Every session binds a wm_scope at creation (accepted by session.plan and session.start):

A reconvened run inherits its parent's scope — an off-record board's reconvene stays off the record. The latest brief is readable at synthboard://briefs/latest.

Plans differ in capacity and models — compare them on pricing. Experts on a board shows the default per plan; the live value is account-configurable and enforced server-side.

Rate limits are per-user (or per-OAuth-client) per bucket. The baseline numbers below apply to Pro; other tiers multiply the baseline — Free ×0.15, Max ×3.3, Ultra ×16 (minimum 1). Buckets without explicit config get a bounded default of 30/min. Concurrent-session caps are enforced atomically — there's no way to race past them.

Hit a limit? The error tells you exactly which cap and when to retry (retry_after_s). Watch live headroom on the usage dashboard.

• One key per client. Separate keys for Claude Desktop, Cursor, and automation scripts — revocation stays surgical.
• Rotate quarterly. Click Rotate on a key to create a replacement with the same scopes. Old key works for 24 hours while you update clients.
• Set a cap for automation. For n8n, Zapier, cron, anywhere you can't watch — a daily credit cap prevents runaway loops.
• Never commit keys. Keep them out of git. If exposed, revoke instantly — it takes effect in real time.
• Scope down. A read-only automation doesn't need session:write. Create keys with just the scopes you need.

Most MCP clients (Claude Desktop, Cursor, Windsurf, Zed, scripts) authenticate with a Bearer API key — simplest, fastest. Browser-based clients like Claude.ai web don't accept raw keys; they use OAuth 2.1 for user-mediated consent. SynthBoard exposes a native, spec-compliant Authorization Server at the standard discovery endpoints.

Discovery metadata

• GET /.well-known/oauth-authorization-server — RFC 8414 AS metadata
• GET /.well-known/oauth-protected-resource — RFC 9728 protected-resource metadata
• GET /.well-known/jwks.json — public JWKS for token verification

Flow

1. Dynamic client registration (RFC 7591): POST /api/oauth/register with your client metadata. https-only redirect URIs required.
2. Authorize: send user to /api/oauth/authorize with response_type=code, code_challenge (S256), resource (your MCP URL), scopes.
3. Consent page: user sees plain-English scope descriptions and approves. CSRF-protected.
4. Token exchange: POST /api/oauth/token with the code + PKCE verifier. Receive a 10-minute access token and 7-day rotating refresh token.
5. Use on /api/mcp — JWT in Authorization: Bearer. Server validates signature, audience (aud must match resource URL, RFC 8707), expiry, and revocation status on every call.
6. Refresh: rotate the refresh token before the access expires. Reused old refreshes trigger grant-chain revocation.

A board takes 6–10 minutes; a consult turn, about a minute. Instead of polling, subscribe and let SynthBoard call you. There are two contracts with different signatures — verify with the right one:

Delivery guarantee

Every started session ends in exactly one terminal event — session.complete, session.failed (including engine timeouts swept by the watchdog, delivered with reason: "timeout"), or session.cancelled. Build state machines on that invariant.

Retries — both systems

Any non-2xx retries with backoff at 1, 5, 15, 60, 240 minutes — 5 attempts total. Subscriptions additionally auto-disable after 10 consecutive failures (re-enable in the Control Center, which resets the breaker).

Verify — subscriptions (Node.js)

import { createHmac, timingSafeEqual } from "node:crypto";

function verifySubscriptionWebhook(
  rawBody: string, sigHeader: string, tsHeader: string, secret: string,
): boolean {
  if (Math.abs(Date.now() / 1000 - Number(tsHeader)) > 300) return false; // replay guard
  const expected = "sha256=" + createHmac("sha256", secret)
    .update(`${tsHeader}.${rawBody}`).digest("hex");
  const a = Buffer.from(sigHeader), b = Buffer.from(expected);
  return a.length === b.length && timingSafeEqual(a, b);
}

Verify — legacy per-key (Node.js)

import { createHmac, timingSafeEqual } from "node:crypto";

function verifyLegacyKeyWebhook(
  rawBody: string, sigHeader: string, secret: string, // whsec_...
): boolean {
  const expected = "sha256=" +
    createHmac("sha256", secret).update(rawBody).digest("hex");
  const a = Buffer.from(sigHeader), b = Buffer.from(expected);
  return a.length === b.length && timingSafeEqual(a, b);
}

MCP Resources are the "GET" side of SynthBoard — read them any time for the latest state. Resource subscriptions are not supported: for live board tracking, poll synthboard.session.get with wait_ms (long-polls up to 60s per call), or use webhooks to be called when a run finishes.

All session-scoped resources enforce ownership — cross-tenant reads return not_found, never a leak. Catalog resources are public read-only.

12 slash-prompts

Pre-configured commands — each routes through the plan-first flow./synthboard-consult opens the 1-on-1 room.

A few statuses differ over REST where HTTP semantics demand it (e.g. concurrent_session_limit → 409, upstream_error → 502).