Skip to content

docs: Go usage limits are shared across all models, not per-model as documented #60311

Open

Description

@andrewpoker1805

Summary

The Go documentation states that usage limits are enforced per model, but in practice the 5-hour (rolling), weekly, and monthly limits are a single pool shared across all paid models. Exhausting the rolling limit on one model blocks every other paid model, even models that have barely been used and are far below their documented per-model limit.

Environment

  • opencode version: 2.2.1 (desktop app, latest channel)
  • OS: Windows 10 (Windows_NT 10.0.19045, win32 x64)
  • Terminal: xterm-256color (OpenCode desktop app)
  • Shell: C:\Windows\system32\cmd.exe
  • Install/channel: latest (desktop app)
  • Active plugins: none configured
  • Plan: Go ($10/month), Personal workspace (single member)

Reproduction

  1. Subscribe to OpenCode Go on a Personal workspace.
  2. Use a single paid model until the rolling (5-hour) usage limit is reached.
  3. Switch to a different paid model that has not been used recently and send any request.
  4. Observe that it is also rejected with "Go usage limit exceeded".
  5. Open Console → Go: only three workspace-wide counters are shown (Rolling, Weekly, Monthly), with no per-model breakdown.
  6. Switch to a free model (e.g. Beam Free): it still works.

Expected Behavior

Per the docs (https://opencode.ai/v2/docs/console/go, "Usage limits"):

"Each model has the following usage limits: 5-hour — 20% of the monthly limit; weekly — 50%; and monthly — 100%."

The pricing tables list a separate "Monthly limit" per model (e.g. GLM-5.3 $15, Claude Haiku 5.5 $15, DeepSeek V4.1 Flash $80), and the "Estimated requests" tables give per-model "Requests per 5 hours / week / month". Reaching the 5-hour limit on one model should not affect the others.

Actual Behavior

The Console Go page shows a single set of counters for the whole plan, with no per-model split:

  • Rolling usage: 100% used (resets in ~2.5h), with a "Go limit hit" badge and the message "Rolling limit reached. Go resumes in 2h 37m."
  • Weekly usage: 96% used
  • Monthly usage: 48% used

Every paid model then returns "Go usage limit exceeded", including models not used in the last 5 hours. Only free models (documented as "Unlimited") keep working.

Usage for Oct 19–29 (Console → Activity → Usage) shows no individual model anywhere near its documented limit, yet the shared rolling limit is fully exhausted:

Model Requests Cost
glm-5.3 163 $5.25 (documented monthly limit: $15)
claude-haiku-5-5 329 $1.71 (limit: $15)
deepseek-v4.1-flash 601 $1.07 (limit: $80)
grok-4.7 6 $0.14
glm-5.3-flash 32 $0.10
qwen3.8-max 3 $0.08
deepseek-v4-pro 6 $0.06
longcat-2.0 20 $0.04
qwen3.8-flash 23 $0.03
gpt-6-luna 49 $0.01
kimi-k3 1 <$0.01
DeepSeek V4.1 Flash (free) 28 $0.00
beam-free 59 $0.00
Total 1,320 $8.50

Additional Context

  • Reproducible consistently: any paid model is blocked the moment the shared rolling counter hits 100%.
  • The Activity page also shows "Most used this period" as percentages of one shared pool (DeepSeek V4.1 Flash 47%, Claude Haiku 5.5 25%, GLM-5.3 13%), which only makes sense if the allowance is shared.
  • Either the documentation should be corrected to describe a shared allowance, or the enforcement should match the documented per-model limits. As written, the per-model "Monthly limit" column and the per-model request estimates are misleading.

Activity

  1. opencodejr commented on Oct 29, 2026

    @opencodejr

    Thanks for the detailed write-up and the usage table. You're right: the docs and the actual behaviour don't match.

    I checked the Go docs on the latest dev (1eea2d4). The Usage limits section still says "Each model has the following usage limits: 5-hour — 20%… weekly — 50%… monthly — 100%". The pricing tables also list a "Monthly limit" for each model, and the "Estimated requests" tables give figures for each model. Nothing on the page says the allowance is shared.

    The Go service actually uses one Rolling/Weekly/Monthly allowance for all paid models. Support confirmed this in #54875: each model's listed monthly limit sets how heavily its usage counts against that shared pool, so $1 on a model with a $15 limit uses up as much as $4 on a model with a $60 limit. That matches your Console: when any of the three gauges hits 100%, every paid model is blocked, and free models keep working. I couldn't trigger the limit myself, because that needs a real Go subscription.

    The script below checks the docs text in a checkout of the repo. I've passed this on to the maintainers as a docs fix.

    Earlier reports of the same confusion, all closed: #54263 (the same docs request), #49186, #54875, #49014, #51550 and #52783.

    Reproduction script (check-go-docs.sh)
    #!/bin/sh
    # Shows that the Go docs describe usage limits as per-model, while the Go service
    # enforces one shared, weighted Rolling/Weekly/Monthly allowance across all paid models
    # (confirmed by support, quoted in #54875; the Console Go page shows only three
    # workspace-wide gauges). Run from an opencode checkout (dev branch).
    set -e
    f=services/www/src/docs/content/console/go.mdx
    git rev-parse HEAD
    echo "--- $f: Usage limits ---"
    grep -n "Each model has the following usage limits" "$f"
    grep -n "Each model's monthly limit below determines" "$f"
    grep -n "Monthly limit" "$f" | head -3
    echo "--- any mention that the allowance is shared? ---"
    grep -n -i "shared\|one allowance\|single allowance\|across all models" "$f" || echo "(none)"

    Run it: sh check-go-docs.sh

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions