Standard Compute review: unlimited flat-rate LLM API for Hermes Agent (setup + plans)

If your Hermes Agent setup burns through per-token bills, or you keep hitting 429s while looping a long task, Standard Compute offers a different shape: one flat monthly price, no usage meter, and a single OpenAI-compatible base URL your agent already speaks. Three plans, $39 / $89 / $249 per month, all “no usage limits, smart-routed across frontier models.” Hermes Agent is listed by name in their integrations directory.

Quick decision box

Pick a tier by workload, not by token count.

• Economy ($39/mo) — shared pool, smart-routed. Solo developer or hobbyist. One Hermes Agent, bursts of long context, occasional cron jobs.
• Standard ($89/mo) — priority lane, higher-capacity pool. Always-on personal agent, one or two long-running workflows, day-long interactive sessions.
• Max ($249/mo) — highest priority, 24/7 fleets. Multi-agent production, multi-hour cron, anything that needs the router to never yield.
• Not for production if you need hard real-time latency guarantees. Pacing under extreme sustained load is by design — it slows responses, it does not reject them. If you need per-millisecond SLOs, a per-token provider fits better.
• Not for “pin this exact model version” workflows. The router picks the model per request. You set the model to standardcompute; you never set Claude Opus 5 or GPT-5.6 Sol by name.

Last verified: 2026-08-03 against standardcompute.com, the integrations page, the unlimited LLM API page, and the Hermes Agent providers docs. Pricing, plan features, the base URL, and the named-custom-provider schema were all live at that time.

Firsthand status: Alastair Fraser has not personally used Standard Compute. This is an independent research and setup guide based on current official documentation and public plan information; it does not claim an authenticated hands-on test.

Short answer. Standard Compute is a flat-rate, OpenAI-compatible LLM API. If your Hermes Agent setup is bottlenecked on token meters, on 5-hour window resets, or on per-token variance month-to-month, this product directly targets that. Hermes supports it cleanly through the named-custom-provider schema in config.yaml — three fields, one env var, no code changes. If you need a specific model version pinned across runs, or a hard latency SLO, look elsewhere. Jump to setup: ## Five-step Hermes quick setup or ## Detailed setup and usage checking.

Contents

• Short answer and recommendation
• Plan comparison
• Which plan should you choose?
• Five-step Hermes quick setup
• How the pricing actually works
• Models, media and exclusions
• Detailed setup and usage checking
• Troubleshooting, security and billing

Short answer and recommendation

Standard Compute is one product, not a family of SKUs. The three plans (Economy / Standard / Max) are the same OpenAI-compatible API on the same https://api.stdcmpt.com/v1 base URL. What changes between plans is the lane — shared pool, priority scheduling, or 24/7 fleet priority — and the price. There is no separate pay-as-you-go product, no “Coding Plan” sibling with its own key, and no developer API distinct from the subscription endpoint. One key from the dashboard unlocks all three plans; you pick the tier at checkout.

For Hermes Agent, the recommendation depends on what you are doing today:

• If you currently pay per-token to a frontier provider for a personal Hermes install, and you notice the bill swing from $20 to $200 across months, the $89 Standard plan is the most direct replacement. It removes the meter.
• If your Hermes runs a few heavy jobs per week on a hobby project, Economy at $39 is enough. Same endpoint, same model router, same key — just the lowest priority lane.
• If you are running Hermes across a small fleet (multiple agents, 24/7 cron, multi-user teams), Max at $249 is the only plan the vendor describes as “built for 24/7 fleets.” Use it if shared-pool or priority-scheduling is producing noticeable queue waits.

Context-window caveat: Hermes requires a model with at least 64K tokens of context for agent use with tools, and smaller windows are rejected at startup. Standard Compute routes each request to a frontier model, but its public plan pages do not publish a plan-level context-window guarantee. Confirm the routed endpoint/model behavior before relying on it for long tool-calling runs — do not read the $39/$89/$249 tier as a 64K guarantee.

If you need to pin a specific model version — Claude Opus 5 today and Claude Opus 5 next month, deterministically — Standard Compute is not the right shape. The router decides per request. Per the Unlimited LLM API page: “smart routing picks the model per request rather than pinning one version.” That is a documented contract, not a caveat.

Plan comparison

Not a drawable token bank. All three plans list “no usage limits” — that is the headline. The constraint is fair-use pacing under extreme sustained load, not a token allowance. You cannot draw down a balance; the plan is the only bill. See ## How the pricing actually works.

Which plan should you choose?

Start with Economy ($39/mo): personal Hermes Agent, occasional cron, low priority. You’re wiring up for the first time or running a few long-context bursts a day.

Standard ($89/mo): always-on Hermes session, two or three long-running workflows in parallel, or you have already replaced one per-token provider and the priority lane matters.

Max ($249/mo): multi-agent fleet, multi-user teams, or 24/7 cron. The only plan the vendor describes as “built for 24/7 fleets.” Skip it for personal installs.

Skip Standard Compute entirely if:

• You need a specific model version pinned across runs. The router decides per request; you set the model to standardcompute and never name Claude Opus 5 or GPT-5.6 Sol.
• You have hard real-time latency requirements. Pacing slows responses, it does not reject them. If you need a per-request SLO, a per-token provider fits.
• Your workload is small and bursty. A per-token plan is genuinely cheaper when you are only consuming a few million tokens per month.

Limits to understand before subscribing

1. Smart routing, not model pinning. You set the model to standardcompute; the router picks the underlying model per request. This is the central contract — see the homepage FAQ: “you never have to pick or update model names.”
2. Fair-use pacing, not 429s. Under extreme sustained load, responses slow down rather than failing. Per the homepage FAQ: “Run far beyond your plan’s pooled share for a sustained period and responses slow down until usage rebalances.” The vendor’s fair-use page describes this as normal behavior for legitimate use — requests may briefly queue or slow under sustained, wildly out-of-profile load, and suspension is reserved for prohibited use (crypto mining, DoS, mass scraping, illegal content). It is the vendor’s fair-use behavior, not a universal availability or abuse-policy guarantee. Verify the live fair-use page before relying on a specific throughput expectation.
3. Data handling per their security page. Per the homepage: “your prompts and outputs are never stored, logged, or used to train Standard Compute’s models.” Upstream, training policies vary by provider, so provider selection is security-first. The full claim set lives on the security page — read it before sending anything sensitive.
4. No partial-month refunds on cancellation. Cancel anytime from the Stripe billing portal. The plan runs to the end of the paid period and stops.
5. No separate “Coding Plan” or pay-as-you-go SKU. One subscription product, three lanes. The PAYG and “subscriptions” columns on the homepage compare other vendors’ shapes, not separate Standard Compute products. If you want pay-per-token, this is the wrong vendor.

Five-step Hermes quick setup

The whole setup is five steps.

Step 1 — Subscribe to Standard Compute. Open standardcompute.com and click Get your API key. Sign in, pick a plan (Economy / Standard / Max) at the billing screen, and complete checkout through Stripe. A free trial is offered at sign-up — use it to verify the integration before paying.

Step 2 — Install Hermes Agent (if you have not yet). Follow the Hermes Agent quickstart. Verify a session starts before wiring in Standard Compute, so an integration error is not mistaken for a missing install.

Step 3 — Add the API key to ~/.hermes/.env. Open the file in your editor (nano, code, or open -e on macOS) and add or replace only this line. Do not redirect-print the file — printf … > ~/.hermes/.env wipes every other key:

STANDARD_COMPUTE_KEY=sc_live_replace_me_with_your_actual_key

Save, then lock and verify mode without printing the key:

chmod 600 ~/.hermes/.env
# Linux — expect 600 <path>
stat -c '%a %n' ~/.hermes/.env
# macOS — expect -rw------- in the left column
ls -l ~/.hermes/.env

Step 4 — Add the named custom provider to ~/.hermes/config.yaml. Add a providers: block at the top level (or append a new entry if the block already exists):

# Configuration status: not run / unauthenticated test.
# Hermes' `api`, `key_env`, `transport`, `default_model` schema is current per the
# documented providers page; the wiring against Standard Compute is
# documentation-verified but has NOT been authenticated end-to-end by the author.
providers:
  standardcompute:
    api: https://api.stdcmpt.com/v1
    key_env: STANDARD_COMPUTE_KEY
    transport: chat_completions
    default_model: standardcompute

Field notes, all per the Hermes providers docs:

• api — the endpoint base URL. base_url / url are accepted aliases.
• key_env — Hermes reads the secret from ~/.hermes/.env. Never paste the literal key into YAML.
• transport: chat_completions — OpenAI-wire compatible.
• default_model: standardcompute — set this to Standard Compute’s documented model id. The vendor routes every request through standardcompute; do not replace it with an underlying model/version name.

