πŸ• Super Intelligence Dog
sign in

API

SID is an OpenAI-compatible gateway. Point any OpenAI SDK at this gateway's base URL and use your sk-sid-… key.

Building with AI and can't fully review what it writes? See how SID verifies the code before it ships.

Plans and prices

Prices are stated inline and come from the same canonical plan table the checkout uses. BellerCreatives is the merchant of record and hosts checkout; a paid checkout provisions your SID key and session on return, so there is no key email and no paste.

Loading plans…

Quickstart

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://superintelligencedog.com/v1",
    api_key=os.environ["SID_API_KEY"],
)

resp = client.chat.completions.create(
    model="auto",                     # let the router choose the best model
    messages=[{"role": "user", "content": "Explain CRDTs"}],
)
print(resp.choices[0].message.content)

Test my connection

Paste your key and run one real check. It calls GET /v1/me from this browser and shows the plan, balance, and spend limit the key actually has β€” a 200 means the key works. The key is sent only to this gateway.

No test run yet.

Chat completions

POST /v1/chat/completions

{
  "model": "auto",                        // or a model id, or "expert:<slug>"
  "messages": [{"role": "user", "content": "hi"}],
  "stream": true
}

Headers: Authorization: Bearer sk-sid-… (required), X-Provider-Key: … (BYOK, optional), X-Routing-Profile: balanced|quality|cheap|fast, X-Min-Quality: 0..1, X-Max-Cost-USD: 0.01, X-Prefer-Owned: true.

The response body carries a routing object with the chosen model, task classification, confidence, and an explanation.

Model routing and fallback

model: "auto" classifies each request (intent, domain, difficulty, modality), filters to models with the required capability, context window, and a usable credential, then ranks them by quality, cost, latency, and reliability for the selected profile. If the first candidate fails, the gateway walks the fallback chain in ranked order and bills whichever model actually served the request; the routing object names it. You can also send a models array to pin your own ordered fallback chain β€” it cannot be combined with expert: or agent: routing, which already pin the model.

Preview routing

POST /v1/route
{ "model": "auto", "messages": [{"role":"user","content":"write SQL"}] }

Dry run β€” shows the ranked candidates, cost estimate, and explanation without calling a provider.

Agent runs: verify, test, and a real security scan

POST /v1/agents/run
{
  "repo_path": "/workspace/myapp",
  "task": "add rate limiting to the login route",
  "diff": "…proposed change to verify…",
  "test_argv": ["pytest", "-q"]
}

The coding agent engine behind a run verifies the proposed diff with an independent model (verify), can run the repo's tests in a sandbox (tests), and always security-scans the project through BellerBuild β€” fail-closed, so a run without its scan does not complete. The response carries all three (scan includes the findings); GET /v1/agents/runs/{run_id} re-reads the same record. Verify a build yourself at BellerBuild, and a paid plan also lists your verified app on Beller Store.

Our spec-first coding run

SID's own agent workflow starts with POST /v1/agents/criteria. It returns a durable proposal containing acceptance criteria and a test command; no code is changed in this step. Review it, then call POST /v1/agents/plans/{plan_id}/approve. Only that approving key can use the proposal. Finally call POST /v1/agents/run with the returned criteria_proposal_id and the same task/workspace. SID rejects an unapproved or changed workspace and gives the approved criteria to both the agent and independent verifier. A run is marked verified only when its approved tests pass, independent review passes, and BellerBuild attests the exact tested artifact. A legacy run without an approved criteria proposal may still return its diagnostics, but cannot claim criteria-verified status.

Where your task goes

Every run receipt carries the actual data path: which model and provider processed your task, whether that endpoint is self-hosted (an owned model on an endpoint we registered β€” see endpoint_class on GET /v1/models) or external (a third-party provider), where code executed (the sandbox backend), and what we retain. Open-weight models run on hosted endpoints; we never call them private or local. Model requests routed auto are routed per task, and the receipt says so rather than naming one model after the fact.

Run SID's own harness

SID ships a first-party coding client β€” the sid CLI β€” that runs on your machine against your real working tree: it reads and edits local files, runs tools, keeps durable sessions, and never commits or pushes on its own. It drives the same first-party loop the hosted agent uses, so there is no third-party harness in the path. Install it with pipx (or pip) β€” the package is self-contained and needs no monorepo checkout.

pipx install sid-harness        # wheel from PyPI

# first run β€” verify your key (/v1/me), save it, pick a default dir:
sid setup
sid run --task "Fix the off-by-one in add()."

Prefer no install? The Build Workbench runs the same agent in a sandbox from a folder you open in place (nothing is uploaded). To use SID as the model backend for a harness you already have, see the guides below.

Connect your coding agent

