OpenCode Zen 与 Go 的区别：怎么选，能不能一起用

目录

• 先把三个总被叫混的名字分开
• 对照表：BYOK、Zen 和 Go
• 10 美元里实际装得下什么
• 把单轮成本摆出来
• 我的建议：把设计和执行分开

  • 为什么这在技术上成立
  • 具体流程，一步一步
  • 一份能执行的规格示例
• 按需要和复杂度选模型
• 把 Go 用足的十条实操
• 跟这套流程搭配的工具
• 什么时候 Go 不是答案
• 收束
• 常见问题

  • OpenCode Go 能替换 Claude Code 或 Codex 吗？
  • 可以同时有 Go 和 Zen 吗？
  • 10 美元的套餐里装得下多少真实任务？
  • 为什么 Kimi K3 在 Go 上每月只估算 490 次请求？
  • 用到顶了怎么办？
  • OpenCode Go 能给团队用吗？
  • 我的数据会被用来训练吗？
• 继续读
• 来源

有一种模式在技术创业者和小团队里反复出现：订 Claude，订 ChatGPT，订 Cursor，再在某个网关上零散充值，最后每个月烧掉 60 到 200 美元，却说不清花在哪。真去翻账单，几乎总是同一件事：钱不是花在想上，而是花在执行上。token 不是消耗在你决定架构的那段对话里，而是消耗在那三百轮里——智能体读文件、跑测试、改一个 import、再读一遍。

想和执行的这道缝，正是 OpenCode Go 打的地方。它是每月 10 美元的套餐，这几个月一直在改那些会用它的人的成本结构。这篇文章要看的是：这 10 美元里实际装得下什么，它和 OpenCode Zen 差在哪，以及为什么我最后的建议不是「都换成 Go」，而是更细的一句：用你付得起的最贵模型定规格，用扛得住任务的最便宜模型去执行。

先把三个总被叫混的名字分开

OpenCode 是一个开源的终端代码智能体，由 Anomaly 维护。它是工具本身：一个你在里面打字的 TUI，一个能读仓库、改文件、跑命令、把 diff 给你看的智能体。它免费，而且一直免费。

OpenCode Zen 是另一回事。它是一个模型网关，一层中间商。OpenCode 团队碰上一个真实问题之后才做了它：号称能编程的模型有几十个，真正能当智能体用的很少，而能用的那些，换一个供应商来提供，结果又差很远。同一个模型，在一家供应商那里很好，换一家就平庸，标签却一样。Zen 是对这件事的回应：他们测模型，和训练团队谈，和供应商谈怎么把模型正确地提供出来，给「模型加供应商」做基准，然后公布一份筛选过的名单。按用量付费，按每百万 token 标价，除了支付手续费，没有声明过的加价。

OpenCode Go 是订阅。从第一次扣款起每月 10 美元，访问一份开放模型目录，上限是 每个模型 的美元，不是套餐共用的一个口袋。Go Plus 每月 40 美元，用同一批模型，把这个上限提高。跳跃不是同一个倍数：在 2026 年 9 月 29 日的文档里，GLM-5.3-Flash 从 60 美元到 180 美元，Kimi K2.6 从 60 美元到 240 美元。它不是无限套餐。5 美元的第一个月已经没有了，推荐计划也结束了。

更新于2026年9月30日。

这三个名字仍然彼此独立。Go Plus 是同一份 Go 目录的第二个价格，不是第四个产品。你可以用自己的 OpenAI 或 Anthropic 密钥跑 OpenCode，一分钱也不付给 Zen 或 Go。你也可以在 OpenCode 以外的智能体里用 Zen。你还可以同时有 Go 和 Zen。这正是我下面要建议的。

对照表：BYOK、Zen 和 Go

	OpenCode BYOK	OpenCode Zen	OpenCode Go
