Nanocoder vs OpenCode: workflow, models and total cost

OpenCode is the default answer and Nanocoder is the deliberate minority one: on September 19, 2026 OpenCode carried 208,444 GitHub stars to Nanocoder's 2,487, and its npm package was downloaded 9,436,914 times in the 30 days to September 16 against Nanocoder's 6,614. Both are free, MIT-licensed terminal coding agents that let you point at a custom API endpoint. Choosing between them is not a quality ranking — it is a choice between the widest surface with two first-party products competing for your token spend, and a narrower surface run by a collective that sells nothing.

Treat those download figures as orders of magnitude rather than user counts. OpenCode also installs through a curl script and Homebrew, and CI runners inflate any npm number, while Nanocoder ships through Homebrew and Nix outside npm as well. The ratio is directionally solid; the absolute counts are not.

First, make sure you are comparing the right two projects

Three name collisions sit directly in the search results for this comparison, and two of them will break a setup rather than merely confuse you.

One more change worth knowing before you follow an older tutorial. The repository many guides still call sst/opencode now 301-redirects to anomalyco/opencode, and the sst GitHub organization is empty with a description reading that it has moved to anomalyco (GitHub API, September 19, 2026). OpenCode's own docs corroborate it in the install commands — brew install anomalyco/tap/opencode, ghcr.io/anomalyco/opencode — and every docs page is footered as copyright Anomaly. The product name did not change, only the organization. A rename date circulates on social media; it could not be verified here, so none is published on this page.

Who should pick which

Start from your default model, not from the feature list. If your day already runs on a hosted frontier model and local inference is an occasional experiment, OpenCode's posture matches yours. If your day runs on Ollama, llama.cpp, LM Studio, vLLM or MLX and a hosted API is the exception, Nanocoder's does — though this is a difference of default, not of capability, because OpenCode documents Ollama, LM Studio and llama.cpp base URLs too.

Migration cost is symmetric and small at the provider layer, and asymmetric above it. A custom endpoint is one JSON block in either client, so moving a gateway across takes minutes. What does not port is what you built on top: Nanocoder Skills bundles under .nanocoder/skills/ and its lifecycle hooks — where a pre-tool-use hook exiting non-zero denies the call and tells the model why — have no OpenCode equivalent to paste into, and OpenCode's per-agent permission blocks, plugins and LSP configuration have no Nanocoder equivalent. Count that work before you count the config lines.

How the two clients actually differ

Sources for this table, all read September 19, 2026 unless noted: the GitHub API, the npm registry, Nanocoder's configuration and features docs, and OpenCode's config, permissions and CLI pages.

Pointing either one at your own API endpoint

Both document a custom endpoint, so a gateway is a supported configuration in either. The difference is how many wire formats you can reach.

OpenCode names an npm package in the provider block and that choice selects the protocol: @ai-sdk/openai-compatible speaks /v1/chat/completions, and @ai-sdk/openai speaks /v1/responses. Kunavo serves both, so this is a real choice rather than a formality.

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "kunavo": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Kunavo",
      "options": {
        "baseURL": "https://api.kunavo.com/v1",
        "apiKey": "{env:KUNAVO_API_KEY}"
      },
      "models": {
        "claude-sonnet-4-6": {
          "name": "Claude Sonnet 4.6",
          "limit": { "context": 200000, "output": 64000 }
        }
      }
    }
  }
}

Two details the providers page is explicit about and that matter for any endpoint it does not already know. First, register the key with /connect, scroll to Other and use the same provider id you used in the file; credentials land in ~/.local/share/opencode/auth.json. Second, the limit block is worth setting here — the docs say standard providers pull context and output limits from models.dev automatically, and Kunavo is not one of them. The values in the block above are the docs' own example figures, not this model's published limits; set them from the model's own page before you rely on the context meter.

Nanocoder's equivalent lives under nanocoder.providers. Note the lowercase baseUrl, which differs from OpenCode's baseURL, and the ${VAR} substitution applied recursively to string fields.

{
  "nanocoder": {
    "providers": [
      {
        "name": "Kunavo",
        "sdkProvider": "openai-compatible",
        "baseUrl": "https://api.kunavo.com/v1",
        "apiKey": "${KUNAVO_API_KEY}",
        "models": ["claude-sonnet-4-6"],
        "contextWindow": 200000
      }
    ]
  }
}

Three Nanocoder-specific traps are worth reading before you paste that in. The sdkProvider union is closed at five values in source/types/config.ts — openai-compatible, google, anthropic, chatgpt-codex and github-copilot — and the fourth is wired to a browser login against ChatGPT's own Codex endpoint rather than an arbitrary base URL, so there is no generic Responses option to declare. If you instead point sdkProvider: "anthropic" at an Anthropic-compatible endpoint, Nanocoder's own provider docs warn that @ai-sdk/anthropic derives the output ceiling from the model id and falls back to 4096 tokens for anything it does not recognise as a Claude model, truncating long replies mid-sentence with no error; the fix is an explicit maxOutputTokens on the provider entry. And because settings resolve block by block, a project-level file that defines nanocoder.providers supplies that whole block — sibling entries in your global config are not merged in. nanocoder config diff is the documented way to see what actually resolved.

