OpenCode Zen vs Go: Which to Choose (and Can You Use Both?)

Zen is prepaid balance. Go is $10 a month from the first charge, and Go Plus is $40 with a higher cap per model. When to use one, the other, or both.

There's a pattern I keep seeing among technical founders and small teams: a Claude subscription, a ChatGPT subscription, a Cursor subscription, loose credits in some gateway, and a vague sense of burning between $60 and $200 a month without knowing exactly on what. When you sit down and look at the bill, you almost always find the same thing: the spend is not in thinking, it is in executing. The tokens do not go in the conversation where you decide the architecture. They go in the three hundred iterations where an agent reads files, runs tests, fixes an import, and reads again.

That distinction — thinking versus executing — is exactly the gap OpenCode Go goes after, a $10-a-month plan that has spent a few months changing the cost equation for anyone who knows how to use it. This article is my read on what actually fits in those $10, how it differs from OpenCode Zen, and why my final recommendation is not "switch to Go." It is more specific than that: define the specs with the most expensive model you can afford, and execute them with the cheapest one that can carry the task.

First, the three names everyone mixes up

OpenCode is an open-source terminal coding agent, maintained by Anomaly. It is the tool: a TUI where you type, an agent that reads your repository, edits files, runs commands, and shows you the diffs. It is free, and it always has been.

OpenCode Zen is something else. It is a model gateway — a middleman — that the OpenCode team built after hitting a real problem: dozens of models claim to be good for programming, but very few work well as agents, and the ones that do give very different results depending on which provider serves them. The same model can be excellent on one provider and mediocre on another, under the same label. Zen is the answer to that: they tested models, talked to the teams that train them, negotiated with providers so they would serve them correctly, benchmarked the model/provider combination, and published a curated list. You pay per use, with prices per million tokens and no declared markup beyond payment-processing fees.

OpenCode Go is the subscription. It costs $10 a month from the first charge and gives access to a catalog of open models, with a dollar cap per model, not one pocket for the plan. Go Plus costs $40 a month, uses the same models, and raises that cap. The jump is not a single multiple: in the September 29, 2026 documentation, GLM-5.3-Flash goes from $60 to $180 and Kimi K2.6 from $60 to $240. It is not an unlimited plan. The $5 first month is gone, and the referral program has ended.

Updated September 30, 2026.

The three names are still independent. Go Plus is a second price for the same Go catalog, not a fourth product. You can use OpenCode with your own OpenAI or Anthropic keys and not pay Zen or Go a cent. You can use Zen from an agent that is not OpenCode. And you can have Go and Zen at the same time, which is in fact what I recommend below.

Comparison table: BYOK, Zen, and Go

	OpenCode BYOK	OpenCode Zen	OpenCode Go
Billing model	Free (you pay the provider)	Pay per use, prepaid balance	Flat subscription
Price	$0 + whatever you spend on your API	Based on tokens consumed	$10/month from the first charge. Go Plus: $40/month
Catalog	Any provider you support	The public list in the docs: Claude, GPT, Gemini, Grok, Qwen, DeepSeek, GLM, Kimi, MiniMax, and free models for a limited time	The Go catalog. It includes Grok 4.7 and 4.6, GLM-5.3 and GLM-5.3-Flash, GPT 6 Luna and GPT 5.6 Luna, Kimi, Qwen, DeepSeek, MiniMax, MiMo, and others. Go Plus uses the same list
Frontier models	Yes, if you pay for the API	Yes. Zen's list includes Claude, GPT, Gemini, and Grok, plus open models	It does not include Claude, GPT Sol, or Gemini Pro. It does include Grok 4.7, Grok 4.6, GPT 6 Luna, and GPT 5.6 Luna, with a $15 monthly cap on Go
Limits	Your provider's	Your balance, and a workspace or member monthly limit if you set one	Per model: 5 hours = 20% of its cap, week = 50%, month = 100%. On Go that cap is $15, $30, or $60 depending on the model
Auto-reload	N/A	If the balance drops under $5, it reloads $20. You can change the amount or turn it off. A monthly limit does not stop that reload	N/A, it is a flat fee
When you hit the limit	N/A	Reload, or it stops	You continue with the free models, or it falls through to your Zen balance if you turn on "Use balance"
Teams	Manual	Workspaces with roles, per-member limits, and models an admin can turn off. Management is in a free beta	Only one member per workspace can subscribe to Go or to Go Plus
Data retention	Your provider's	Providers state zero retention and no training, with exceptions: free models, OpenAI and Anthropic (30 days), Muse Spark Contributor, and others listed in the docs	0 days on most. 30 days on Grok 4.7, Grok 4.6, GPT 6 Luna, and GPT 5.6 Luna. Muse Spark Contributor does train
Bring your own key	It is the default mode	Yes, you can use your OpenAI or Anthropic keys inside Zen. The provider bills those tokens, not Zen	No
Who it's for	Anyone who already has contracts or credits	Anyone who needs models Go does not include, and fine control of spend	Anyone who executes a lot inside the Go catalog. Go Plus, if that quota falls short

