Best API for Your AI Agent

Best API for Hermes Agent

Full guide →

For an always-on Hermes Agent, connect a cost-optimized OpenAI-compatible API such as Standard Compute at https://api.stdcmpt.com/v1: its router sends each background job and scheduled task to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), and all of it draws from one enforced compute budget on a plan from $19/month. Nous Portal is the first-party option, combining models, hosted tools and hosting in one credit balance; OpenRouter or one vendor's key suits light, bursty use; a local model through llama.cpp costs nothing per token if your GPU can run it.

Best API for OpenCode

Full guide →

Which API provider to connect to OpenCode depends on how you use it: OpenCode Go for the native path and mostly open models, DeepSeek's direct API for light, bursty use, and a cost-optimized routed provider like Standard Compute, which sends each turn to the cheapest model that can do it on a monthly plan from $19, once OpenCode is your daily driver. OpenCode lists Standard Compute natively through models.dev, with the base URL https://api.stdcmpt.com/v1, so switching providers is a config selection, not a setup project. The catch nobody puts in the pricing table: single-vendor plans get reshaped mid-flight (price hikes, new weekly caps), and per-token billing turns one runaway agent loop into a surprise invoice. Pick by which failure mode you can live with.

Best API for Claude Code

Full guide →

For a drop-in API that optimizes Claude Code for cost, use Standard Compute: its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), it serves Anthropic's Messages API at https://api.stdcmpt.com, and Claude Code runs on it through the standardcompute launcher or ANTHROPIC_BASE_URL on one plan from $19 a month with no 5-hour or weekly windows. Each plan is a fixed compute budget that stops when used, not unlimited: Standard at $89 carries $89, about 25 median coding-agent days pinned to Sonnet 5.5 at list prices, and smart routing stretches it further. Claude Max is also one price but keeps the windows; the Anthropic API has no windows but no fixed price. Z.ai's GLM Coding Plan is flat-rate too, for GLM models only.

Best API for OpenClaw

Full guide →

To run OpenClaw's always-on jobs cost-efficiently, run standardcompute launch openclaw: Standard Compute's router sends each background task to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), and the tasks draw from a plan from $19 a month with a $19 compute budget until it is spent, then stop instead of billing overage. OpenClaw's jobs consume compute while you are away, so compare providers on routine-call cost and scheduled-task frequency; an always-on process still needs enough allowance for its actual requests.

Best API for Cline

Full guide →

For heavy daily Cline use, the alternative to topping up OpenRouter credits is a cost-optimized API, and Standard Compute is built into Cline's provider list from Cline 4.1.25 (October 16, 2026): pick Standard Compute under API Provider, enter https://api.stdcmpt.com/v1 and your key (on 4.1.24 and older, choose OpenAI Compatible with the same settings). Its router sends each Plan and Act step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), so one key replaces several provider profiles, on a fixed plan from $19/month with an enforced compute budget. OpenRouter stays cheaper for light or bursty use; OpenCode Go and GLM coding subscriptions are candidates where Cline supports them.

Best API for Aider

Full guide →

To run Aider cost-efficiently, set OPENAI_API_BASE=https://api.stdcmpt.com/v1 and run aider --model openai/standardcompute: Standard Compute's router sends each request to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Usage-based access through OpenRouter can suit occasional tasks; choose around edit quality, repository context and how often you use Aider, and verify editing behavior on your own repository.

Best API for OpenAI Codex CLI

Full guide →

To run Codex CLI cost-efficiently, run standardcompute launch codex: Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), and it serves the OpenAI Responses API (/v1/responses) at https://api.stdcmpt.com/v1, which current Codex CLI releases require for custom providers, on a plan from $19 a month with a $19 compute budget. Compare that with your ChatGPT plan's native Codex allowance, and check the API protocol your installed version supports. Its fixed monthly price includes a finite compute budget; parallel tasks consume that allowance faster.

Best API for Pi

Full guide →

To run Pi cost-efficiently, add Standard Compute to ~/.pi/agent/models.json as an OpenAI-format provider at https://api.stdcmpt.com/v1: its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), plans start at $19 a month with a $19 compute budget, and requests stop at the budget instead of billing overage. OpenCode Go is one coding-subscription candidate and OpenRouter offers usage-based model choice; compare them on a task you actually run in Pi.

Best API for Oh My Pi

Full guide →

To run Oh My Pi cost-efficiently, declare Standard Compute in ~/.omp/agent/models.yml with the openai-completions API and https://api.stdcmpt.com/v1: its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), and plans start at $19 a month with a $19 compute budget shared by every model role. Long sessions and parallel subagents spend that budget faster, so compare it with a coding subscription or usage-based models per role.

Best API for Roo Code

Full guide →

Roo Code shut down on May 15, 2026 and its repo is archived, so the API question now applies to where Roo users went: Cline (the extension Roo was forked from, and the Roo team's recommendation), ZooCode (the community fork that keeps Roo's modes) or Kilo Code. All three take the same OpenAI Compatible provider Roo did: base URL https://api.stdcmpt.com/v1 and model standardcompute put them on Standard Compute, whose router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget shared across every mode. Measure a full planning, editing and debugging task first, since each pass uses compute.

Best API for Kilo Code

Full guide →

To run Kilo Code cost-efficiently, add Standard Compute as a custom provider (Provider API: OpenAI Compatible, base URL https://api.stdcmpt.com/v1): its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), plans start at $19 a month for a $19 compute budget, and requests stop at the budget instead of billing overage. Kilo's own routes are metered: Kilo Gateway credits pass provider list prices through with no markup plus a 5% fee on each credit purchase, Kilo Pass from $19 a month is paid out as credits with bonus credits that expire each cycle, and your own provider keys are billed $0 by Kilo. It is a budget, not an open-ended allowance, so check that a month of your long sessions fits.

Best API for Continue

Full guide →

Continue is no longer maintained (its team joined Cursor and the repo is read-only), so for a new setup Cline or Kilo Code is the safer pick; an existing Continue install still works. For a cost-optimized API in Continue, add an OpenAI-compatible model to config.yaml with apiBase https://api.stdcmpt.com/v1, your Standard Compute key and model standardcompute: the router sends each chat and edit request to the cheapest model that can do it, billed on a fixed plan from $19/month, with requests stopping (not overbilling) when the monthly compute budget is used. Evaluate autocomplete separately: a local model often suits frequent small completions better than any hosted plan.

Best API for Amp

Full guide →

To run Amp's main agent cost-efficiently, add Standard Compute as a Custom URL connection in Amp's Model Routing (base URL https://api.stdcmpt.com/v1) and pin your modes to models it serves: for every model we vet providers for price, uptime and speed, with automatic fallback, and usage draws from a plan from $19 a month with a $19 compute budget. Without a connection of your own, Amp bills model usage from credits at providers' API prices, so a long high or ultra thread costs what the API would. Custom URL connections work on every Amp tier, including the free Hobby plan.

Best API for Qwen Code

Full guide →

Since Qwen Code's free Qwen OAuth tier ended on April 15, 2026, every session needs a provider key. To run it cost-efficiently across Qwen and other models, add Standard Compute as an OpenAI-compatible provider in ~/.qwen/settings.json (baseUrl https://api.stdcmpt.com/v1): its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Alibaba's Coding Plan ($50 a month for Pro) is the native fixed-price option for Qwen, GLM, Kimi and MiniMax models with 5-hour, weekly and monthly request caps, and OpenRouter suits light, bursty use.

Best API for Cursor

Full guide →

To run Cursor's chat and agent cost-efficiently, paste a Standard Compute key into Cursor's OpenAI API key field, override the base URL to https://api.stdcmpt.com/v1 and pick the standardcompute model: its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month. It matters most on Cursor's Premium plan and up, where Claude, GPT and other third-party models are charged at API list price on top of the subscription. Any custom key has two limits: Tab completion stays on Cursor's own models, and requests still pass through Cursor's servers.

Best API for GitHub Copilot

Full guide →

For long GitHub Copilot agent sessions in VS Code, add Standard Compute as a Custom Endpoint model (base URL https://api.stdcmpt.com/v1): its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), and those sessions run on a plan from $19 a month instead of Copilot's own models. Copilot meters chat, agent mode, code review and Copilot CLI against monthly GitHub AI Credits, so long agent runs are what drain a plan first. VS Code's docs say bring-your-own-key models work even without a Copilot plan; inline code completions are the part that still needs a GitHub account.

Zed's agent panel costs nothing with your own API key, so the model provider is the whole bill: Standard Compute, added as an OpenAI-compatible provider at https://api.stdcmpt.com/v1, sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month. The alternative is Zed Pro, which bundles a small token allowance and then bills hosted models per token. With your own key, spend goes straight to that provider and Zed itself stays free.

For daily goose sessions, the best API is a cost-optimized OpenAI-compatible provider such as Standard Compute, added as a goose custom provider at https://api.stdcmpt.com/v1: its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. goose's onboarding recommends Agent Router by Tetrate, which starts you on $10 of free credits and then bills per token, and OpenRouter is pay-per-use too. A local model through Ollama costs nothing per token if your hardware can run it. goose itself is free, so the provider is the whole bill.

For Crush, the best API is a cost-optimized OpenAI-compatible provider: add Standard Compute to your crushrc as an openai-compat provider at https://api.stdcmpt.com/v1, and its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Crush is free and runs on your own keys. Charm's own Hyper service bills Hypercredits at 5 cents each, with 100 free a month or 250 a day on its $20 subscription, and OpenRouter suits light, bursty use.

To run Factory Droid cost-efficiently, add Standard Compute to customModels in ~/.factory/settings.json with provider generic-chat-completion-api and baseUrl https://api.stdcmpt.com/v1: with the model standardcompute, its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Factory's own plans run $20, $100 and $200 a month with Factory-hosted models. The catch: Factory says bring-your-own-key use is free only up to an allowance on its Individual plans and is then charged according to your plan, and it does not publish the allowance size.

For JetBrains Junie CLI, the best API is a cost-optimized endpoint in a custom model profile: save ~/.junie/models/standardcompute.json pointing at https://api.stdcmpt.com/v1/chat/completions, run junie --model custom:standardcompute, and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. JetBrains' own route is AI Pro at $10 or AI Ultimate at $30 a month, with 10 or 35 AI Credits worth $1 each. JetBrains says bring-your-own-key use is billed by the provider and needs no JetBrains AI subscription. Custom profiles are a Junie CLI feature; the Junie plugin inside the IDE does not take your own key.

For Kimi Code CLI with more than Kimi models, the best API is a cost-optimized OpenAI-compatible provider: add Standard Compute to ~/.kimi-code/config.toml as an openai provider at https://api.stdcmpt.com/v1 and let its router send each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), or pin moonshotai/kimi-k3, on a plan from $19 a month with a $19 compute budget. A Kimi membership is the native route: Plus at $19 a month and up include Kimi Code, with a rolling 5-hour window and a monthly total. The old Python Kimi CLI is archived; Kimi Code CLI (the kimi command) replaced it.

For Warp's agent, the best API is a cost-optimized OpenAI-compatible endpoint: add Standard Compute as a custom inference endpoint in Warp's settings (URL https://api.stdcmpt.com/v1), pick standardcompute in the model picker, and its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Warp's Build plan is $20 a month with $20 of agent usage at API rates, and Max is $200 with $200. Custom endpoints work on Warp's Free plan for individuals and organizations with 10 or fewer employees, but Warp's Auto models never use them, so you choose the model by hand.

For TRAE's agent on your own API, the best fit is a cost-optimized OpenAI-compatible custom model: in Settings → Models → Add Model → Custom Model, choose OpenAI Chat Completions, enter the base URL https://api.stdcmpt.com/v1, your Standard Compute key and the model ID standardcompute, and its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. TRAE's own plans are Pro at $20 a month with $20 of usage, Pro+ at $60 and Ultra at $200. The catch: Auto mode never uses custom models, and the Free plan is listed as Auto mode only, so plan on picking your custom model by hand.

For Zoo Code, the best API is a cost-optimized OpenAI-compatible provider: set API Provider to OpenAI Compatible with base URL https://api.stdcmpt.com/v1 and model standardcompute, and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget, shared across Architect, Code, Debug and your custom modes. Zoo Code is free and open source with your own keys; its paid parts are Zoo Gateway and Cloud Agent credits and a Team plan at $25 per seat a month. Zoo Code uses native tool calling only, so every model you pin must support tools.

For DeepSeek Harness with more than DeepSeek models, the best API is a cost-optimized custom model API: in Settings → Models → Add model provider → Custom model API, pick OpenAI Chat Completions, enter https://api.stdcmpt.com/v1 and the model standardcompute, and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. dsh's own route is a DeepSeek account or API key billed per token, which is hard to beat if DeepSeek models are all you need. OpenRouter is pay-per-use too. dsh itself is free and MIT-licensed, so the model provider is the whole bill.

For Grok Build with more than Grok models, the best API is a cost-optimized custom model: add [model.standardcompute] to ~/.grok/config.toml with base_url https://api.stdcmpt.com/v1, api_backend = "chat_completions" and env_key = "STANDARDCOMPUTE_API_KEY", and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Signing in with an xAI account runs Grok's own models; The X Subscription's paid tiers ($8 to $200 a month) include a weekly pool for first-party Grok usage, and an XAI_API_KEY bills per token. Grok Build itself is open source (Apache 2.0).

For Codewhale, the open-source terminal agent formerly called DeepSeek-TUI, the best API for mixed work is a cost-optimized OpenAI-compatible provider. Standard Compute is built into Codewhale's provider list from its next release (PR #6985, merged October 16, 2026): run /provider, pick Standard Compute and set STANDARDCOMPUTE_API_KEY. On 0.10.1 and earlier, add [providers.standardcompute] with kind = "openai-compatible" and base_url https://api.stdcmpt.com/v1 to ~/.codewhale/config.toml. Either way, Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. A DeepSeek API key billed per token is the cheap route for DeepSeek-only work, OpenRouter is pay-per-use, and Codewhale runs local models through Ollama too. Codewhale itself is free and MIT-licensed.

For Reasonix (DeepSeek-Reasonix), the best API for mixed work is a cost-optimized custom provider: in Reasonix Studio, Settings → Model → Access → Add model service → Custom provider, choose OpenAI-compatible, enter https://api.stdcmpt.com/v1 and the model standardcompute, and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Reasonix's default is DeepSeek's API billed per token, and its presets cover coding plans such as OpenCode Go, GLM and Kimi. Reasonix itself is free and MIT-licensed.

For nanobot, the self-hosted personal agent from HKU's Data Intelligence Lab, the best API for an always-on setup is a cost-optimized OpenAI-compatible provider: add a standardcompute provider with apiBase https://api.stdcmpt.com/v1 to ~/.nanobot/config.json (or Settings → Models → New preset → Add provider) and a preset with the model standardcompute, and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. OpenRouter and direct provider keys bill per token, and a local model through Ollama costs nothing per token. nanobot itself is free and MIT-licensed.

For Z.ai's ZCode with more than GLM models, the best API is a cost-optimized custom provider: in Settings → Model Providers → Add Provider, set the OpenAI endpoint to https://api.stdcmpt.com/v1, add your key and the model standardcompute, and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. ZCode's native route is a Z.ai account with a free daily trial quota and the GLM Coding Plan (Lite, Pro and Max, with 5-hour and weekly credit limits). ZCode is free and open source (Apache 2.0).

For Command Code with your own key, the best API for mixed daily work is a cost-optimized BYOK provider: add Standard Compute in /connect or ~/.commandcode/providers.json with baseURL https://api.stdcmpt.com/v1 and the model standardcompute, and its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Command Code's own plans ($1 to $200 a month) include credits with 5-hour and weekly limits, and its Provider plan ($15 a month with $15 of usage included) bills the model you pick at list rates with no markup. BYOK requests go straight from your machine to the provider.

NanoClaw runs Claude Code through the Claude Agent SDK, so the endpoint you give it must speak Anthropic's Messages API. For an always-on NanoClaw, the best cost-optimized option is Standard Compute's Messages endpoint: set NANOCLAW_ANTHROPIC_BASE_URL to https://api.stdcmpt.com and your key as NANOCLAW_ANTHROPIC_AUTH_TOKEN before setup, give the agent the model anthropic/claude-standardcompute, and the router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. NanoClaw's setup also accepts a Claude Pro or Max subscription or an Anthropic API key. NanoClaw itself is free and MIT-licensed.

For Docker Agent, Docker's open-source runtime for YAML-defined agents, the best API for agents that run every day is a cost-optimized OpenAI-compatible provider: define a provider with base_url https://api.stdcmpt.com/v1, token_key STANDARDCOMPUTE_API_KEY and api_type openai_chatcompletions, then use standardcompute/standardcompute as the model, and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Docker Agent's built-in providers (Anthropic, OpenAI, OpenRouter and more) bill per token, and Docker Model Runner runs open models locally for free. Docker Agent itself is free (Apache 2.0).

For Octop, Tencent Cloud's self-hosted multi-user assistant, the best API for a household or small team that chats with it every day is a cost-optimized OpenAI-compatible provider: in Model Management → Custom Providers → New Provider, set Type to OpenAI Compatible, Base URL to https://api.stdcmpt.com/v1, add your key and the model standardcompute, and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Octop's presets (DeepSeek, Zhipu, Kimi, OpenAI, Anthropic, Tencent Cloud plans and more) bill per provider, and Ollama runs local models for free. Octop itself is free and MIT-licensed.

For Rakazo, the self-hosted alternative to Grok Bot, Meta Muse and OpenAI Dots, the best API for bots that run routines all day is a cost-optimized OpenAI-compatible endpoint: set RAKAZO_OPENAI_COMPAT_ALLOW_PUBLIC=1 in your deployment, then in Settings → Models choose OpenAI-compatible with the server URL https://api.stdcmpt.com/v1 and the Model id standardcompute, and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. OpenRouter and direct OpenAI or Anthropic keys bill per token, and a ChatGPT plan can sign in for OpenAI's models. Rakazo itself is free and Apache-2.0.

For nanoMuse, the open-source Muse-style personal agent from Zhejiang University, the best API once the account's starting allowance is used up is a cost-optimized OpenAI-compatible endpoint. Standard Compute is in nanoMuse's provider catalogue from its next release (PR #482, merged October 16, 2026): in the web console open Connections → Chat model, click Standard Compute, paste your key and Save. On 1.0.5 and earlier, click Add an endpoint under Local or your own endpoint instead, enter https://api.stdcmpt.com/v1 as the Base URL with your key, click Add endpoint, then pick the chat model standardcompute and Save. Either way, Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. nanoMuse's own docs point to OpenRouter outside mainland China and Alibaba Cloud Bailian inside it, both billed per token, or a ChatGPT plan sign-in. nanoMuse is free, non-profit and GPL-3.0.

For MiniMax Code (mcode), MiniMax's open-source terminal coding agent, the best API depends on the models you want. For MiniMax models only, MiniMax's own M Plan or pay-as-you-go API costs less than any router. For Claude, GPT, GLM or Qwen next to MiniMax, Standard Compute is listed in MiniMax Code's provider picker: run /model, choose + Add 3rd-party provider…, pick Standard Compute under Known providers and paste your key. Its router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. Bringing your own key needs no MiniMax login.

For jcode, the Rust coding-agent harness built for many sessions and swarms, the best API for parallel agents every day is a cost-optimized OpenAI-compatible profile: run jcode provider add standardcompute --base-url https://api.stdcmpt.com/v1 --model standardcompute --api-key-stdin --set-default, and Standard Compute's router sends each step to the cheapest model that can do it (Claude Fable 5.1 or GPT-6 Astra only when it counts), on a plan from $19 a month with a $19 compute budget. jcode also signs in with Claude and ChatGPT subscriptions, which come with usage windows, and with OpenRouter or provider keys billed per token. jcode itself is free and MIT-licensed.