OpenCode Go: $5 First Month, $10 After, and Hermes Agent Setup

OpenCode Go is easy to misread. It has a low monthly price, a stack of popular open models, and the word “unlimited” nowhere near it. That can still sound like a flat $10 API subscription. It is not that.

You pay $5 for the first month, then $10 per month for a fixed dollar-value allowance metered across a rolling 5-hour window, a weekly window, and a monthly window. Usage is measured in dollars, so request counts vary by model: cheap models like DeepSeek V4 Flash allow many requests per window, expensive ones like GLM-5.2 allow fewer. When you exceed the monthly cap, OpenCode lets you top up with credits from your Zen balance (if enabled) instead of blocking requests. The docs also note Go is “designed primarily for international users and provides stable global access” — a positioning cue, not a refund clause. (OpenCode Go landing page; OpenCode Go docs)

Last verified: August 2, 2026, against the OpenCode Go landing page, the OpenCode Go docs, and the Hermes Agent AI Providers page. Reference links are in the sources list at the end.

Firsthand status: Alastair Fraser has not personally used OpenCode Go. 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.

This guide has two halves. First it explains exactly what the subscription buys, where its limits sit, and how the top-up works. Then it walks through creating the account, getting the right key, configuring Hermes Agent, running a smoke test, checking usage, and diagnosing common failures.

The plan at a glance

OpenCode publishes a single Go tier, plus a 2× usage promo on GPT 5.6 Luna for a limited time. The headline numbers are dollar caps on three rolling windows, not request counts. (OpenCode Go landing page)

The cap mechanics are dollar-based. Different models consume allowance at very different rates per request. OpenCode publishes an estimated request count per model that gives a rough feel, but the usage bar shown in your OpenCode console is the source of truth. (OpenCode Go docs)

Not for production: Go is built for individual interactive use. Sustained batch or customer-facing throughput against the same model will hit the 5-hour or weekly window quickly. OpenCode Zen (PAYG credits) or a direct per-token provider is the better shape for those workloads.

What the dollar caps really mean

The headline numbers — $12/5-hour, $30/week, $60/month — are dollar-value limits, not token counts. Each request converts to a dollar cost using the underlying model’s pay-as-you-go rates, then deducts from the allowance. (OpenCode Go docs)

Three limits operate at once:

1. A rolling 5-hour window. Heavy bursts of expensive-model calls can exhaust this short window even though the monthly cap sounds large.
2. A rolling weekly window. Sustained use across a working week can hit this ceiling before the monthly cap does.
3. A monthly cap. The hard ceiling for the billing month. Not a request counter; a dollar-value allowance shared across all three windows.

OpenCode’s docs explain the multiplier: “we aim to give you 6× that in usage” — meaning $10/month should produce roughly $60 of measured allowance via bulk discounts and reserved GPU capacity. Models where the team has not negotiated a discount run at a lower multiplier. Unused included allowance does not roll into the next billing cycle. The subscription buys bounded dollar-value access over time, not a stockpile. (OpenCode Go docs)

Models, modalities, and exclusions

The current Go lineup lists 18 open models. The exact roster and the per-model request estimates are pulled live from the OpenCode Go docs and the landing page; treat them as a snapshot. (OpenCode Go docs)

The full 18-model roster (including minimax-m2.5) is on the live endpoints table. The per-model request-estimates table on the same page is the source for the numbers above; re-pull before recommending it to others.

The endpoints follow OpenCode’s per-model routing: chat/completions for most models, messages (Anthropic-compat) for the MiniMax / Qwen group, and responses for GPT 5.6 Luna — all hosted under https://opencode.ai/zen/go/v1/. Hermes normalizes this automatically. (OpenCode Go docs)

The live docs warn: “The list of models may change as we test and add new ones.” Treat the table as a verified snapshot for the publish date; re-check before recommending it to others. (OpenCode Go docs)

Privacy: per-model data retention

OpenCode publishes a per-model data-retention table. Almost every Go model retains data for 0 days by default; the exceptions are Grok 4.5 (30 days, with ZDR disabling some xAI features — see xAI docs), GPT 5.6 Luna (abuse-monitoring logs up to 30 days per OpenAI’s data retention controls), and DeepSeek V4 Flash (monthly ZDR agreement; current run through August 31, 2026). (OpenCode Go docs)

If you pass personal or proprietary data through these models, re-check the live OpenCode privacy table before treating a specific model as zero-retention.

Optional supplement: Zen top-up credits

OpenCode Go is the hybrid “flat-fee-with-overage” sibling of OpenCode Zen. When you turn on the Use balance option in the OpenCode console, requests that exceed your Go monthly cap fall back to your Zen balance instead of being blocked. Without the toggle on, requests over the monthly cap are blocked — that is the budget guardrail. With it on, top-up is opt-in: an empty Zen balance still fails. Treat Zen top-up as a way to handle bursty weeks, not a substitute for buying Go. (OpenCode Go docs; OpenCode Zen landing page)

Which tier should you buy?

There is only one Go tier, so the buying decision is really “should you buy Go at all?” Three honest answers:

Yes — if mixed open-model coding is what you actually want. A $10/month flat fee across 18 open models (Kimi, DeepSeek, MiniMax, Qwen, GLM, MiMo, Hy3, Grok) is unusually good value; the OpenCode team benchmarked the roster for agentic coding. (OpenCode Go docs)

No — if your workload is steady-state production. Sustained batch or customer-facing throughput against the same model will hit the 5-hour or weekly window quickly. OpenCode Zen (PAYG credits) or a direct per-token provider is the better shape.

Maybe — if you already subscribe to other coding subscriptions. A $10 OpenCode Go alongside a $20 MiniMax Token Plan or $20 Nous Portal starts to overlap. Pick one flat-fee subscription as your primary and keep Go for the specific models it uniquely covers (Grok 4.5, Kimi K3, MiMo-V2.5, Hy3, the cheap GLM-5.2/5.1 per-call side).

A safe buying rule: subscribe for one month at $5, watch the usage bar and the live model roster, then decide whether the recurring $10 is worth it. The landing page states “Cancel any time”; the legal contract is the Terms of Use. (OpenCode Go landing page; OpenCode Terms of Use)

Limits to understand before subscribing

• Single Go subscription per workspace. Only one member per workspace can subscribe to OpenCode Go; each team Go account needs a separate workspace. (OpenCode Go docs)
• No production-grade guarantee. Go is “designed primarily for international users” and curated for interactive coding; treat the caps as a guideline, not an SLA.
• Promo is time-bound. “GPT 5.6 Luna gets 2× usage limits for a limited time” — the multiplier can disappear. (OpenCode Go landing page)
• Model roster drifts. “The list of models may change as we test and add new ones.” Do not pin tooling to one model id without checking it on the day. (OpenCode Go docs)
• Cancellation is “any time” on the landing page; the legal effect lives in the OpenCode Terms of Use (a binding contract with Anomaly Innovations, Inc.; arbitration agreement + class-action waiver). (OpenCode Terms of Use)
• Restricted uses. The Terms of Use prohibit scraping, automated extraction of Output, training competing models, running auto-responders / spam / background processes while not logged in, and reverse engineering. Violations can terminate your account. (OpenCode Terms of Use)
• Privacy and data handling. OpenCode publishes a privacy policy separately; check it if you are passing user content through the included models. (OpenCode Privacy Policy)
• Treat checkout as authoritative. Prices, promos, and the roster can shift. Verify live before paying.

Before you set up Hermes Agent

You need a macOS or Linux terminal (or Windows via WSL2), an OpenCode account, an active OpenCode Go subscription, the OpenCode Go API key from the console, and a current Hermes Agent installation.

Direct links:

• Sign in or create an OpenCode account
• OpenCode Go landing page (subscribe button)
• OpenCode Go docs (How it works + API endpoints)
• Hermes Agent AI providers documentation

Install Hermes Agent

If Hermes is not installed, use the published installer:

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

Then check the installation with hermes doctor. Review scripts downloaded with curl | bash before running them if that is your security policy. The authoritative installation guide lives at the current Hermes installation page.

Subscribe to Go and get the API key

1. Create or sign in to your OpenCode account.
2. Open OpenCode Go and click Subscribe to Go. The first month bills $5, recurring $10/month.
3. In the OpenCode console, copy the OpenCode Go API key. Keep it private. This is the credential Hermes uses to draw from your Go allowance and, if enabled, fall back to your Zen balance.
4. If you want bursty requests to continue after you hit the monthly cap, open the console and enable Use balance so Go can top up from Zen credits. Leave it off if you want a hard stop at $60.

The key can exist before the Go subscription is active. If Hermes returns an authorization error after wiring up, confirm the subscription is paid and the key matches the workspace you subscribed in. (OpenCode Go docs)

Configure OpenCode Go in Hermes

OpenCode Go is one of the named providers in Hermes. The native provider id is opencode-go, its credential variable is OPENCODE_GO_API_KEY, and its base URL is https://opencode.ai/zen/go/v1. Hermes persists API keys under ~/.hermes/.env. (Hermes Agent AI providers)

Run hermes model, choose OpenCode Go, paste your API key, and pick a model. Start with mimo-v2.5 or deepseek-v4-flash for the smoke test, or minimax-m3 if you want to test Anthropic-compat routing.

To manage the key yourself without printing it into shell history:

mkdir -p ~/.hermes
chmod 700 ~/.hermes
read -rsp 'OpenCode Go API key: ' OC_KEY; printf '\n'
printf 'OPENCODE_GO_API_KEY=%s\n' "$OC_KEY" >> ~/.hermes/.env
unset OC_KEY
chmod 600 ~/.hermes/.env
hermes model

Do not reuse an OpenCode Zen key here by accident — Go and Zen use separate keys and separate billing.

Command map

The authenticated smoke-test command syntax was checked against current Hermes Agent docs; the authenticated call itself was not run in this guide context (no reader-owned OpenCode Go key was exposed).

Smoke-test the connection

Run a small one-shot request against a cheap, call-dense model:

hermes chat --provider opencode-go --model deepseek-v4-flash \
  -q "Reply with exactly: GO_OK"

A response containing GO_OK proves that Hermes can resolve the opencode-go provider, read the credential, reach https://opencode.ai/zen/go/v1, and invoke the model. It does not prove that the monthly cap is sufficient for a heavy agent session or that Zen top-up is configured.

For normal interactive work, start Hermes with hermes. Inside a running session, /model opencode-go/<model> switches between Go models without re-authenticating. To add or authenticate a new provider, exit and use hermes model in the terminal. (Hermes Agent AI providers)

The authenticated smoke-test command syntax was checked against current Hermes Agent docs; the authenticated call itself was not run in this guide context (no reader-owned OpenCode Go key was exposed).

Check usage and remaining quota

OpenCode does not publish a quotable REST endpoint for “remaining Go allowance.” The source of truth is the usage bar in your OpenCode console, alongside the Go subscription tile and (if enabled) the Zen balance. (OpenCode Go docs)

Troubleshooting

401 or “invalid API key”

Confirm that you copied the OpenCode Go key from the console, not a Zen PAYG key or another provider’s key. Check for trailing whitespace, then re-run hermes model. Never post the key in a screenshot.

The key exists but no models are listed (or one is missing)

OpenCode Go requires a paid subscription plus the key. After signing up, wait a minute and run hermes model --refresh. If a published model id still does not appear, the docs page is the canonical roster — re-pull it before debugging further. If models still do not appear at all, check OpenCode status / Discord, update Hermes, and compare your installed version against the current providers docs.

Requests succeed, then stop

You have hit one of the three caps (5-hour / weekly / monthly). Options:

• Wait for the rolling window to reset.
• Enable Use balance in the OpenCode console so requests fall through to your Zen credits.
• Switch to a cheaper model (deepseek-v4-flash, mimo-v2.5) for the rest of the window.
• Wait for the next billing month for the monthly cap to reset.

The model is missing from the picker

See “The key exists but no models are listed” above — the recovery steps are the same.

The provider does not show up at all

Confirm OPENCODE_GO_API_KEY is set in ~/.hermes/.env and the file is owner-readable (chmod 600). Outdated Hermes installs sometimes omit the built-in opencode-go profile; run hermes update and restart.

”Model not supported” from the API

This is a known failure mode: OpenCode Go’s API expects bare model ids (minimax-m3, kimi-k3), not vendor-prefixed names (minimax/minimax-m3, moonshotai/kimi-k3). If you copy a config from an aggregator like OpenRouter, strip the vendor/ prefix or use opencode-go/<bare-id> in the model: field of config.yaml. (Hermes Agent AI providers)

Security and cost controls

Treat the OpenCode Go API key like a paid credential:

• Keep ~/.hermes/.env owner-readable only (chmod 600); do not commit it.
• Do not paste it into prompts, logs, or screenshots.
• Rotate or replace it if exposed. OpenCode lets you regenerate keys from the console.
• The Terms of Use make the account holder responsible for activity under the account and prohibit the restricted uses listed in § Limits to understand. (OpenCode Terms of Use)

Keep the billing paths distinct so a quota reset never silently becomes an unexpected metered charge:

• OpenCode Go API key → $5/$10 subscription allowance, then optional Zen-balance top-up if the Use balance toggle is on.
• OpenCode Zen (PAYG) API key → pays directly from your Zen credit balance with no Go allowance attached.

If the workflow is a customer-facing service, scheduled batch system, or anything requiring stable throughput, switch to a pure-PAYG provider with explicit budgets and monitoring. Go is built for interactive use; it is not a production SLA. (OpenCode Go docs)

Keep this setup current

OpenCode changes model rosters, promos, and pricing. Hermes changes provider catalogs and setup flows. Before buying or debugging, re-check the OpenCode Go landing page, the OpenCode Go docs, the OpenCode Terms of Use and Privacy Policy, the Hermes provider documentation, and the live checkout shown in your OpenCode account.