A council — or one named expert — from your code

Two endpoints, one key. /api/v1/council runs your work through a multi-model AI debate plus the proprietary Final QA layer and returns a finished answer — and a presentation-ready HTML deliverable. /api/v1/mind asks one named specialist from our catalogue — the CFO, the CMO, the Corporate Lawyer — for their read on your material, at a fraction of the cost. Built so your own apps and AI agents (Claude, GPT, your engine) can call either like any tool.

Quickstart

1. 1. Create an API key at /account (it’s shown once — store it).
2. 2. POST your brief to the endpoint with the key as a Bearer token.
3. 3. Read back the verdict, the QA audit and the HTML deliverable. Credits bill to your account.

Want one expert rather than a debate? Same key, same shape — jump to /api/v1/mind.

curl https://decidi.ai/api/v1/council \
  -H "Authorization: Bearer dck_live_…" \
  -H "Content-Type: application/json" \
  -d '{
    "question": "Review and harden these terms for public use: …",
    "level": "deep",
    "intent": "contract-review",
    "personaIds": ["corporate-lawyer","contracts-reviewer","devils-advocate"]
  }'

Authentication

Send your key as a Bearer token. Keys look like dck_live_…, are tied to one account, and only the hash is stored — keep it server-side. Revoke or rotate any time at /account.

Authorization: Bearer dck_live_3b69…

Endpoint

POST https://decidi.ai/api/v1/council

Prefer a machine-readable contract? The full OpenAPI 3.1 spec is at /openapi.json — import it into an API client, an agent framework, or MCP tooling.

Request body

Response

Ask one named specialist

POST https://decidi.ai/api/v1/mind

Sometimes you don’t want a debate — you want the CFO to look at a budget, the CMO to audit a campaign, or the Corporate Lawyer to read one clause. This is that call: one named mind from the catalogue, one generation, a fraction of a council’s cost and wall-clock. The answer comes back in the first person — the call, what to verify, and what they’d push back on.

You never write the persona prompt. An agent that invents its own “you are a sharp CFO…” system message gets a generalist doing an impression. Here the brief is Decidi’s own, versioned with the product — so the read gets better without you touching your code.

curl https://decidi.ai/api/v1/mind \
  -H "Authorization: Bearer dck_live_…" \
  -H "Content-Type: application/json" \
  -d '{
    "persona": "cfo",
    "question": "Is this budget realistic, and what would you cut first?",
    "material": "FY27 plan\nHeadcount 14 → 22\nMarketing $2.4m …"
  }'

Request body

Response

GET /api/v1/mind returns the whole catalogue — id, name, role, domain, blurb, tags — with optional ?q= and ?domain= filters. Call it rather than hard-coding ids: the catalogue moves.

Persona catalogue — every ID you can seat

Pass any of these ids in personaIds (2–6 per council; repeat an id to seat the same mind more than once, each on a different model) — or as persona on /api/v1/mind to ask just one of them. Omit personaIds for a balanced default council. All 92 minds you can call:

Examples

JavaScript / TypeScript

const res = await fetch("https://decidi.ai/api/v1/council", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.DECIDI_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    question: "Audit my checkout flow before launch.",
    level: "deep",
    intent: "ux-audit",
  }),
});
const { verdict, qa, artifact_html, credits_charged } = await res.json();

Python

import os, requests

r = requests.post(
    "https://decidi.ai/api/v1/council",
    headers={"Authorization": f"Bearer {os.environ['DECIDI_API_KEY']}"},
    json={
        "question": "Stress-test my investment thesis: …",
        "level": "deep",
        "intent": "investment-thesis",
    },
    timeout=300,
)
data = r.json()
print(data["verdict"])              # the QA-signed verdict
open("deliverable.html","w").write(data["artifact_html"] or "")

From an AI agent (Claude, GPT, your engine)

Wire Decidi in as a tool your agent can call when a task is high-stakes and deserves more than one model. Give the tool this schema and let the agent fill question and an intent:

{
  "name": "decidi_council",
  "description": "Run a high-stakes task through a multi-model AI council + QA. Use for audits, reviews, contracts, investment theses, and any decision where being wrong is expensive.",
  "input_schema": {
    "type": "object",
    "properties": {
      "question": { "type": "string", "description": "The brief / work to run" },
      "level":    { "type": "string", "enum": ["quick","standard","deep"] },
      "intent":   { "type": "string", "description": "ux-audit | code-review | contract-review | decision | …" }
    },
    "required": ["question"]
  }
}

Then POST exactly as above with your account key. The agent gets a verdict it can act on, plus the QA flags so it knows what was uncertain — a built-in second opinion that isn’t its own model.

Use it from Claude Code, Cursor, or any AI agent

Decidi is a plain REST endpoint, so any AI agent that can make an HTTP request — Claude Code, Cursor, Cline, Windsurf, the OpenAI or Gemini CLIs, or your own engine — can consult the council as a tool. Give the agent the key and one instruction: before any big or irreversible decision, get a second opinion that isn’t its own model.

1 · Give the agent the key

export DECIDI_API_KEY=dck_live_…

2 · Add this to its rules (CLAUDE.md, .cursorrules, or system prompt)

Before any high-stakes or irreversible decision — a schema or data migration,
a pricing or architecture change, a security-sensitive design, deleting data,
a public launch, or anything where being wrong is expensive — STOP and get a
second opinion from the Decidi council before you act.

POST the decision, with full context, to https://decidi.ai/api/v1/council using
DECIDI_API_KEY as a Bearer token. Read the "verdict" and the QA flags, then factor
them in before proceeding. Do not treat your own first answer as final on
decisions that matter.

3 · The call it makes

curl https://decidi.ai/api/v1/council \
  -H "Authorization: Bearer $DECIDI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "question": "Should we migrate the public API from REST to GraphQL? Context: …",
    "level": "deep",
    "personaIds": ["software-architect","devils-advocate","pragmatist","security-engineer"]
  }'

The response is one QA-audited verdict plus the credits charged — a second opinion from several independent frontier models, not the agent’s own. It bills your account’s credits.

MCP server — native tools in Claude Code, Cursor and any MCP client

Decidi hosts an MCP server at https://decidi.ai/api/mcp (Streamable HTTP, plain JSON responses). Connect once and your agent gets the council as first-class tools — no schema to paste, no wrapper to write.

Claude Code

claude mcp add --transport http decidi https://decidi.ai/api/mcp \
  --header "Authorization: Bearer dck_live_…"

Cursor — .cursor/mcp.json

{
  "mcpServers": {
    "decidi": {
      "url": "https://decidi.ai/api/mcp",
      "headers": { "Authorization": "Bearer dck_live_…" }
    }
  }
}

Tools

Auth: decidi_challenge needs no account and rides the same fair-use limits as the free web tool. decidi_council and decidi_consult authenticate with the Authorization header shown above and are metered to your account exactly like the REST API — same key, same hourly limit, same credit billing. Without a key those two return an error that says where to get one.

Intents (purpose-built deliverables)

Set intent and the council produces a comprehensive, purpose-built deliverable — regardless of how brief your input is.

Errors

Rate limits & billing

• · 60 calls/hour per account.
• · Each call runs the full council + the Final QA audit + the deliverable, and bills credits — metered at the real live model cost plus a small facilitation margin (cost-plus, see pricing).
• · A run can take from a few seconds (quick) to ~1–2 minutes (deep). Use a generous client timeout (≥120s).
• · Tip: a sharper brief → a sharper result. Paste the real material; the intent guarantees the rigor.