Step 5 — Smoke test the wiring. From outside any session, run the model wizard and pick the new provider, then send a one-line question to confirm the round-trip:

hermes model
# choose "standardcompute"

hermes chat -q "Reply with just the word OK to confirm the Standard Compute wiring works."

Expected-good output: a short reply containing OK, with the model name reported as standardcompute. A 401 / “Invalid API key” usually means STANDARD_COMPUTE_KEY is not being read — re-check the env-var name in config.yaml and the .env permissions.

How the pricing actually works

Standard Compute charges one flat monthly price per plan. There is no token meter, no per-request cost, no usage cap, and no overage billing. You pay the plan price; the router serves every request you send within the lane you bought.

What “no usage limits” actually means, per the Unlimited LLM API page:

• No per-minute request caps — the homepage states “429 rate limited never.”
• No “quota exceeded” errors, and no 5-hour session caps.
• No meter to watch — the bill is the plan price regardless of how many requests you sent that month.

The catch is fair-use pacing, per the homepage FAQ:

“Run far beyond your plan’s pooled share for a sustained period and responses slow down until usage rebalances — like traffic shaping on a network. You are never cut off and requests are never rejected. The exact policy is on the fair-use page, and your dashboard shows a live speed gauge, current pacing, and a recovery forecast.”

Two practical implications:

1. The router picks the model per request. The model field is always standardcompute. Per the Integrations FAQ: “It is a single model identifier that routes to the best available frontier model for each request, so you never have to pick or update model names.” This is why the Hermes default_model: standardcompute field is mandatory, not a suggestion.
2. The unit of fairness is “sustained heavy load,” not token volume. A loop that keeps the request queue full for an hour will see responses slow down; the policy lives on the fair-use page and is enforced by the dashboard speed gauge. Verify that page before committing a production cron workload.

The “2–7× more compute per dollar” figure on the homepage is described as “user reported” — not measured by the vendor. Treat it as directional, not a benchmark.

Models, media and exclusions

Standard Compute exposes a single OpenAI-compatible model id, standardcompute, that routes per request. The homepage shows a representative (not exhaustive) lineup, “always current” — new releases are reviewed and added within days:

• Frontier (closed): Claude Opus 5 (Anthropic), GPT-5.6 Sol (OpenAI), Gemini 3.1 Pro (Google)
• Open frontier: GLM 5.2 (Z.ai), Kimi K3 (Moonshot AI), MiniMax M3 (MiniMax)

The homepage is honest about this: “A representative lineup, not the full roster. Models and providers shift as we review and re-score them — new releases often land before this page catches up.” Treat any model name you see on Standard Compute’s site as accurate on the date you saw it, not as a permanent contract.

What is excluded from the API surface. Standard Compute is an LLM API. There is no documented image, voice, or video generation endpoint on the Integrations page. If you need those, wire a separate provider alongside Standard Compute (Hermes’ auxiliary model config supports per-task routing — see the Hermes providers docs).

Excluded tools and agents. Per the integrations FAQ: “The exceptions are tools locked to a single vendor’s API with no custom-provider setting, like Claude Code.” Hermes Agent is on the supported list; the vendor maintains a dedicated Hermes setup page with the three required settings.

Detailed setup and usage checking

This is the long form of the five-step quick setup. The quick path gets you to a working wire; this section adds the verification commands and the failure modes you should run before declaring the integration live.

Verify the install. If you do not yet have Hermes Agent installed, follow the official quickstart. Confirm the install is healthy:

hermes --version
hermes model

hermes model opens the wizard. For Standard Compute specifically you do not need the wizard — adding the providers: entry directly to config.yaml is the named-custom-providers path.

Edit ~/.hermes/.env safely. Open the file in your editor and add or replace only this line, then save:

STANDARD_COMPUTE_KEY=sc_live_replace_me_with_your_actual_key

Lock and verify mode without printing the key:

chmod 600 ~/.hermes/.env
# Linux — expect "600 <path>"
stat -c '%a %n' ~/.hermes/.env
# macOS — expect -rw------- in the left column
ls -l ~/.hermes/.env

Do not use printf … > ~/.hermes/.env — it wipes every other key in the file. Always edit, never redirect-print.

Add the providers: block to ~/.hermes/config.yaml:

# Configuration status: not run / unauthenticated test.
# Hermes' `api`, `key_env`, `transport`, `default_model` schema is current per the
# documented providers page; the wiring against Standard Compute is
# documentation-verified but has NOT been authenticated end-to-end by the author.
providers:
  standardcompute:
    api: https://api.stdcmpt.com/v1
    key_env: STANDARD_COMPUTE_KEY
    transport: chat_completions
    default_model: standardcompute

Field notes, all per the Hermes providers docs:

• api — endpoint base URL. base_url / url are accepted aliases.
• key_env — Hermes reads the secret from ~/.hermes/.env.
• transport: chat_completions — OpenAI-wire compatible.
• default_model: standardcompute — set this to Standard Compute’s documented model id. Setting it to a version string (Claude Opus 5, gpt-5.6-sol) is wrong by contract.

Smoke test (verify the round-trip)

Option A — through Hermes. Pick the provider and ask Hermes to confirm:

hermes model
# select "standardcompute"

hermes chat -q "Reply with just the word OK to confirm the Standard Compute wiring works."

Expected-good output: a one-line reply containing OK, model name standardcompute. A 401 usually means STANDARD_COMPUTE_KEY is not being read — re-check the env-var name in config.yaml and the .env permissions.

Option B — direct curl against the endpoint. Bypass Hermes to confirm the endpoint is reachable with your key:

curl https://api.stdcmpt.com/v1/chat/completions \
  -H "Authorization: Bearer $STANDARD_COMPUTE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"standardcompute","messages":[{"role":"user","content":"Reply with just the word OK."}]}'

Expected-good output: a JSON body containing "choices" with a message from the assistant, HTTP 200. A 401 means the key is wrong or revoked; a 400 with model in the error body typically means you set a version string instead of standardcompute.

Troubleshooting, security and billing

Common failure modes.

• 401 / “Invalid API key” on first smoke test. STANDARD_COMPUTE_KEY is not being read. Verify the line is in ~/.hermes/.env (not ~/.bashrc, not a shell export), the file is mode 600, and the field name in config.yaml is exactly key_env: STANDARD_COMPUTE_KEY (case-sensitive).
• 400 with model in the error body. You set default_model to a version string (e.g. claude-opus-5, gpt-5.6-sol). Standard Compute accepts only standardcompute.
• Pacing-induced slow responses. Sustained heavy load — not a fault. Per the fair-use page, responses slow down under sustained pressure and recover when usage rebalances. Your dashboard has a live speed gauge.
• Wiring works, model name in the reply is not what you expect. Correct by contract. The router picks the underlying model per request. If you need a specific model pinned, Standard Compute is the wrong vendor.
• Hermes cannot find the provider after editing config.yaml. Run hermes model from the terminal — it re-reads the config and lists every entry under providers:. If your entry is not there, check YAML indentation (two spaces per level) and that providers: is at the top level, not nested.
• Switching to a different provider for one task. Two model commands, not interchangeable: hermes model (terminal, full wizard) and /model (inside a chat session, switch between already-configured providers). Use /model custom:standardcompute:standardcompute (named provider standardcompute, model standardcompute) to flip to Standard Compute mid-session.

Security notes.

• STANDARD_COMPUTE_KEY is a secret. Do not paste it into chat, screenshots, or committed config. chmod 600 ~/.hermes/.env after every edit.
• Local deletion is not remote revocation. If you leak the key, rotate it from the Standard Compute dashboard — removing it from ~/.hermes/.env only stops this host from using it.
• Per the homepage, prompts and outputs are “never stored, logged, or used to train Standard Compute’s models.” Upstream, training policies vary by provider. The full claim set is on the security page — read it before sending anything sensitive.

Billing notes.

• Three plans, all billed by Stripe. One key works against any plan; you pick the tier at checkout and can change tiers in the dashboard.
• Cancel anytime from the Stripe billing portal. No partial-month refunds.
• No usage-based billing — the plan price is the bill. If Stripe charges a different amount, check whether you upgraded mid-cycle. A free trial is offered at sign-up; use it to verify the integration before paying.

Verifying freshness. Standard Compute’s pricing, model lineup, and base URL can change without notice. Before committing a production workload, re-check the four sources listed in the frontmatter: standardcompute.com for pricing and plan features, the integrations page for the Hermes setup contract, the unlimited LLM API page for fair-use framing, and the Hermes providers docs for the providers: schema. If any of those URLs have moved, this guide’s load-bearing claims will be stale.