Run a council from your code

One HTTPS call 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. Built so your own apps and AI agents (Claude, GPT, your engine) can call it 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.

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

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). Omit personaIds for a balanced default council. All 86 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.

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.