计费	免费（钱付给供应商）	按用量，预付余额	固定月费
价格	$0，外加你在 API 上的花费	按消耗的 token	从第一次扣款起 $10/月。Go Plus：$40/月
目录	你接得上的任何供应商	文档上的公开名单：Claude、GPT、Gemini、Grok、Qwen、DeepSeek、GLM、Kimi、MiniMax，以及限时免费模型	Go 的目录。含 Grok 4.7 和 4.6、GLM-5.3 和 GLM-5.3-Flash、GPT 6 Luna 和 GPT 5.6 Luna、Kimi、Qwen、DeepSeek、MiniMax、MiMo 等。Go Plus 用同一份名单
前沿模型	有，只要你付 API	有。Zen 的名单里有 Claude、GPT、Gemini 和 Grok，也有开放模型	不含 Claude、GPT Sol 和 Gemini Pro。含 Grok 4.7、Grok 4.6、GPT 6 Luna 和 GPT 5.6 Luna，在 Go 上月度上限为 15 美元
限额	你的供应商的限额	你的余额；如果配置了，还有 workspace 或成员的月度上限	按模型：5 小时 = 该模型上限的 20%，一周 = 50%，一个月 = 100%。在 Go 上，这个上限按模型是 15、30 或 60 美元
自动充值	不适用	余额低于 $5 就充 $20。金额可改，也可以关掉。月度上限挡不住这次充值	不适用，是固定月费
用到顶之后	不适用	充值，或者停	还能用免费模型；打开 Use balance 就转到你的 Zen 余额
团队	手动	带角色的 workspace，按成员设上限，管理员可以关掉某些模型。管理功能在免费 beta	每个 workspace 只能有一名成员订阅 Go 或 Go Plus
数据留存	你的供应商的政策	供应商宣称零留存、不用于训练。例外：部分免费模型可能用数据改进模型；OpenAI 和 Anthropic（30 天）；Muse Spark Contributor；以及文档里列出的其他项	多数 0 天。Grok 4.7、Grok 4.6、GPT 6 Luna、GPT 5.6 Luna 留存 30 天，且不用于训练。Muse Spark Contributor 会训练
自带密钥	这就是默认	可以。Zen 里能用你自己的 OpenAI 或 Anthropic 密钥。那些 token 由供应商收，不由 Zen 收	不行
适合谁	已经有合同或额度的人	需要 Go 没有的模型，并且要精细控制开支的人	在 Go 的目录里执行量大的人。那份额度不够，就看 Go Plus

这张表的快读：Zen 是按市价的完整目录，Go 是便宜、但有天花板的一个子集。它们不抢同一件事，是互补的。

10 美元里实际装得下什么

Go 不给你一笔共用的 token。每个模型有一个 月度美元上限。在这个上限上，5 小时窗口是 20%，一周是 50%，一个月是 100%。

只有上限 60 美元的模型，才会得到每五小时 12 美元、每周 30 美元、每月 60 美元。上限 30 美元的模型是 6、15 和 30。上限 15 美元的模型是 3、7.50 和 15。「付 10 美元，给你大约 60」描述的是第一组，不是整份套餐。

2026 年 9 月 29 日的文档里，Go 的上限是这样分的：

• 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 和 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。
• 没有付费上限，限时： Space Bunny Free、LongCat 2.5 Preview Free。

40 美元的 Go Plus 不会把所有东西乘以同一个系数。GLM-5.3-Flash 到 180 美元，Kimi K2.6 到 240 美元，DeepSeek V4.1 Flash 到 120 美元，Kimi K3 到 60 美元，Grok 4.7 到 60 美元。

下一张表抄的是 Go 的估算请求。OpenCode 按每个模型观察到的使用模式来算。我没有重算。

模型	Go 上限	每 5 小时请求	每周请求	每月请求
Muse Spark 1.3 / 1.2 Contributor	60	45,300	113,300	226,600
MiMo-V2.6-Flash 和 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 和 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 和 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 估算每月 226,600 次请求。Kimi K3 估算 490 次。这是同一份 10 美元套餐。谁要是把 Go 当成「永远用名字最大的那个」的自助餐，第一天就会把 5 小时窗口填满。上限 15 美元的模型，那个窗口是 3 美元，不是 12 美元。

在 Go Plus 上，同一个 GLM-5.3-Flash 估算为每 5 小时 18,960 次、每周 47,370 次、每月 94,740 次。Kimi K3 估算为 440、1,000 和 1,960。Grok 4.7 估算为 676、1,692 和 3,380。其余的表在 Go 文档。

