Crush vs OpenCode: workflow, models and total cost

Crush and OpenCode are both free terminal coding agents that charge you nothing and both let you point at your own OpenAI- or Anthropic-compatible endpoint, so the choice is not about the price of the client. It is about license, permission defaults, config execution model and which wallet each project steers you toward. Crush is the AI coding agent from Charm — not the Rust shell of the same name — written in Go and shipped under FSL-1.1-MIT. OpenCode is the TypeScript agent at opencode.ai, maintained by Anomaly, under MIT.

Two name traps have to be cleared before any of the rest is safe to read. "Crush CLI" is also the name of an unrelated project — liljencrantz/crush, which describes itself as "a command line shell that is also a powerful modern programming language", written in Rust and nothing to do with AI coding. And there are two repositories called opencode, one of which is Crush's own former name. That is the section immediately below, because getting it wrong invalidates every later comparison.

Three projects, two of them called OpenCode

The archived Go CLI is not a third option in this comparison. It is Crush's ancestor, and the repository says so in its own words: "This repository is no longer maintained and has been archived for provenance. The project has continued under the name Crush, developed by the original author and the Charm team."

Repository metadata read from the GitHub API on September 19, 2026; package versions confirmed against npm, where @charmland/crush is 0.95.0 under FSL-1.1-MIT and opencode-ai is 1.18.31 under MIT. Note that the npm package name opencode-ai belongs to the live Anomaly project, while opencode-ai is also the GitHub org of the archived one — checking npm alone cannot tell them apart, so check the GitHub org. One thing this page could not establish: GitHub returns no archive date for the old repository, so no date is claimed for it. Similarly, github.com/sst/opencode now redirects to anomalyco/opencode and opencode.ai's footers read "© Anomaly", but no dated first-party rename announcement was found, so the handover is described and not dated.

Who should pick which

On migration cost: the model configuration is the cheap half and the config format is the expensive half. There is no converter between a crushrc and an opencode.json, so a project-local setup is rewritten by hand. What survives is broader than it looks — both clients support MCP servers, LSP servers and Agent Skills, so extensibility is not a differentiator between them, only its syntax is. Both also have a non-interactive mode, so this is not a TUI-versus-TUI choice: Crush's run subcommand is described in its source as "Run a single non-interactive prompt", and OpenCode documents opencode run.

Permissions and config execution: the one genuine safety difference

These two projects default in opposite directions, and it is the difference most worth knowing before you let either one loose on a repository.

Crush's README states that by default Crush asks for permission before running tool calls. You widen that with a flat allow or deny list — permissions allow view edit, permissions deny bash sourcegraph — or remove it entirely with --yolo, which the source describes as "Automatically accept all permissions (dangerous mode)".

OpenCode starts from the other end. Its permissions documentation says most permissions default to "allow", with doom_loop and external_directory defaulting to "ask". In exchange the rules are finer: permissions are keyed per tool across read, edit, glob, grep, bash, task, skill, lsp, question, webfetch, websearch, external_directory and doom_loop, they accept glob patterns per tool so bash can allow git * and deny rm *, rules are evaluated by pattern match with the last matching rule winning, and an agent can override the global set. OpenCode also has an --auto flag that approves anything not explicitly denied, so both clients can be made permissive; they simply do not start there.

The second half is the config format. Crush's README is blunt about it: "Both crushrc and crush.json are trusted code; crushrc runs in a full shell, and any $(...) in crush.json runs at load time. Don't launch Crush in a directory whose config you haven't reviewed". Crush reads ./.crushrc, then ./crushrc, then ~/.config/crush/crushrc, so a repository you cloned can ship one. That is a genuine capability — it is how a key comes out of a password manager — and a genuine hazard. OpenCode's opencode.json is data. Both facts checked September 18, 2026; the older Crush JSON format is documented as deprecated and not receiving new features, so build on crushrc rather than on JSON.

The wallet, not the client, is where the money goes

Each project has an official first-party provider, and they are stocked differently. Charm Hyper sells no Claude, GPT or Gemini model at all; OpenCode sells both a frontier pay-as-you-go catalog and a $10 monthly subscription over a separate, mostly open-weights roster.

Hyper prices and the model list were read from its public models endpoint on September 18, 2026 — 23 models, none of them a Claude, GPT or Gemini model. Most carry open-weights family names — DeepSeek, Kimi, GLM, MiniMax, Qwen, gpt-oss-120b and Gemma — and one, inkling, is Charm-branded with no documented base model, so "no frontier proprietary family" is the claim this page makes rather than "open-weights throughout". Plan prices come from hyper.charm.land, checked the same day. One conflict worth naming if privacy is part of your decision: Crush's README and Hyper's pricing page both describe zero data retention, while Hyper's own documentation says "a strict 30-day maximum retention policy" and its FAQ frames the zero-retention policy as one held with its cloud providers. Read the docs sentence rather than the marketing one, and confirm in your account terms.

There is a fact here that cuts against the usual lock-in narrative: Crush ships OpenCode Zen and OpenCode Go as built-in providers keyed by OPENCODE_API_KEY, so an OpenCode wallet follows you into Crush. But Go's own documentation asks clients to identify themselves with their own user agent and to send a stable session ID in an x-opencode-session header, and its validated-client table lists Hermes, Claude Code, Codex, ZCode, Pi, jcode and Kilo Code CLI — Crush appears on neither that list nor the problematic one. Absence from a list is not evidence of breakage, and this page has no evidence either way, so it concludes nothing. Test it yourself before you rely on it. Zen's own bring-your-own-key option is narrower than it sounds too: its docs describe using your own OpenAI or Anthropic keys inside Zen, not a slot for an arbitrary gateway.