The quick read of this table: Zen is a full catalog at market prices, Go is a cheap subset with a ceiling. They do not compete. They complement each other.

What actually fits in $10

Go does not give you a shared token fund. Each model has a monthly cap in dollars. On that cap, the 5-hour window is 20%, the week is 50%, and the month is 100%.

That only produces $12 every five hours, $30 a week, and $60 a month when the model has a $60 cap. A $30 model allows $6, $15, and $30. A $15 model allows $3, $7.50, and $15. The line "you pay $10 and they give you about $60" describes the first group, not the whole plan.

In the September 29, 2026 documentation, Go's caps split like this:

$60: GLM-5.3-Flash, GLM-5.2, Kimi K2.7 Code, Kimi K2.6, LongCat-2.0, MiMo-V2.6-Flash, MiMo-V2.5, MiniMax M3, MiniMax M2.7, Muse Spark 1.3 and 1.2 Contributor, Qwen3.7 Plus, DeepSeek V4.1 Flash, Hy3.
$30: Qwen3.8 Flash, DeepSeek V4 Flash, Hy4 preview.
$15: GLM-5.3, Kimi K3, MiMo-V2.6-Pro, MiMo-V2.5-Pro, Qwen3.8 Max, DeepSeek V4 Pro, DeepSeek V4 Flash Vision Exp, Grok 4.7, Grok 4.6, GPT 6 Luna, GPT 5.6 Luna.
No paid cap, for a limited time: Space Bunny Free and LongCat 2.5 Preview Free.

Go Plus, at $40, does not multiply everything by the same factor. GLM-5.3-Flash moves to $180, Kimi K2.6 to $240, DeepSeek V4.1 Flash to $120, Kimi K3 to $60, and Grok 4.7 to $60.

The next table copies Go's estimated requests. OpenCode calculates them from an observed usage pattern per model. I did not recompute them.

Model	Go cap	Requests / 5 h	Requests / week	Requests / month
Muse Spark 1.3 / 1.2 Contributor	60	45,300	113,300	226,600
MiMo-V2.6-Flash and MiMo-V2.5	60	30,100	75,200	150,400
DeepSeek V4.1 Flash	60	26,000	65,000	130,000
DeepSeek V4 Flash	30	13,000	32,500	65,000
LongCat-2.0	60	11,400	28,600	57,200
GLM-5.3-Flash	60	6,320	15,790	31,580
DeepSeek V4 Flash Vision Exp	15	6,500	16,250	32,500
Qwen3.8 Flash	30	5,400	13,500	27,000
Qwen3.7 Plus	60	4,300	10,800	21,600
Hy3	60	4,300	10,750	21,500
GPT 6 Luna	15	4,230	10,560	21,130
MiniMax M2.7	60	3,400	8,500	17,000
MiMo-V2.6-Pro and MiMo-V2.5-Pro	15	3,250	8,150	16,300
MiniMax M3	60	3,200	8,000	16,000
GPT 5.6 Luna	15	2,050	5,100	10,250
Kimi K2.7 Code	60	1,350	3,380	6,750
Hy4 preview	30	1,350	3,380	6,770
Kimi K2.6	60	1,150	2,880	5,750
DeepSeek V4 Pro	15	1,050	2,600	5,200
GLM-5.2	60	880	2,150	4,300
GLM-5.3	15	220	540	1,080
Grok 4.7 and Grok 4.6	15	169	423	845
Qwen3.8 Max	15	160	400	810
Kimi K3	15	110	250	490