一件真正的智能体任务——加上认证、写测试、更新文档——不是一次请求。它是 30 到 150 轮。按这个尺子，GLM-5.2 每月 4,300 次请求，是一个月 30 到 100 件中等任务。一个人，够。四个人挤在同一个账号里，不够：每个 workspace 只能有一名成员订阅 Go 或 Go Plus。

如果只要 Go 的价格和限额，不要 Zen，也不要这套策略，我有一篇单独的评测：OpenCode Go用量上限：每月10美元值不值。

把单轮成本摆出来

要看清我建议的策略为什么成立，可以算一个典型智能体回合在每个模型上花多少。我用一个固定、接近真实的画像：大约 800 个新输入 token，60,000 个从缓存读出的 token（仓库上下文，这才是开支的大头），250 个输出 token。然后套上 Zen 的公开价格：

模型	估算的每轮成本	每 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

这是我自己在 2026 年 8 月 12 日做的估算，用的是上面的画像和当天的 Zen 价格。2026 年 9 月 30 日没有重算：目录里已经有更新的模型，价格也在动。它用来看数量级，不用来做这个月的预算。表里的 Grok 4.5 是那天的标价样本，不是当前 Go 目录里的模型。

一眼能看见的是，前沿模型和干活的模型之间不是差 30%，也不是贵一倍。同一轮里，Claude Fable 5 比 GPT 5.6 Luna 或 DeepSeek V4 Flash 贵四十多倍。进了 Go，这条缝还要更宽。于是有个不舒服的问题：那 150 轮「读文件、打 diff、跑测试」，真的需要世界上最好的模型吗？

几乎不需要。世界上最好的模型要做的，是决定建什么、怎么建。那个决定是五到十轮，不是一百五十轮。

我的建议：把设计和执行分开

这是文章的核心。试过不少次之后，我的流程是：用 Claude 或 Grok 定规格，用 OpenCode Go 执行规格。

我个人主要用 Claude——架构决定用 Opus 5，比较常规的规格用 Sonnet 5。我想要一个偏见不同的第二意见，或者需要模型直接、不迎合的时候，用 Grok。Codex 在这一段同样好用，如果你本来就用它。要点不是品牌，是角色。

逻辑和任何认真的敏捷方法一样：细化和执行是不同的活动，成本和风险也不一样。没有人让架构师去写单元测试，也没有人让初级工程师决定数据模型。两件事塞进同一次前沿模型对话里，你就是按架构师的价格，为执行工作付好几个小时。

为什么这在技术上成立

执行模型不需要创意。它需要听话，也需要能干。规格如果是好的——写明动哪些文件、守什么契约、盖住哪些边界、成功怎么验证——任务就不再是「把这个设计出来」，而是「把这个写成代码并验证」。GLM-5.2 或 Kimi K2.7 Code 做这个完全够。

规格差的时候，执行模型就开始即兴。然后人们得出「开放模型不行」。不是不行：你让它干两份工，只按一份付了钱。

具体流程，一步一步

1. 用 Claude 或 Grok 做设计对话。 先不写代码。讲问题、业务上下文和约束。明确要求它先提问，再提议。这里花掉一个贵模型的 5 到 15 轮，而这是整个过程里最值的轮次。

2. 把规格生成成文件。 要 markdown，最少包括这些：目标、上下文（今天已经有什么）、明确的范围、明确的不做、要动的文件、契约和接口、边界情况、可验证的验收标准、验证计划。存进仓库，例如 specs/2026-08-12-auth-jwt.md。它活在 git 里，这是要点的一部分：既是文档，也是追溯。

3. 拆成原子任务。 规格里的每项任务，都应该是智能体能做完、并且能不含糊地验证的。如果做到一半还要做一个产品决定，它就还不能执行，回到第 1 步。

4. 用 OpenCode Go 执行。 在仓库里打开 OpenCode，指到这份规格，让干活的模型去做。我的默认分配是：主要实现用 GLM-5.2 或 Kimi K2.7 Code；机械的活（重命名、迁语法、生成重复测试、改 import）用 MiniMax M3 或 DeepSeek V4 Flash。

5. 只有必要时，才用贵的模型复查。 测试过了、diff 读得懂，就不必。有地方不对味，把 diff 交给 Claude 或 Grok，问一个具体问题。那是三轮，不是三十轮。

