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.
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β¦
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)
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.
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: "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.
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.
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.
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.
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.
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.
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 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 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 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 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.
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 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>.
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.
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.
GET /v1/models β catalog (incl. owned models).GET /v1/me β balance, plan, usage.GET /v1/keys, POST /v1/keys/{id}/rotate|revoke|cap|provider-key β manage your own key (rotate a leaked key, spend cap, store a BYOK provider key once, plan snapshot; account page). Routes only ever reach the authenticated key β another key's id is 404.POST /v1/messages β Anthropic-compatible Messages (Claude Code; see Connect your coding agent).POST /v1/feedback β rate a request; improves routing.POST /v1/conversations, β¦/chat β persisted workspace.POST /v1/experts, GET /v1/experts β specialized experts.POST /v1/marketplace/listings, β¦/install β marketplace.POST /v1/orgs β teams, seats, usage rollup.POST /billing/checkout β top up credits.Interactive schema: /docs-fastapi Β· machine-readable: /openapi.json.