Hermes vs OpenCode: a persistent assistant or an interactive coding agent

Hermes Agent and OpenCode are not two builds of the same thing: Hermes is an always-on personal agent that answers across messaging channels and carries memory between sessions, while OpenCode is an interactive coding agent you drive from a terminal, a desktop app or an editor. Both are MIT licensed, both had commits pushed on the day this page was checked, and both accept a third-party endpoint without a paid tier standing in the way. So the decision is not a feature score — it is where the agent runs, who is allowed to talk to it, and what keeps billing when nobody is typing.

Two name traps first, because both are live in the search results for this comparison. The OpenCode here is anomalyco/opencode: not archived, MIT, default branch dev, 209,062 stars, latest release v1.18.31 published September 14, 2026. GitHub still resolves sst/opencode to it: that path returns this repository's own record, so it is a move between owners rather than a second live project. Why the move happened is not something the API settles, so this page does not say. A different repository, opencode-ai/opencode, has been archived and read-only since September 2025, and its own README says the project "has continued under the name Crush" — see Crush vs OpenCode for that boundary. And "Hermes" also names Nous Research's open-weight model family, a JavaScript engine and a parcel carrier; this page means only NousResearch/hermes-agent (not archived, MIT, 247,674 stars, latest release v2026.9.14, named "Hermes Agent v0.21.3", published September 14, 2026). All four repository states read from the GitHub REST API on September 21, 2026.

Which one should you pick?

Pick Hermes Agent when the work arrives while you are away from the keyboard. Its docs describe "20+ platforms from one gateway" — CLI, Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS and more — plus seven terminal backends and scheduled tasks. That reach comes with a permission axis OpenCode simply does not have: the gateway decides who may address the agent at all, and it defaults closed — "If no allowlists are configured and GATEWAY_ALLOW_ALL_USERS is not set, all users are denied." The cost path is the one to think hardest about, because an always-on agent bills when you are not watching, and the migration blocker is specific: the macOS installer is Apple Silicon only, with Intel macOS named as not a supported platform (installation docs, September 21, 2026).

Pick OpenCode when the work is a repository and you are supervising it. It carries code-specific tooling Hermes does not document: Language Server Protocol integration that uses diagnostics as feedback for the agent, a built-in plan agent that sets file edits and bash to ask, and read-only explore and scout subagents. Its permission model is the exact inverse of Hermes': "Most permissions default to "allow"", with doom_loop and external_directory defaulting to ask and .env files denied. So OpenCode starts open and you close it; Hermes starts closed and you open it. The cost path is simpler — nothing runs when you are not in a session — and the migration cost is the reverse of Hermes': OpenCode documents no cross-session memory of you, so its persistence is the AGENTS.md files you write and commit.

Pick both when the honest answer is delegation. Nous ships a bundled Hermes skill that hands coding work to the OpenCode CLI as an external process — a one-shot opencode run for a bounded task, or a backgrounded interactive session through Hermes' terminal tool. That is first-party documentation rather than a workaround, and it is why this comparison is not purely a substitution question: the two agents do not share a session or a context window, so OpenCode runs on its own credentials and its own meter. The credential and metering detail belongs to Hermes Agent with Codex and OpenCode, which covers the four credential surfaces in that one workflow.

Hermes Agent vs OpenCode, dimension by dimension

Rows read September 21, 2026 from the Hermes documentation index, memory, delegation, tools, checkpoints and security pages, and from OpenCode's rules, agents, ACP, IDE and permissions pages. Every cell that reports an absence — no cross-session user memory, no LSP, no concurrency limit, no sender-authorization layer — is an absence in the pages listed here, not a vendor statement that the feature does not exist.

Both take a third-party endpoint — on different terms

Neither product gates a custom base URL behind a plan. OpenCode Zen is Anomaly's own gateway and its docs say it is "completely optional and you don't need to use it to use OpenCode"; Hermes takes named providers from its own config file, so Nous Portal is one option there rather than a requirement. What differs is protocol reach. Hermes names anthropic_messages as a first-class transport value alongside chat_completions and codex_responses in a providers: block in ~/.hermes/config.yaml (Hermes provider docs). OpenCode documents a generic per-provider baseURL override — "useful when using proxy services or custom endpoints" — and picks the wire format with npm, but its providers page carries no Anthropic-protocol custom-endpoint recipe. Read that as an absence in the documentation rather than a demonstrated block.

One Hermes-specific configuration property is worth reading before you compare rate cards. There is exactly one custom-endpoint case where the provider docs describe Hermes switching caching on by itself: a base URL containing x.ai, where it sends an x-grok-conv-id header with every request. For other custom endpoints the docs describe detection rather than a blanket on or off — Hermes matches a per-model prompt_caching declaration "to the exact provider route and runtime model id", which is how a gateway that resolves a bare alias gets cache markers, and "when omitted, Hermes keeps its normal provider and model capability detection"; prompt_caching: false turns the markers off. Markers are only the client's half of it: whether a given endpoint caches without them is that endpoint's own behaviour, so check it in your provider's documentation rather than assuming either answer. The size of the stake is in Hermes' model configuration docs, which describe a cached rate as roughly 75–90% discounted against full input price. Two smaller notes from the same pages: custom OpenAI-compatible endpoints get "no automatic catalog-sized output cap" from Hermes, so the server's own default applies, and for self-hosted servers the provider docs put tool calling on the server's side of the line — llama.cpp needs --jinja, vLLM needs --enable-auto-tool-choice.