一份能执行的规格示例

# Spec: 公开搜索端点的速率限制

## 目标
避免 `GET /api/search` 被滥用。这个端点目前没有保护。

## 上下文
- Express 4 + Redis 已经在 `src/lib/redis.ts`
- 认证中间件在 `src/middleware/auth.ts`（要模仿的模式）
- 目前还没有中间件测试

## 范围
- 可复用的 `rateLimit` 中间件，按路由配置
- 只应用到 `GET /api/search`
- Redis 滑动窗口，每 IP 每 60 秒 60 次请求
- 返回 429，并带 `Retry-After` 头

## 不做
- 按已登录用户限流（第二阶段）
- 指标面板
- 改搜索算法

## 文件
- 新建：`src/middleware/rateLimit.ts`
- 新建：`src/middleware/__tests__/rateLimit.test.ts`
- 修改：`src/routes/search.ts`（只加中间件）

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

## 边界情况
- Redis 挂了 → 放行请求并记录 warning（fail-open）
- 请求里没有 IP → 用 `req.socket.remoteAddress`，还是没有就不限流
- 时钟：用服务器的 `Date.now()`，不用客户端时间戳

## 验收标准
- [ ] 60 秒内 60 次请求通过；第 61 次返回 429
- [ ] `Retry-After` 头给出距离重置的秒数
- [ ] Redis 挂了时测试仍然是绿的
- [ ] `npm test` 和 `npm run lint` 为绿
- [ ] 「文件」清单之外没有任何文件被修改

## 验证
运行 `npm test -- rateLimit` 和 `npm run lint`。

这样一份规格，GLM-5.2 执行起来不会吃力，大概 25 到 40 轮。按每轮大约 0.014 美元的 Go 预算算，这是你那 60 美元月度额度里的半美元左右。这样的规格一个月可以做一百多次。

按需要和复杂度选模型

这是最省钱、也最省挫折的习惯，却最少有人练。打开任何对话之前，正确的问题不是「哪个模型最好」，而是「这是哪一类工作」。

我把它分成四级。

0 级——机械。 重命名变量，把一种格式转成另一种，生成样板，翻译配置文件，按已经定下的模式写重复测试。没有决定。用上限高、请求次数多的模型：MiMo-V2.6-Flash、DeepSeek V4.1 Flash 或 MiniMax M2.7。结果错了，马上能看出来，重试也只花掉那个上限里的一点点。

1 级——有规格的实现。 规格清楚，要把它变成能编译、能过测试、守项目惯例的代码。需要真本事，但不需要产品判断。这里是 GLM-5.2、Kimi K2.7 Code、MiniMax M3、Qwen3.7 Plus。这是真实编程工作的 70%，也正是 Go 的地盘。

2 级——有边界的设计。 要做决定，但框是已知的：这张表怎么建模，这个情况用什么模式，这个模块怎么拆。这里门槛升高：Grok 4.7、Claude Sonnet 5，或 Zen 里同一档的模型。轮次少，所以即使更贵，对账单的影响也比你怕的小。在 Go 上，Grok 4.7 的月度上限是 15 美元。

3 级——有后果的决定。 架构、迁移策略、技术选型、一团理不清的事故、任何选错就要花掉几周的事。用前沿模型，不要犹豫：Claude Opus 5、Claude Fable 5、GPT 5.6 Sol、Gemini 3.1 Pro。这里值得奢侈地要一个第二意见：把同一个问题交给两个不同家族的模型，再比较。两边一致，你有一个还算像样的信号；两边分叉，你正好找到了必须自己想的那一点。

把这一切收成一句：贵的模型做决定，便宜的模型去执行。 推论同样重要：如果你发现自己在同一件任务的第八十轮还在用前沿模型，设计那一步出了问题。回到规格。

有一层值得说清楚，因为它碰到这件事的哲学一面。总想用最好的模型，不是经济问题，是心理问题：那样感觉更安全。但这种安全感有真实的价钱，而且不只是账单。你把一切都交给能力最强的模型，就不再分得清哪些决定重要、哪些不重要。强迫自己在选工具之前先给任务分类，说到底是在练判断。判断是唯一不能外包的东西。

把 Go 用足的十条实操