Muse Spark 1.3 Contributor estimates 226,600 requests a month. Kimi K3 estimates 490. It is the same $10 plan. Anyone who uses Go as a buffet of "always the model with the bigger name" fills the 5-hour window on day one. On a model capped at $15, that window is $3, not $12.

On Go Plus, the same GLM-5.3-Flash estimates 18,960 requests every 5 hours, 47,370 a week, and 94,740 a month. Kimi K3 estimates 440, 1,000, and 1,960. Grok 4.7 estimates 676, 1,692, and 3,380. The rest of the table is in the Go documentation.

A real agentic task — add authentication, write the tests, and update the docs — is not one request. It is somewhere between 30 and 150 turns. By that yardstick, GLM-5.2's 4,300 monthly requests are between 30 and 100 medium tasks a month. For one person, that is plenty. For four people on the same account, it is not: only one member per workspace can subscribe to Go or to Go Plus.

If you want a breakdown focused only on Go's price and limits, without the Zen or strategy part, I have a dedicated review: OpenCode Go: price, usage limits, and whether it is worth it in 2026.

The real cost per turn, for scale

To see why the strategy I am proposing works, it helps to calculate what a typical agentic turn costs on each model. I use a realistic, fixed profile — about 800 tokens of new input, 60,000 tokens read from cache (the repo context, which dominates the spend), and 250 tokens of output — and I apply Zen's public prices:

Model	Estimated cost per turn	Turns per $1
GPT 5.6 Luna	$0.00166	~600
DeepSeek V4 Flash	$0.00186	~540
MiniMax M3	$0.0041	~240
Kimi K2.7 Code	$0.0132	~76
Claude Sonnet 5	$0.0161	~62
GLM-5.2	$0.0178	~56
Grok 4.5	$0.0211	~47
Claude Opus 5	$0.0403	~25
GPT 5.6 Sol	$0.0415	~24
Claude Fable 5	$0.0805	~12

My own estimate from August 12, 2026, using the profile above and Zen's prices that day. I did not recalculate it on September 30, 2026: the catalog now includes newer models and the prices move. It shows the order of magnitude, not a budget for the month. Grok 4.5 in this table is a Zen price from that day, not a current Go model.

What stands out is that the gap between the frontier model and the workhorse is not 30% and it is not double: Claude Fable 5 costs more than forty times what GPT 5.6 Luna or DeepSeek V4 Flash costs for the same turn, and inside the Go plan that gap gets wider still. Which raises the uncomfortable question: do those 150 turns of "read the file, apply the diff, run the test" really need the best model in the world?

Almost never. What does need the best model in the world is the decision of what to build and how. And that decision is five or ten turns, not a hundred and fifty.

My recommendation: separate design from execution

Here is the core of the article. My workflow, after a fair amount of trial and error, is this: I define the spec with Claude or Grok, and I execute the spec with OpenCode Go.

I mostly use Claude — Opus 5 when the decision is architectural, Sonnet 5 for more routine specs — and Grok when I want a second opinion with a different bias, or when I need the model to be direct instead of agreeable. Codex works just as well for this phase if it is your usual tool. The point is not the brand. It is the role.

The logic is the same one we apply in any serious agile method: refinement and execution are different activities, with different costs and different risk profiles. Nobody puts the architect on unit tests, and nobody asks the junior to decide the data model. When you mix both into one conversation with a frontier model, you pay architect prices for execution work for hours.

Why this works technically

An execution model does not need creativity. It needs obedience and competence. If the spec is good — if it says which files to touch, which contract to meet, which edge cases to cover, and how success is verified — then the task stops being "design this" and becomes "transcribe this into code and validate it." Models such as GLM-5.2 or Kimi K2.7 Code do that perfectly well.

When the spec is bad, the execution model starts improvising. That is where people conclude that "open models are no good." It is not that they are no good. You asked them to do two jobs and only paid for one.

The concrete workflow, step by step

1. Design conversation with Claude or Grok. No code yet. Describe the problem, the business context, and the constraints. Explicitly ask it to question you before it proposes anything. You spend 5 to 15 turns of an expensive model here, and they are the best-spent turns in the process.