Neither snippet has been runtime-tested against Kunavo's endpoint. Kunavo publishes a setup guide for OpenCode, which is a configuration reference rather than a compatibility test, and publishes none for Nanocoder. Treat both blocks as starting points, run one bounded task, and read what your account actually recorded.

One shared gap: neither client knows your gateway's model metadata

Both clients lean on models.dev for context limits, output ceilings and per-token cost. That file listed 222 providers when checked on September 19, 2026, and Kunavo is not among them — the reason for the absence is not something this page can establish. The consequence differs slightly by client but applies equally to both, so it is not a reason to prefer one.

In OpenCode, declare limit.context and limit.output per model or the remaining-context indicator budgets against a default that is not your model's. In Nanocoder, set contextWindow or per-model contextWindows; its per-response footer prints a token count and an estimated cost priced from models.dev, and its documentation is careful to say the cost segment is omitted when no pricing is available, so a missing number means unknown rather than zero. Either way, the client's figure is its own arithmetic over reported tokens — reconcile against your provider's ledger, not against the footer.

What each one costs you

Both clients are free. The asymmetry is what sits behind them.

Nanocoder has no account, no tier, no hosted service and nothing to upgrade to — its README states there are no paid tiers gating the useful parts, and the project describes itself as funded by sponsors rather than by users. One disclosure belongs here: Atlas Cloud is a listed sponsor, and it also appears in Nanocoder's own supported-provider list and sells a coding plan. That is a non-neutral incentive in an otherwise vendor-free project, and you should know about it rather than not.

OpenCode is free too, but the same vendor sells two products that compete for exactly the spend a gateway wants. Neither is required: the docs describe both as optional, and Zen's goals page commits to letting you use any other provider with OpenCode.

Read September 19, 2026. Two things this table is careful about. Zen's goals page states an intention to pass on price drops by selling at cost, with markup only to cover processing fees. The three Claude rates it publishes do line up with Anthropic's own published rates for those models — Opus 5 at $5 / $25, Sonnet 5 at $2 / $10, Haiku 4.5 at $1 / $5 — so on those three, a comparison against Zen is a comparison against the model vendor's rate card. That check was made only for those three models, on September 19, 2026, and says nothing about the rest of Zen's shelf. And Zen's free models carry data-use strings printed on the same page, ranging from data being used to improve the model during a free period to trial-only endpoints that tell you not to submit confidential data. A free tier with training rights attached is a different product from a free tier without them.

A worked estimate for the token bill underneath either client

This is illustrative token arithmetic, not a measured task cost and not a bill ceiling. Assume one session that sends 200,000 uncached input tokens and receives 15,000 output tokens. Rates come from the live Kunavo catalog per million tokens; your real sessions will differ with repository size, tool output and how often the agent re-reads files.

The comparison people actually want here is against OpenCode Go's $10 a month, and it is not like for like. Go serves a fixed shelf under per-model monthly caps of $15 to $60: its own usage-limits table lists no Claude model and no Gemini model, its one GPT entry is GPT 5.6 Luna, and Grok 4.6 sits on it too — so the docs' phrase "open coding models" does not mean open weights only (checked September 19, 2026). The models above are a different shelf entirely. On these assumptions, $10 of prepaid Kunavo credit models roughly 90 sessions of that shape on Claude Haiku 4.5 at $0.110 each, and about 18 on Claude Opus 5. That sizes a budget; it does not tell you which produces better work on your repository, and cheapest listed rate is not the same question as lowest cost to finish the task — a cheaper model that needs three attempts can cost more than one that needs one.

The like-for-like line is Zen's pay-as-you-go shelf, where the same model appears on both sides. Zen publishes Claude Opus 5 at $5.00 per million input tokens and $25.00 per million output; Kunavo's catalog currently reads $2.00 and $10.00 for the same model. That is the comparison worth making, and it is worth reading carefully: Zen's $5.00 / $25.00 is Anthropic's own published rate for this model, so this is two catalogs pricing the same model differently rather than a padded reseller being undercut. Confirm both in checkout before you move a budget, because either catalog can reprice.

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, which is a funding minimum rather than a task fee or a subscription.

Setting up the one you picked

If you landed on OpenCode, the configuration block above is the whole integration and the OpenCode integration guide covers both wire formats in detail; create a Kunavo account when you are ready to fund a key. If you landed on Nanocoder, use the same base URL through its openai-compatible provider and keep a working route available while you try it — no Nanocoder-to-Kunavo runtime test has been performed here.

Still deciding? OpenCode alternatives widens the field beyond these two, the best API for OpenCode compares provider routes for that client specifically, OpenCode pricing goes deeper on Zen and Go, and the agent API directory records how every client in this space handles a custom base URL. If a provider block is already failing, OpenCode provider not found covers the usual cause, and OpenAI-compatible API explains what that phrase does and does not guarantee.

FAQ

Repository, release and download figures read from the GitHub API and the npm registry on September 19, 2026; behaviour and price claims read from both projects' own documentation on the same date, and the models.dev provider list checked then too. Neither client was runtime-tested against Kunavo's endpoint, no performance or compatibility testing was performed, and every dollar figure for Kunavo on this page is illustrative token arithmetic from the live catalog rather than a measured task cost.