1. 默认模型设成干活的，不是贵的。 在 opencode.json 里，把 opencode-go/glm-5.2 或 opencode-go/kimi-k2.7-code 设成主模型。往上换必须是有意识的动作，不是默认状态。

2. 用 OpenCode 的智能体系统按角色分配模型。 OpenCode 可以定义不同的智能体，各用各的模型。一个 plan 智能体用能干的模型，只读、只提议；一个 build 智能体用便宜的模型去执行。这就是本文的流程，只是自动化了。

3. 在仓库根目录写一份 AGENTS.md。 惯例、测试命令、目录结构、什么不能动。写在那里的每一条，都是干活的模型不用去猜的一条。猜，才是消耗轮次的东西。

4. 用上缓存。 每轮成本的大头是读缓存，不是新 token。同一上下文上的长会话，每轮比「每个小任务开一个新会话」便宜得多。把相关的工作捆在一起。

5. 盯五小时窗口，别只盯月度。 那个窗口是该模型上限的 20%：上限 60 就是 12 美元，上限 15 就是 3 美元。会话会很密的话，先用请求次数多的模型，Grok 4.7 或 Kimi K3 留到卡住的时候。

6. 只有当你有 Zen 余额、并且知道为什么，才打开 Use balance。 它是逃生阀：Go 用完之后，继续走按用量付费的余额，而不是停住。截止日前很有用。开着又忘了，就危险。

7. Go 用完之后还有免费模型，但小字不一样。 在 Go 上，Space Bunny Free 和 LongCat 2.5 Preview Free 限时没有付费上限，Go 的隐私表把它们标成 0 天、不训练。在 Zen 上，有几个免费模型可能用数据改进模型：Big Pickle、MiMo 的免费版、Ling，以及 Nemotron 的免费端点，等等。Muse Spark Contributor 在 Go 和 Zen 上都是用价格换训练许可。不要把机密代码送给会训练或会留存的模型。

8. 放进客户代码之前，先看隐私表。 在 Go 上，多数标的是 0 天。Grok 4.7、Grok 4.6、GPT 6 Luna 和 GPT 5.6 Luna 留存 30 天。Muse Spark 1.3 和 1.2 Contributor 允许训练。DeepSeek 是 0 天，文档把协议视为有效到 2026 年 10 月 31 日。代码在 NDA 下的话，这一列比基准测试更重要。

9. 即使用 Go，也给 Zen 留一点余额。 10 美元的 Go，加上 20 美元的 Zen 余额，两边都占：目录里的执行在实践里很少先被卡住，决定需要前沿模型时也能点到。加起来仍少于一份高端订阅。

10. 去量。 OpenCode 的控制台显示你的消耗。一个月里每周看一次，你会发现 80% 的开支来自两三类任务。那些才是该挪到便宜模型上的，或者更好，用一份可复用的规格把它自动化。

跟这套流程搭配的工具

OpenCode（opencode.ai）是底座：TUI、CLI、服务器模式、IDE 集成、MCP 和 Agent Skills。一行安装，macOS、Linux 都能用，Windows 走 WSL。

TUI 里的 /connect 是你接上 Go 或 Zen 的方式：它要你从 opencode.ai/auth 的控制台复制 API key。/models 看可用目录。配置里的 ID 带供应商前缀：Go 是 opencode-go/kimi-k3，Zen 是 opencode/gpt-5.6-sol。

Claude Code、Codex CLI 或 Grok 用来做设计。哪个都行。要紧的是，规格对话发生在执行以外的地方，哪怕只是为了不把上下文搅在一起。

一个放进 git 的 specs/ 目录。 听起来少，却是这套方法一半的价值。规格会积起来，会被复用，会变成模板，而且——这是好的部分——会变成后来任何人或任何智能体最好的入职材料。

MCP 服务器 用来给智能体真实上下文：你的数据库、任务管理、文档。有上下文的智能体需要的轮次更少，轮次少就是少花预算。

Go 的直接端点，如果你想在上面再搭东西。https://opencode.ai/zen/go/v1/chat/completions 兼容 OpenAI 的 SDK，有些模型在 /v1/messages 上提供 Anthropic 格式。你的 Go 订阅可以从自己的脚本里用，不只是从 TUI。

什么时候 Go 不是答案