Kunavo serves /v1/chat/completions and /v1/responses at https://api.kunavo.com/v1, and Anthropic Messages at https://api.kunavo.com. On paper that means Hermes can reach it on all three of its transports (the Messages route answers for Claude models only) and OpenCode on both of its npm packages — but this is source-document review, not a tested integration. Neither client has been runtime tested against Kunavo's endpoint here, and Kunavo's own OpenCode integration doc carries its own earlier verification stamp. For the Hermes side, Hermes Agent custom API covers the provider block; the Anthropic base URL doc covers the host-root form the Messages transport expects.

Kunavo does not serve embedding, text-to-speech or speech-to-text models, so none of those steps can be pointed here. Hermes ships a text_to_speech tool and its tools page lists a Nous Portal hosted gateway covering web search, image generation, TTS and browser automation; that side of the work stays with whichever provider you have configured for it.

What the same tokens cost on each route

Neither client charges for itself. Both repositories are MIT licensed, and Hermes' own FAQ states it plainly: "Hermes Agent itself is free and open-source (MIT license). You pay only for the LLM API usage from your chosen provider." What differs is the shape of the work each one sends.

This is illustrative token arithmetic, not a measured task cost and not a bill ceiling. Assume one working session of 400,000 uncached input and 25,000 output tokens. For the Hermes shape, add a delegated batch of three subagents at 300,000 input and 20,000 output each — a number chosen for illustration, not measured; Hermes' documented default allows up to ten. Rates are live Kunavo catalog prices per million tokens.

Two readings. Under these assumptions the delegated workers are $2.40 of the $3.45 total, which matches what Hermes' own delegation docs say qualitatively — "the worker model is where the cost actually lives". And the orchestrator slot is the cheap lever: naming Claude Haiku 4.5 there takes the same run to $2.61. Hermes exposes delegation.model, delegation.provider, delegation.base_url and delegation.api_key, so workers can point somewhere different from the orchestrator entirely. Remember the multiplier this example leaves out: "Every auxiliary task defaults to auto — meaning Hermes tries your main model for that job too", across compression, vision, summarisation, approval scoring, MCP routing, title generation and skill search.

If you are weighing Kunavo against OpenCode's own gateway, the comparison flips by model, so name the model every time:

Zen figures read from Anomaly's own rate card on September 21, 2026, which states the prices are per 1M tokens. These are three rows of a longer table, so draw no conclusion about models not listed here. Zen also auto-reloads $20 when a balance falls below $5, which is a funding behaviour worth checking before you compare balances rather than rates. OpenCode Go is a separate $10-per-month product metered in requests rather than tokens and usable "with any agent" (checked September 21, 2026), so it is not comparable to any per-token rate on this page, including Kunavo's.

One line item has no OpenCode counterpart: if you host the always-on agent, Hermes Cloud publishes $0.56 per day running and $0.03 per day stopped for a Medium instance (10 concurrent sessions, 2GB RAM, 4 vCPUs), with a $2 minimum in credits or an active subscription required to deploy, and it states that those charges cover compute and storage while inference and tool usage bill separately on top (checked September 21, 2026). OpenCode runs on your own machine and charges nothing for idling.

Kunavo's catalog amount is a billing floor rather than a cap: when the upstream reports its charge, the bill is the greater of catalog cost and upstream cost times the applicable markup. Cache charges and external tools sit outside this example. The minimum top-up is $10 in prepaid credit with no free tier — a funding minimum, not a task fee or a subscription. See billing details, and create an account when you have chosen a route.

What does not migrate between them

Switching agents moves less than it looks like it should, and each side keeps its state in its own place.

• Hermes state lives in ~/.hermes/: memories/MEMORY.md and memories/USER.md, skills/, config.yaml and state.db. Memory is "scoped per profile by design", and the docs warn: "Don't point two agent processes at the same Hermes home directory." No export or import mechanism is documented on the memory page, so treat the paths as fact and the portability as unverified.
• OpenCode state lives in ~/.local/share/opencode/ (including auth.json and per-project session data) with configuration in ~/.config/opencode/. Its durable, portable asset is the AGENTS.md files in the repository, which travel with the repository rather than with the agent.
• Skills and instructions are not interchangeable. Hermes writes its own skills to disk and calls the format compatible with an open skills standard, but nothing checked here establishes that OpenCode loads a Hermes skill or that Hermes reads an AGENTS.md.
• Channel setup has no counterpart. Gateway allowlists, DM pairing and cron schedules are Hermes concepts; there is nothing on the OpenCode side to import them into.

Comparing further afield? Hermes vs OpenClaw covers the other always-on assistant, OpenCode vs Claude Code the other interactive coding agent, and OpenCode pricing and Hermes Agent pricing each product's own commercial terms.

FAQ

Checked September 21, 2026: the GitHub REST API for both repositories, their latest releases and the two same-name repositories, plus the documentation and pricing pages linked throughout this page on hermes-agent.nousresearch.com, portal.nousresearch.com and opencode.ai. Two topics were left out because the sources do not settle them: OpenCode's providers page states both that /connect offers a Claude Pro/Max option and that Anthropic prohibits the plugins that route those models, and nothing published by either project measures task performance, so this page ranks neither agent. No runtime test was performed — no Hermes session, no opencode run and no request from either client against Kunavo's endpoint. Kunavo token rates come from the live catalog; every dollar figure on this page is illustrative token arithmetic.