2. Generate the spec as a file. Ask for markdown, with this minimum structure: goal, context (what exists today), explicit scope, explicit out of scope, files to touch, contracts and interfaces, edge cases, verifiable acceptance criteria, and a verification plan. Save it in the repo, for example at specs/2026-08-12-auth-jwt.md. Living in git is part of the point: it is documentation and it is traceability.

3. Split it into atomic tasks. Each task in the spec should be something an agent can finish and verify without ambiguity. If a task needs a product decision halfway through, it is not ready to execute. Go back to step 1.

4. Execute with OpenCode Go. Open OpenCode in the repo, point at the spec, and let the workhorse model work. My default assignment is GLM-5.2 or Kimi K2.7 Code for the main implementation, and MiniMax M3 or DeepSeek V4 Flash for mechanical tasks (renaming, migrating syntax, generating repetitive tests, updating imports).

5. Review with the expensive model, only if you need to. If the tests pass and the diff is readable, you do not need to. If something smells off, hand the diff to Claude or Grok with a specific question. That is three turns, not thirty.

Example of an executable spec

# Spec: Rate limiting on the public search endpoint

## Goal
Prevent abuse of `GET /api/search`, which today has no protection.

## Context
- Express 4 + Redis already available in `src/lib/redis.ts`
- Auth middleware in `src/middleware/auth.ts` (the pattern to copy)
- No middleware tests yet

## Scope
- Reusable `rateLimit` middleware, configurable per route
- Apply it only to `GET /api/search`
- Sliding window in Redis, 60 requests / 60s per IP
- Respond 429 with a `Retry-After` header

## Out of scope
- Rate limiting per authenticated user (phase 2)
- Metrics dashboard
- Changes to the search algorithm

## Files
- Create: `src/middleware/rateLimit.ts`
- Create: `src/middleware/__tests__/rateLimit.test.ts`
- Modify: `src/routes/search.ts` (only add the middleware)

## Contract
```ts
rateLimit(opts: { windowMs: number; max: number; keyPrefix: string }): RequestHandler
```

## Edge cases
- Redis down → let the request through and log a warning (fail-open)
- No IP on the request → use `req.socket.remoteAddress`, and if that is missing too, do not limit
- Clock: use the server's `Date.now()`, not client timestamps

## Acceptance criteria
- [ ] 60 requests in 60s pass; the 61st returns 429
- [ ] The `Retry-After` header carries seconds until reset
- [ ] With Redis down, the tests stay green
- [ ] `npm test` and `npm run lint` are green
- [ ] No file outside the "Files" list is modified

## Verification
Run `npm test -- rateLimit` and `npm run lint`.

GLM-5.2 runs a spec like that without trouble, probably in 25–40 turns. At about $0.014 of Go budget per turn, that is roughly half a dollar of that model's $60 monthly cap. You can do this more than a hundred times a month.

Pick the model for the need and the complexity

This is the habit that saves the most — money and frustration — and the one fewest people practice. The right question before you open any chat is not "which is the best model?" It is "what kind of work is this?"

I think about it in four levels.

Level 0 — Mechanical. Renaming variables, converting one format to another, generating boilerplate, translating a config file, writing repetitive tests from a pattern that already exists. There are no decisions. Use a high-cap model with a lot of requests: MiMo-V2.6-Flash, DeepSeek V4.1 Flash, or MiniMax M2.7. If the result is wrong, you notice immediately, and retrying spends little of that cap.

Level 1 — Guided implementation. There is a clear spec, and it has to become code that compiles, passes tests, and respects the project's conventions. It takes real competence, not product judgment. This is where GLM-5.2, Kimi K2.7 Code, MiniMax M3, and Qwen3.7 Plus live. It is 70% of real programming work, and it is exactly Go's ground.

Level 2 — Bounded design. Something has to be decided, but inside a known frame: how to model this table, which pattern to use for this case, how to structure this module. The bar goes up: Grok 4.7, Claude Sonnet 5, or a model of the same class on Zen. These are few turns, so even though they cost more, the hit on the bill is smaller than you fear. On Go, Grok 4.7 has a monthly cap of $15.

Level 3 — A decision with consequences. Architecture, a migration strategy, a technology choice, analysis of a confusing incident, anything where being wrong costs weeks. A frontier model, without hesitation: Claude Opus 5, Claude Fable 5, GPT 5.6 Sol, Gemini 3.1 Pro. And this is where a second opinion is worth it: ask the same question of two models from different families and compare. When they agree, you have a reasonable signal. When they diverge, you have found exactly the point where you had to think.

