Standard Compute is built to be a plug-and-play AI API for automations. If your automation platform can send an HTTP request, it can use Standard Compute — no special SDKs required.
Every request hits the Standard Compute gateway — a single, fully OpenAI-compatible endpoint. From there, Standard Compute's intelligent routing algorithm requests the best-fit model across top-tier providers — reaching for the most advanced models when the work calls for it. You integrate once against one Standard Compute endpoint and one model id, and we do the rest.
https://api.stdcmpt.com/v1. No custom SDKs — override the base URL and key, and existing code works unchanged.standardcompute. Our routing algorithm reads each request and matches it to the ideal model — reaching for the most advanced models when a task needs deeper reasoning, and fast ones for simple steps. You always get the best fit, no model pinning required./chat/completions, /completions, and /responses, with up to 200K context — your existing parsers keep working.All requests use a customer API key in the Authorization header:
Authorization: Bearer YOUR_API_KEY
Content-Type: application/jsonTip: store the key in your automation platform's “Secrets/Credentials” store (recommended) rather than directly in node/module configuration.
| Endpoint | Use it for | Typical output |
|---|---|---|
POST /v1/completions | Fast prompt to completion workflows. Great for “one-shot” tasks. | Completion text under choices[0].text |
POST /v1/responses | Richer responses and structured output workflows. | Convenient text field such as output_text |
POST https://api.stdcmpt.com/v1/completions
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json
{
"model": "standardcompute",
"prompt": "Summarize this message in 1 sentence:\n{{text}}",
"max_tokens": 120,
"temperature": 0.3
}POST https://api.stdcmpt.com/v1/responses
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json
{
"model": "standardcompute",
"input": "Extract key action items from this:\n{{meeting_notes}}"
}Authorization: Bearer YOUR_API_KEYContent-Type: application/json is set.prompt vs input).Hermes is an autonomous AI agent that ships with a large set of built-in skills and tools (web search, browser automation, file operations, text-to-speech, cron jobs, and more). It connects to any OpenAI-compatible endpoint, so Standard Compute drops straight in as the model provider.
Hermes runs on Linux or macOS (use WSL2 on Windows). You'll need git, curl, python, node.js, and your Standard Compute API key. A small VPS or an older machine is enough when the model runs remotely.
Run the install script, reload your shell, and verify the install:
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrc
hermes --versionStart hermes setup and choose Full setup — you already have your Standard Compute key, so you don't need the Quick Setup trial inference. When prompted for a provider, select Custom OpenAI-compatible endpoint and paste your Standard Compute connection:
Base URL: https://api.stdcmpt.com/v1
API Key: YOUR_STANDARDCOMPUTE_API_KEY
Model: standardcomputeHermes auto-detects the model's capabilities and recommends a setup type (responses, chat-completions, etc.) — accept the recommendation unless you know otherwise.
@botfather, send /newbot, and paste the token into the wizard.Launch the chat with hermes, then confirm the wiring and a simple tool task:
Hello. Which provider and model are you using?
Write a bash command that shows disk usage.responses setup type, or lower max_turns (e.g. 30). If the hermes command isn't found, run source ~/.bashrc (or ~/.zshrc). hermes doctor diagnoses most problems.OpenClaw is an open-source AI agent framework that lets you run autonomous agents with pluggable model providers. By registering Standard Compute as a provider in OpenClaw’s config, every agent session automatically routes through the Standard Compute API — no per-agent setup needed.
OpenClaw resolves model requests through a provider chain. By adding Standard Compute as a named provider and setting it as the default, all agent calls — primary model, sub-agents, image handling, and heartbeat pings — are routed to api.stdcmpt.com without touching individual agent definitions. If Standard Compute is ever unreachable, OpenClaw can fall back to any previous provider you had configured.
Back up your existing config so you can roll back if anything goes wrong:
cp ~/.openclaw/openclaw.json ~/.openclaw/openclaw.json.bakOpen ~/.openclaw/openclaw.json in your editor. Use OpenClaw’s config command or API where possible rather than free-hand editing — it validates the schema for you.
"models": {
"mode": "merge",
...
}standardcompute key under models.providers. This tells OpenClaw where to send requests and what capabilities the model exposes."models": {
"providers": {
"standardcompute": {
"baseUrl": "https://api.stdcmpt.com/v1",
"apiKey": "<YOUR_API_KEY>",
"api": "openai-responses",
"models": [
{
"id": "standardcompute",
"name": "Standard Compute",
"reasoning": false,
"input": ["text", "image"],
"cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
"contextWindow": 200000,
"maxTokens": 8192
}
]
}
}
}The api field is set to openai-responses because Standard Compute exposes an OpenAI-compatible responses endpoint. Costs are zero because Standard Compute billing is handled at the account level, not per-token.
standardcompute/standardcompute (provider/model) means every agent component uses the same endpoint."agents": {
"defaults": {
"model": { "primary": "standardcompute/standardcompute" },
"imageModel": { "primary": "standardcompute/standardcompute" },
"subagents": { "model": "standardcompute/standardcompute" },
"heartbeat": { "model": "standardcompute/standardcompute" }
}
}openai/gpt-4o), move it into the fallback arrays so OpenClaw can still reach it when needed:"model": { "primary": "standardcompute/standardcompute", "fallbacks": ["openai/gpt-4o"] },
"imageModel": { "primary": "standardcompute/standardcompute", "fallbacks": ["openai/gpt-4o"] }"tools": {
"media": {
"image": { "enabled": false }
}
}openclaw config validateOnly restart the agent runtime once validation passes. If it reports errors, fix them first — a bad config can prevent OpenClaw from starting entirely.
OpenCode is an open-source terminal coding agent. Because it speaks the OpenAI protocol, Standard Compute drops in either as a provider entry in opencode.json or through plain environment variables.
Add Standard Compute under provider in ~/.config/opencode/opencode.json, then select the model.
{
"provider": {
"standardcompute": {
"npm": "@ai-sdk/openai-compatible",
"options": {
"baseURL": "https://api.stdcmpt.com/v1",
"apiKey": "YOUR_API_KEY"
},
"models": {
"standardcompute": { "name": "Standard Compute" }
}
}
}
}OpenCode also reads standard OpenAI environment variables. Add these to your ~/.zshrc (or ~/.bashrc) and run source ~/.zshrc to apply:
export OPENAI_API_KEY=YOUR_API_KEY
export OPENAI_BASE_URL=https://api.stdcmpt.com/v1Despite the “OpenAI” naming, this is a protocol — not a provider restriction. The endpoint at https://api.stdcmpt.com/v1 serves the model Standard Compute's router selects for each request, behind the stable standardcompute model name.
Kilo Code is an AI coding agent for VS Code. It connects to Standard Compute through its built-in OpenAI Compatible provider — no config files required.
Base URL: https://api.stdcmpt.com/v1
API Key: YOUR_API_KEY
Model: standardcomputeSave, and Kilo Code routes every request through Standard Compute.
n8n is the most flexible platform for custom APIs, and Standard Compute integrates cleanly in two ways:
YOUR_STANDARDCOMPUTE_API_KEY and Base URL: https://api.stdcmpt.com/v1Use HTTP Request and call Standard Compute directly:
Method: POST
URL: https://api.stdcmpt.com/v1/completions
Headers:
Authorization: Bearer {{$env.STDCP_API_KEY}}
Content-Type: application/json
Body (JSON):
{
"model": "standardcompute",
"prompt": "Rewrite this politely:\n{{$json.text}}",
"max_tokens": 180,
"temperature": 0.4
}Zapier is fantastic for fast no-code automations. For custom AI APIs, the most reliable approach is to use Webhooks by Zapier (Custom Request).
Use the Custom Request action to send JSON to Standard Compute.
POST, URL: https://api.stdcmpt.com/v1/responses (or /v1/completions).POST https://api.stdcmpt.com/v1/responses
{
"model": "standardcompute",
"input": "Summarize this in 3 bullet points:\n{{Text from previous step}}"
}POST https://api.stdcmpt.com/v1/completions
{
"model": "standardcompute",
"prompt": "Rewrite this politely:\n{{Text from previous step}}",
"max_tokens": 200,
"temperature": 0.3
}Zapier will expose fields from the JSON response so you can map them into later steps. For example, a completion may be accessible via choices__0__text.
Make.com integrates cleanly through its HTTP module (“Make a request”) and custom webhooks. You can call Standard Compute in one module and map the response to subsequent steps.
Use the HTTP app for both /v1/completions and /v1/responses.
POST, URL: https://api.stdcmpt.com/v1/completions (or /v1/responses), and add the authorization header.{
"model": "standardcompute",
"prompt": "Turn this into a friendly customer reply:\n{{message}}",
"max_tokens": 220,
"temperature": 0.4
}{
"model": "standardcompute",
"input": "Extract action items:\n{{meeting_notes}}"
}We keep this guide aligned with platform documentation and community-known behavior. For reference:
https://api.stdcmpt.com