OpenCode Plans and Pricing: Free CLI, Optional Go Plan, and What Parallel Agents Cost

Three routes, and only one is a subscription

Everything about OpenCode pricing comes down to which of these three you pick, and you can switch between them per project or per session.

BYOK is the purest form: OpenCode is just a client. Point it at an Anthropic or OpenAI key you already have and the tokens are billed directly by that provider, exactly as if you had called their API yourself. OpenCode is not in the payment path at all and takes no cut.

Console, the service OpenCode used to call Zen, is a curated gateway. You add credits, use whichever models you want at published per-token rates, and can set an auto-recharge rule. It works like any other provider inside OpenCode: run /connect and pick the OpenCode pay-as-you-go provider, so switching to it is a configuration change, not a migration.

Go is the optional subscription. It gives you an API key for a list of mostly open coding models, such as GLM, Kimi, Qwen, DeepSeek and MiniMax, plus Grok 4.7, GPT 6 Luna, Claude Haiku 5.5 and Gemini 4 Argon. Each model has a monthly dollar limit, and you can use 20% of it per 5 hours and 50% per week.

What OpenCode Zen, now Console, actually costs

Console publishes per-million-token rates split into input, output, cached reads and cached writes. The spread across the catalogue is enormous, which is the single most useful thing to understand about it. As of October 31, 2026:

Read that table again, because the range is the point: the top of the catalogue costs 360 times the budget tier on output. On a subscription CLI your model choice changes how fast you burn a fixed allowance. Here it changes your bill directly and by two orders of magnitude. Picking the right model for the task is not a micro-optimisation on Zen, it is the whole cost story.

Console also carries models listed at $0 input and $0 output. OpenCode marks several of them as limited-time offers, so check the live catalogue before relying on one for a long-running workflow.

Console sells at cost, with markup only to cover processing: a fee of 4.6% plus $0.31 is added to each credit purchase, so a $50 top-up costs $52.61. That is a payment fee rather than a service fee, and it is the argument for topping up in larger amounts less often rather than in small increments.

The auto-recharge rule, and how to set it

Auto-recharge buys credits when your balance runs low, using a threshold and an amount you set in Settings, Billing. This is convenient and it is also the mechanism by which a misbehaving agent quietly spends real money overnight.

Auto-recharge is a rule you add, and you can remove it. Running without it turns your balance into a hard spending cap: once the balance reaches zero, paid requests fail and the balance never goes negative. That is the closest thing OpenCode has to the safety of a subscription: the agent stops when the money runs out, exactly like hitting a weekly limit, except you chose the number.

This is the honest counterweight to "no quota wall". A subscription protects you from your own agents. Pay-as-you-go does not, unless you build the protection yourself.

What running several OpenCode sessions at once does to the cost

On your own key or on Console credits, OpenCode bills per token, so there is no shared allowance to divide and no wall to hit. Go is the exception: its per-model limits behave like a subscription quota, so parallel sessions on the same Go model reach its 5 hour share sooner. Two agents working at the same time simply consume tokens at the same time, and your spend over an hour tracks the number of agents that are actually busy rather than the number of terminals you have open.

That makes a parallel workflow easy to reason about and easy to underestimate. The model matters more than the count: three sessions on a budget model can cost less than one session on a frontier model, given the spread in the Console catalogue. What the count changes is how fast the balance drains, and therefore how often auto-recharge fires.

The practical side of that is in the OpenCode agent swarm guide, and the mechanics of getting several sessions going are in how to run multiple OpenCode sessions.

Pay-as-you-go against a subscription: when each one wins

The comparison people usually make is total monthly spend, and that is only half of it. The real difference is what happens at the edges.

A subscription starts as a fixed cost with included capacity. Many providers now let you enable paid overflow, so the ceiling is optional and the final bill may not be fixed. Pay-as-you-go has no monthly floor: a week off costs nothing, and a week of heavy refactoring costs whatever it costs. OpenCode Go now offers the subscription side inside OpenCode too, from $10 a month.

That maps cleanly onto how people actually work:

• Bursty or occasional work favours OpenCode. Two intense weeks a quarter on a subscription means paying for the ten quiet ones.
• Steady daily work favours a subscription. The predictable cost is worth more than the theoretical savings, and you stop thinking about it.
• Unattended automation favours pay-as-you-go, because a CI pipeline that dies on a personal quota is worse than one that costs a few dollars.
• Learning and evaluation favours OpenCode outright, thanks to the free models and BYOK.

The setup that works best in practice is not choosing at all. Keep a subscription for your daily driver and keep OpenCode on the side for overflow, for the weeks you hit a weekly cap, and for automation. Two providers on two separate meters means you are almost never fully stopped, which is the argument developed in the OpenCode agent swarm guide.

Every number in that table has its own page with the full tier list and the fine print: Claude Code, Codex, Kimi Code, Antigravity, Grok Build and Cursor CLI.

Is OpenCode free? Yes, genuinely

The CLI is free and open source, with no paid edition, no feature gate and no seat count. This is not the "free tier" framing the other vendors use, where the free thing is a limited version of the paid thing. There is no paid version of OpenCode.

What costs money is the model behind it. Console currently has a zero-cost path through temporary free models, but the catalogue can change.

The realistic budget framing: evaluating OpenCode costs $0, using it seriously costs whatever your token consumption costs, and there is no monthly floor. For most single-agent daily use on a mid-tier model, that lands well under a $20 subscription. For heavy parallel agent work on a frontier model, it lands well above one.

Keeping the bill honest while agents run

Without a quota wall, the only thing between you and a surprise is visibility. Three habits do most of the work:

• Match the model to the task. The 360x output spread across the Console catalogue means routine work on a frontier model is the single most expensive mistake available to you.
• Set the balance as a cap. Turn auto-recharge off before any unattended run, so an empty balance stops the agent instead of refilling itself.
• Watch what is actually running. Parallel agents multiply spend linearly, and an agent stuck in a loop looks exactly like an agent working hard.

That last one is where a workspace helps. CodeAgentSwarm, the desktop app for running several AI CLI agents in parallel, keeps every OpenCode session visible at once with its current status and activity, so a session that has been busy for forty minutes on a five-minute task is obvious rather than invisible.