The rule that sums it up: the expensive model decides, the cheap model executes. And the corollary, which matters just as much: if you catch yourself using a frontier model on turn eighty of the same task, something went wrong in the design step. Go back to the spec.

There is a nuance worth stating, because it touches the philosophical part of this. The temptation to always use the best model is not economic. It is psychological: it feels safer. But that feeling of safety has a real price, and it is not only the bill. When you delegate everything to the most capable model, you stop distinguishing the decisions that matter from the ones that do not. Forcing yourself to classify the task before you pick the tool is, at bottom, an exercise in judgment. And judgment is the one thing you cannot outsource.

Ten practical tips for getting more out of Go

1. Set your default model to the workhorse, not the expensive one. In your opencode.json, leave opencode-go/glm-5.2 or opencode-go/kimi-k2.7-code as the main model. Switching up should be a conscious act, not the default state.

2. Use OpenCode's agent system to assign models by role. OpenCode lets you define different agents with different models. A plan agent with a capable model that only reads and proposes, and a build agent with a cheap model that executes. It is the workflow in this article, automated.

3. Write an AGENTS.md at the repo root. Conventions, test commands, folder structure, what not to touch. Everything that is in there is something the workhorse model does not have to guess, and guessing is what burns turns.

4. Use the cache. Most of the cost per turn is cache reads, not new tokens. Long sessions over the same context are much cheaper per turn than opening a new session for every small task. Group related work.

5. Watch the five-hour window, not the monthly one. That window is 20% of that model's cap: $12 if the cap is $60, and $3 if the cap is $15. If the session is going to be intense, start with a high-request model and save Grok 4.7 or Kimi K3 for when you get stuck.

6. Turn on "Use balance" only if you have Zen balance and you know why. It is the escape valve: when you exhaust Go, it keeps drawing on your pay-per-use balance instead of blocking. Very useful on a deadline, dangerous if you leave it on and forget.

7. When Go runs out, the free models remain, with different fine print. On Go, Space Bunny Free and LongCat 2.5 Preview Free are listed with no paid cap for a limited time, and Go's privacy table marks them at 0 days and not used for training. On Zen, several free models can use the data to improve the model: Big Pickle, MiMo free, Ling, and the free Nemotron endpoints, among others. Muse Spark Contributor, on Go and on Zen, trades price for permission to train. Do not send confidential code to a model that trains or that retains.

8. Check the privacy table before you put client code in. On Go, most models are listed at 0 days. Grok 4.7, Grok 4.6, GPT 6 Luna, and GPT 5.6 Luna retain data for 30 days and are not used for training. Muse Spark 1.3 and 1.2 Contributor do allow training. DeepSeek is at 0 days under an agreement the documentation treated as valid through October 31, 2026. If the code is under an NDA, that column matters more than the benchmark.

9. Keep Zen balance even if you use Go. Ten dollars of Go plus twenty of Zen balance gets you the best of both: execution that is unlimited in practice, and occasional access to frontier models when the decision justifies it. It is still less than a single premium subscription costs.

10. Measure. The OpenCode console shows your usage. Look at it once a week for a month and you will find that 80% of your spend comes from two or three kinds of task. Those are the ones to move to cheap models or, better, automate with a reusable spec.

Practical tools that fit this workflow

OpenCode (opencode.ai) is the base: TUI, CLI, server mode, IDE integration, MCP support, and Agent Skills. A one-line install, and it works on macOS, Linux, and Windows via WSL.

The /connect command inside the TUI is how you plug in Go or Zen: it asks for the API key you copy from the console at opencode.ai/auth, and /models shows the available catalog. In your config, the IDs carry the provider prefix: opencode-go/kimi-k3 for Go, opencode/gpt-5.6-sol for Zen.

Claude Code, Codex CLI, or Grok for the design phase. Any of them works. What matters is that the spec conversation happens somewhere other than the execution, even if only so you do not mix contexts.

A specs/ directory versioned in git. It sounds like little, and it is half the value of this method. Specs accumulate, get reused, become templates, and — this is the good part — become the best possible onboarding for any person or agent who arrives later.

