OpenCode Go is a low-cost open-source coding model subscription launched by OpenCode, priced at 5 USD for the first month and 10 USD/month on renewal, promising stable access to open-source model APIs for a fixed monthly fee. It is currently in Beta, with models hosted in the US, EU, and Singapore. This article is a comprehensive analysis based on public information from official documentation, GitHub Issues, and the Discord community.

1. Product Overview and Key Data

Supported Models

The official team currently offers 10 open-source coding models:

Notes:

• The list is maintained dynamically and “may change as models are tested and added”
• Some models use the OpenAI-compatible format, others use the Anthropic format; the API pattern is not fully uniform
• Only one member per workspace may subscribe to the Go service

Key Parameters

2. Billing Rules and Usage Limits

The “Dollar Value” Calculation Logic

OpenCode Go’s limits are defined in “dollar value” rather than a fixed request count. Each request deducts credit based on that model’s actual API cost. The 10 USD subscription buys a “usage cap” of 60 USD/month, not a fixed number of requests.

The number of requests a given model can issue under the threefold limits varies enormously:

Key finding: Qwen3.5 Plus is the most generous, supporting roughly 10k requests within 5 hours; GLM-5.1 supports only about 880 — a difference of more than 11x. Under high-frequency use, the 5-hour limit is the first to be triggered.

Note that these are the “recommended estimates” given by the official team; the actual tokens in each request directly affect real consumption.

How the Three-Tier Limits Work

The 5-hour limit is the easiest to trigger. Taking Kimi K2.6 as an example, it can only make 1,150 calls per 5 hours, so a complex task involving 10 calls can only complete about 115 of them. If you use it intensively in a single session (such as automated refactoring or large-scale code review), you may hit this limit quickly.

When You Exceed the Limit

• Enable the “usage balance” option in the console to continue with Zen balance
• Or downgrade to free models
• Or wait for the limit to reset

3. Potential Issues and Limitations

The following issues and limitations are directly related to the OpenCode Go subscription service.

1. Inherent Risks of the Beta Stage

• The subscription is in Beta; features and limits may change at any time
• The model list is not fixed and “may change as models are tested and added”
• The official documentation explicitly states that “the list may change,” so there is a risk of models being removed or adjusted after you subscribe

2. Model API Compatibility Issues

Calling some models through the OpenCode Go API raises format compatibility issues:

• Kimi K2.5/K2.6 tool-calling errors: some users report a "reasoning_content is missing in assistant tool call message" error when calling Kimi models (GitHub #15197, #23646)
• Tool calls are more likely to fail when the thinking feature is enabled
• There are a fair number of related issues, affecting stability
• Note: these issues mainly appear when calling Kimi models through the OpenCode platform; calling the native Kimi API directly may not have this problem

3. Usage Constraint Limitations

4. Fit Assessment with AI Agent Tools

When frameworks like OpenClaw / Hermes Agent call models through the OpenCode Go API, two dimensions matter most: whether model capability and quota are sufficient.

Agent Core Needs vs. Actual Capability

Model Selection Advice

Recommended: Qwen3.5 Plus / Qwen3.6 Plus

• 16,000–50,500 requests per month, the most generous allowance
• Better Chinese-language support
• Tool calling is more stable than Kimi, with fewer related bug reports in community feedback
• Capability on complex multi-step tasks is slightly behind top commercial models, but sufficient for everyday coding tasks

Proceed with caution: Kimi K2.5/K2.6

• Tool calling suffers from the missing reasoning_content bug
• There are multiple related issues on GitHub (#15197, #20427, #20650)
• Fine for simple code generation, but risky as an Agent’s core model

Is the Quota Enough?

Using Qwen3.5 Plus as an example, under the 60 USD/month limit:

Key bottleneck: the 5-hour limit (12 USD). If you use it intensively in a single session (such as automated refactoring or large-scale code review), you may hit it quickly. Taking Kimi K2.6 as an example, with only 1,150 calls per 5 hours, a complex task involving 10 calls can only complete about 115 tasks per 5 hours.

Conclusion

5. Real Community User Feedback

The following feedback mainly comes from public discussions on GitHub Issues and the Discord community. Reddit, Hacker News, and other communities could not be fully searched.

Feedback Directly Related to the Go Subscription

Positive:

• Clear price advantage: many users think 10 USD/month for access to multiple open-source models is “great value,” especially for developers who want to try different models
• Usable model quality: Qwen3.5 Plus and MiniMax M2.5 perform stably on daily coding tasks
• Improved access stability: compared with calling each model’s native API directly, OpenCode Go’s unified interface reduces configuration complexity

Negative:

• Kimi model tool calling is unstable: many users report reasoning_content errors when using Kimi K2.5/K2.6, affecting automated workflows
• Limit quota feels low: some heavy users think the 60 USD/month cap is insufficient for high-frequency use, especially with premium models
• Beta uncertainty: the model list and limit quotas may change at any time

Who It’s For

Recommended for:

• Individual developers who want to try multiple open-source coding models at low cost
• Those using Qwen3.5 Plus for daily light-weight coding assistance
• Users who want a stable interface and don’t want to configure each model’s native API individually

Not recommended for:

• High-frequency, long-session AI Agent workflows
• Scenarios that depend on Kimi models for core tool calling
• Production environments with extremely high requirements on service stability

Statement: This article is compiled from public information from the official OpenCode public documentation and channels such as GitHub Issues. OpenCode Go is in Beta, and some information may change over time.