Every guide below is the same two values β€” this gateway's base URL and your sk-sid-… key β€” written into the tool's own configuration surface. Closed-lab models (OpenAI, Anthropic) are BYOK: send your own provider key via the X-Provider-Key header to use them; open-weight models ride SID credits with no extra header.

Claude Code

Claude Code rides the Anthropic-compatible Messages endpoint. The base URL is the bare host β€” Claude Code appends /v1/messages itself β€” and ANTHROPIC_AUTH_TOKEN carries your key as the Bearer value:

export ANTHROPIC_BASE_URL=https://superintelligencedog.com
export ANTHROPIC_AUTH_TOKEN=sk-sid-…
claude

Claude Code's default claude-… model ids are not catalog ids; unknown ids route as auto (the response names what actually ran), or pin the slots yourself:

export ANTHROPIC_MODEL=deepseek-v4-flash
export ANTHROPIC_DEFAULT_HAIKU_MODEL=glm-5.2

To use closed Anthropic models with your own key, pass it through:

export ANTHROPIC_CUSTOM_HEADERS="X-Provider-Key: sk-ant-…"

Verify inside the session with /status β€” it shows the base URL.

Codex CLI

Codex CLI rides the OpenAI Responses endpoint. In ~/.codex/config.toml, define SID as a custom provider with wire_api = "responses" (the protocol current Codex builds require) and point model at the router:

model_provider = "sid"
model = "auto"

[model_providers.sid]
name = "Super Intelligence Dog"
base_url = "https://superintelligencedog.com/v1"
env_key = "SID_API_KEY"
wire_api = "responses"

Then export your key and run Codex:

export SID_API_KEY=sk-sid-…
codex

Or pick a catalog id instead of auto with model = "deepseek-v4-flash" (or any id from GET /v1/models). Closed OpenAI/Anthropic models need your own key via an env_http_headers entry sending X-Provider-Key. Note: Codex's hosted tools (web search, multi-agent namespaces) are not forwarded β€” the function tools it defines locally (shell exec, file tools) work as usual.

Cursor

Cursor Settings β†’ Models β†’ API Keys: enable OpenAI API Key and paste your sk-sid-… key; enable Override OpenAI Base URL and enter the base URL (no trailing slash); then Add Custom Model with a catalog id and enable it:

https://superintelligencedog.com/v1

Cursor's custom-key path serves chat models; Tab completion and agent-side routing stay on Cursor's own models.

Cline

Cline settings (the βš™οΈ icon) β†’ API Provider: OpenAI Compatible. Base URL, API key, and model id:

Base URL: https://superintelligencedog.com/v1
API Key:  sk-sid-…
Model ID: auto

Any catalog id works as the Model ID; leave the optional model configuration empty to let the server decide.

Continue

In Continue's config.json (or the equivalent config.yaml), add SID as an OpenAI-compatible model:

{
  "models": [
    {
      "title": "SID (auto)",
      "provider": "openai",
      "model": "auto",
      "apiBase": "https://superintelligencedog.com/v1",
      "apiKey": "sk-sid-…"
    }
  ]
}

Continue's chat, edit, and agent modes then route through SID; any catalog id works in place of auto.

Aider

Aider reads the standard OpenAI-compatible environment variables. Point them at the gateway and name the model as openai/<id>:

export OPENAI_API_BASE=https://superintelligencedog.com/v1
export OPENAI_API_KEY=sk-sid-…
aider --model openai/auto

If Aider's model check rejects auto, pass any catalog id from GET /v1/models as openai/<id>.

OpenCode

Add SID as a custom OpenAI-compatible provider in opencode.json and set the default model to sid/auto:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "sid": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Super Intelligence Dog",
      "options": {
        "baseURL": "https://superintelligencedog.com/v1",
        "apiKey": "{env:SID_API_KEY}"
      },
      "models": { "auto": { "name": "Auto (SID router)" } }
    }
  },
  "model": "sid/auto"
}

Export SID_API_KEY=sk-sid-… in your shell, or store the key with OpenCode's /connect command instead of the apiKey option.

Zed

In Zed's settings.json, point the OpenAI provider's api_url at the gateway and declare the models you want in the picker; put your key in the OPENAI_API_KEY environment variable:

{
  "language_models": {
    "openai": {
      "api_url": "https://superintelligencedog.com/v1",
      "available_models": [
        {
          "name": "deepseek-v4-flash",
          "display_name": "DeepSeek V4 Flash (SID)",
          "max_tokens": 128000
        }
      ]
    }
  }
}
export OPENAI_API_KEY=sk-sid-…

Then pick the custom model in the Agent Panel. auto works too β€” name it in available_models the same way.

Other endpoints

Full reference

Interactive schema: /docs-fastapi Β· machine-readable: /openapi.json.