MCP servers to give the agent real context: access to your database, your task tracker, your documentation. An agent with context needs fewer turns, and fewer turns means less budget spent.

Go's direct endpoints, if you want to build something on top. https://opencode.ai/zen/go/v1/chat/completions is compatible with the OpenAI SDK, and some models expose the Anthropic format at /v1/messages. You can use your Go subscription from your own scripts, not only from the TUI.

When Go is not the answer

For honesty's sake, three cases where I would not recommend it.

If your work is mostly level 3 — architecture consulting, research, analysis — Go will do little for you, because the value is in the models it does not include. Pay Zen per use and stop there.

If you are a team, Go does not scale: only one member per workspace can subscribe. For teams, the path is a Zen workspace with per-member spend limits and models enabled by role.

And if your code is strictly confidential, check the retention table model by model and consider BYOK with a provider you already have a contract with. Ten dollars is cheap, but not cheap enough to skip that conversation.

Closing

The conclusion I take from months on this workflow is not about OpenCode. It is about how we think about AI spend in general: we keep buying tools when what we should be designing are processes.

Ten dollars a month goes a long way if the execution arrives with clear instructions, and it goes a very short way if you use it as a substitute for thinking. The Go plan does not make you more productive by itself. It forces you — by design, through its limits — to decide what deserves an expensive model and what does not. And that discipline, which looks like a constraint, ends up being what makes the work come out better.

Define the spec with the best model you can afford. Execute it with the cheapest one that can carry it. Keep the spec in git. Repeat.

The plan, if you want it, is at OpenCode Go. It is the product page: the referral program has ended, and that link does not add balance.

Frequently asked questions

Does OpenCode Go replace Claude Code or Codex?

No, and it should not. Go is an execution plan with open models. Claude Code and Codex are still better for the design phase and for tasks that require judgment. The point of this article is to use them together, not to pick one.

Can I have Go and Zen at the same time?

Yes. Go covers execution inside its catalog. Go Plus, at $40, raises the quota on those same models. Zen covers what Go does not include. With "Use balance" on, requests continue against the Zen balance once you hit the Go cap.

How many real tasks fit in the $10 plan?

It depends on the model. GLM-5.2 estimates 4,300 requests a month. With tasks of 30 to 150 turns, that is between 30 and 100 medium tasks. DeepSeek V4 Flash estimates 65,000 a month on Go, and MiMo-V2.6-Flash estimates 150,400. Kimi K3 estimates 490. The plan does not behave the same on every model.

Why does Kimi K3 only estimate 490 requests a month on Go?

Because the cap is per model. Kimi K3 has a monthly cap of $15 on Go, not $60. Grok 4.7 and Grok 4.6 are also at $15 and estimate 845 requests a month. It is not a single 6x multiplier applied to the whole catalog. On Go Plus, Kimi K3's cap moves to $60 and the estimate rises to 1,960 requests a month.

What happens if I exhaust the limit?

You can keep using the free models in the catalog, or turn on "Use balance" to draw on your Zen balance. You can also wait for the five-hour window to reset.

Does OpenCode Go work for teams?

Not as a shared quota: only one member per workspace can subscribe to Go or to Go Plus. For teams, the published path is a Zen workspace with roles, per-member spend limits, and control over which models are enabled.

Is my data used for training?

In the Go table from September 29, 2026, most entries say no, with 0-day retention. Grok 4.7, Grok 4.6, GPT 6 Luna, and GPT 5.6 Luna retain data for 30 days and are listed as not used for training. Muse Spark Contributor does allow training. On Zen, several free models can use the data to improve the model, and OpenAI and Anthropic retain it for 30 days. The exception list is in each product's documentation.

Keep reading

If you only want the price, the limits, and my experience using OpenCode Go on its own, without the Zen or spec-strategy part: OpenCode Go: price, usage limits, and whether it is worth it in 2026.

If you want the rest of the landscape of AI providers for coding, beyond OpenCode: Why in 2026 you should no longer depend on a single AI provider for coding.

Sources

Go's catalog, caps, and estimated requests checked on September 29, 2026. Zen, auto-reload, and privacy exceptions checked on September 30, 2026. The cost-per-turn table is an estimate from August 12, 2026 and was not recalculated. The catalog changes; check the documentation before you pay.