Bringing your own endpoint, in both clients

This is the part where both projects are genuinely open and where a Crush user gets something Hyper cannot sell them at all. Neither client gates custom providers behind a plan.

The single most useful detail for a Crush user: Crush's base URL includes /v1, for both the OpenAI-compatible and the Anthropic-compatible types. Its README's own custom-provider examples write https://api.deepseek.com/v1 and https://api.anthropic.com/v1. That is the opposite convention from Claude Code, whose ANTHROPIC_BASE_URL takes a bare origin because the client appends the path itself — see the base URL reference for why the same gateway is written two ways. For a Kunavo key the Crush value is https://api.kunavo.com/v1.

# crushrc is Bash. Treat it as executable code, not as settings.
provider add kunavo --type openai-compat \
  --base-url "https://api.kunavo.com/v1" \
  --api-key "$KUNAVO_API_KEY"

model add kunavo/claude-sonnet-5 \
  --name "Claude Sonnet 5" \
  --context-window 1000000 \
  --default-max-tokens 32000 \
  --price-input 2 \
  --price-output 10

Three notes on that block. Use openai-compat, not openai: the README reserves openai for proxying or routing through OpenAI itself. The --price-* flags only feed Crush's on-screen cost estimate — they do not change what you are billed, so a typo there produces a wrong readout rather than a wrong charge. And because crushrc is Bash, --api-key "$(op read ...)" is a documented way to keep the key out of the file entirely. OpenCode's equivalent is a data file, with the key referenced through {env:VAR}:

{
  "$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-5": {
          "name": "Claude Sonnet 5",
          "limit": { "context": 1000000, "output": 128000 }
        }
      }
    }
  }
}

The npm field picks the wire format: @ai-sdk/openai-compatible for an endpoint serving /v1/chat/completions, @ai-sdk/openai for /v1/responses. OpenCode can also override the baseURL of a built-in provider without declaring a custom one, so there are two routes rather than one, and keys added through /connect land in ~/.local/share/opencode/auth.json (provider docs, checked September 18, 2026). Kunavo publishes a full OpenCode setup guide; there is no equivalent Crush page yet, which is why the Crush config is printed here rather than linked. Neither client has been runtime-tested against Kunavo, so treat both blocks as configuration references and verify with one bounded task.

What a session actually costs

The figures below are illustrative token arithmetic, not measured task costs and not a bill ceiling. Assume one agent session that sends 200,000 uncached input tokens and receives 15,000 output tokens — an assumption for comparison, not a measurement of your repository. Rates are live Kunavo catalog prices per million tokens, alongside the rates OpenCode Zen published on September 18, 2026 for the model names it also carries. Zen's catalog is not a mirror of Kunavo's, so one row below has no counterpart there.

Read the middle two columns honestly. On Claude Sonnet 5 the two catalogs are identical at $2.00 and $10.00, so there is no saving to claim there; the gaps are on the other rows. Zen's Claude Haiku 4.5 row is $1.00 and $5.00 against Kunavo's $0.40 and $2.00, and Zen's Claude Opus 5 row is $5.00 and $25.00 against Kunavo's $2.00 and $10.00. Three caveats before you lean on that. Zen lists no model called GPT-5.6 Terra at all — on September 18, 2026 its GPT rows were GPT 6 Astra and GPT 5.6 Sol, neither of which is the same model — so that row is deliberately blank rather than filled with a near neighbour. Zen also tiers its Gemini 3.1 Pro row by context: the rate quoted above is its ≤ 200K band, and a longer prompt prices higher there. And these are published catalog rates on one date, not a benchmark and not a promise that any route is the cheapest way to finish your task: a model that needs a second attempt undoes a rate advantage quickly. Five rows is also not the whole shelf on either side.

Now the point this page exists to make. A displayed cost and a billed cost are different numbers in both clients. Crush's default model listing and its cost estimates come from Catwalk, an auto-updating external catalog, and for a hand-registered custom provider the figures are simply whatever you typed into model add. OpenCode's own products make the same point without any third-party involvement: DeepSeek V4 Flash is $0.14 in / $0.28 out on Zen, $0.15 / $0.60 on Go off-peak and $0.30 / $1.20 on Go at peak (vendor docs, September 18, 2026). Catwalk's record for that model matches the off-peak pair, so a Crush cost readout for it would silently understate peak-hour usage. Reconcile against the ledger your provider account actually recorded, never against the number in the terminal.

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 — a funding minimum, not a task fee or a subscription. See billing details.

Setting one of them up

If you land on OpenCode, start at the OpenCode integration guide and create a Kunavo account to fund a key. If you land on Crush, the crushrc block above is the whole configuration; keep a working route available, run one bounded task, and read the charge your account recorded for it before you switch a daily driver. Comparing further afield? OpenCode vs Claude Code and OpenCode alternatives widen the field, and the OpenAI-compatible API reference covers the endpoint convention both clients rely on.

FAQ

Repository metadata, releases and npm versions checked against the GitHub API and the npm registry on September 19, 2026; licenses, READMEs, Crush source files, and the Charm Hyper, OpenCode Zen, OpenCode Go, permissions and provider documentation checked September 18–19, 2026. Kunavo token rates come from the live catalog. No compatibility, performance or benchmark testing of either client was carried out for this page, and none is claimed; every dollar example here is illustrative token arithmetic rather than a measured task cost.