说老实话，有三种情况我不会推荐它。

如果你的工作主要是 3 级——架构咨询、研究、分析——Go 帮不上多少，因为价值在它没有的那些模型上。按用量付 Zen 就行。

如果你们是一个团队，Go 扩不上去：每个 workspace 只能有一名成员订阅。团队的路是一个 Zen workspace，按成员设开支上限，再按角色打开模型。

如果你的代码在严格意义上是机密，就按模型核对留存表，并考虑 BYOK，找一家你已经有合同的供应商。10 美元是便宜，但没有便宜到可以跳过那次谈话。

收束

用了这套流程几个月之后，我带走的结论不是关于 OpenCode 的。它是关于我们怎么想 AI 开支：我们还在买工具，而该设计的是流程。

指令清楚的时候，每月 10 美元装得下很多；拿它代替思考，就装不下什么。Go 不会自己让你更有生产力。它用限额逼你决定，什么值得一个贵模型，什么不值得。这套看起来像限制的纪律，最后会让工作做得更好。

用你付得起的最好模型定规格。用扛得住的最便宜模型执行。把规格放进 git。再来一遍。

套餐在 OpenCode Go。那是产品页：推荐计划已经结束，这个链接不会入账余额。

常见问题

OpenCode Go 能替换 Claude Code 或 Codex 吗？

不能，也不该。Go 是用开放模型做执行的套餐。Claude Code 和 Codex 仍然更适合设计，以及需要判断的任务。这篇文章的安排是一起用，不是二选一。

可以同时有 Go 和 Zen 吗？

可以。Go 覆盖它目录里的执行。40 美元的 Go Plus 提高的是同一批模型的额度。Zen 覆盖 Go 没有的。打开 Use balance 之后，Go 到顶时请求会继续走 Zen 余额。

10 美元的套餐里装得下多少真实任务？

看模型。GLM-5.2 估算每月 4,300 次请求。任务如果是 30 到 150 轮，那就是 30 到 100 件中等任务。DeepSeek V4 Flash 在 Go 上估算每月 65,000 次，MiMo-V2.6-Flash 估算 150,400 次。Kimi K3 估算 490 次。套餐在每个模型上表现不一样。

为什么 Kimi K3 在 Go 上每月只估算 490 次请求？

因为上限按模型算。Kimi K3 在 Go 上的月度上限是 15 美元，不是 60。Grok 4.7 和 Grok 4.6 也是 15 美元，估算每月 845 次请求。不是把一个 6 倍乘到整个目录上。在 Go Plus 上，Kimi K3 的上限变成 60 美元，估算升到每月 1,960 次请求。

用到顶了怎么办？

可以继续用目录里的免费模型，或者打开 Use balance，去花 Zen 余额。也可以等五小时窗口重置。

OpenCode Go 能给团队用吗？

不能当成共享额度：每个 workspace 只能有一名成员订阅 Go 或 Go Plus。团队的公开路径是一个 Zen workspace，带角色、按成员的开支上限，以及控制打开哪些模型。

我的数据会被用来训练吗？

在 2026 年 9 月 29 日的 Go 表上，多数说不会，留存 0 天。Grok 4.7、Grok 4.6、GPT 6 Luna 和 GPT 5.6 Luna 留存 30 天，并标为不用于训练。Muse Spark Contributor 允许训练。在 Zen 上，有几个免费模型可能用数据改进模型，OpenAI 和 Anthropic 留存 30 天。例外名单在各自产品的文档里。

继续读

如果只要价格、限额，以及我一个人用 OpenCode Go 的体验，不要 Zen，也不要规格策略：OpenCode Go用量上限：每月10美元值不值。

如果关心的是 OpenCode 以外、编程用 AI 供应商的其余局面：为什么 2026 年你不该再依赖单一 AI 供应商来编程。

来源

• OpenCode Go — 官方文档
• OpenCode Zen — 官方文档
• OpenCode Go — 产品页
• OpenCode Zen — 产品页
• OpenCode — 总文档

Go 的目录、上限和估算请求于 2026 年 9 月 29 日核对。Zen、自动充值和隐私例外于 2026 年 9 月 30 日核对。每轮成本表是 2026 年 8 月 12 日的估算，没有重算。目录会变，付款前先看文档。