GOAT Plan vs OpenCode Go — Common Models Comparison

Method: For each common model, we feed OpenCode Go's per-model token assumptions (input / cache-read / output per request) into both platforms' per-token pricing + monthly allowance, using CommandCode's calculator formula:

costPerRequest = (inTok/1e6) * inPrice + (outTok/1e6) * outPrice + (cacheTok/1e6) * cacheReadPrice
requests/month = monthlyAllowance / costPerRequest

This gives apples-to-apples request counts. All prices are per 1M tokens, USD, precise (no rounding).

Sources

Platform	Pricing page	Plan details	Token assumptions	Per-token rates & allowances
Command Code GOAT	commandcode.ai/pricing	docs/plans/goat	docs/resources/pricing-limits#usage-estimates	Same page -- per-model credit allowances + per-token rates
OpenCode Go	opencode.ai/pricing	docs/en/go (English)	docs/en/go -- Usage limits	Same page -- "prices per 1M tokens" table + "Usage" column

Calculator source

CommandCode's usage calculator is a client-side React component embedded in the pricing-limits page. The formula was extracted from the page's JavaScript bundle:

• Source URL: https://commandcode.ai/docs/_next/static/chunks/app/resources/pricing-limits/page-6886473b13679efd.js
• Local copy: [calculator-source.js](./calculator-source.js) in this directory
• Formula (de-minified):// Default assumptions (overridden per-model on OpenCode's page) // { inputTokens: 800, outputTokens: 180, cacheReadTokens: 50000 } ​ // cost per single request function costPerRequest(modelPricing, tokAssumptions) {  return tokAssumptions.in / 1e6 * modelPricing.in +         tokAssumptions.out / 1e6 * modelPricing.out +         tokAssumptions.cache / 1e6 * modelPricing.cacheRead; } ​ // number of requests per month function requests(monthlyAllowance, modelPricing, tokAssumptions) {  const cpr = costPerRequest(modelPricing, tokAssumptions);  return cpr > 0 ? monthlyAllowance / cpr : 0; }

Replication script

The exact numbers in this comparison were generated with:

• requests-calculation.js -- feed OpenCode's per-model token assumptions into both platforms' pricing + allowances

​

cd ~/workspace/models_comparison
node requests-calculation.js

Plan-Level Summary

Feature	Command Code GOAT	OpenCode Go
Price	$10/mo + processing fee	$10/mo ($5 first month)
Total monthly value	$70 credits (7x multiplier)	$60 usage (6x multiplier)
5-hour rolling limit	$14	$12
Weekly rolling limit	$35	$30
Monthly limit	$70	$60
Beyond limits	Buy pay-as-you-go credits (roll over, never expire)	"Use balance" -- draw from ZEN balance, then pay-as-you-go
Deals / discounts	Baked-in deals on MiMo (98-99%), MiniMax M3 (50%), Gemini 3.7 Flash (50%)	No explicit deals; prices already reflect negotiated rates
Data retention	0-30 days (model-dependent)	0-30 days (model-dependent)
Cache read price	Higher for some Qwen models & Grok 4.5	Lower for Grok 4.5, Qwen 3.6/3.7 Plus

Per-Model Comparison (16 Common Models)

Token assumptions for each model are taken from OpenCode Go's "Usage limits" section (English docs). These per-model assumptions -- not the calculator's generic defaults -- are used for both platforms to ensure a fair comparison.

Gap % = (|Go req - GOAT req| / max(Go req, GOAT req)) x 100. Shows the relative magnitude of the winner's advantage.

Model	Go price (in/out/cache)	GOAT price (in/out/cache)	Go allow	GOAT allow	Go req/mo	GOAT req/mo	Gap %	Winner
DeepSeek V4 Flash	$0.22/$0.66/$0.007	$0.22/$0.66/$0.007	$15	$60	18,894	75,576	75.0%	GOAT
DeepSeek V4 Pro	$0.66/$1.98/$0.022	$0.66/$1.98/$0.022	$15	$20	5,221	6,961	25.0%	GOAT
GLM-5.2	$1.40/$4.40/$0.26	$1.40/$4.40/$0.26	$60	$70	3,958	4,617	14.3%	GOAT
GLM-5.3	$1.40/$4.40/$0.26	$1.40/$4.40/$0.26	$15	$20	989	1,319	25.0%	GOAT
GPT-5.6 Luna	$0.20/$1.20/$0.02	$0.20/$1.20/$0.02	$15	$20	10,246	13,661	25.0%	GOAT
Grok 4.5	$2.00/$6.00/$0.30	$2.00/$6.00/$0.50	$15	$20	601	509	15.2%	Go
Hy3	$0.14/$0.58/$0.035	$0.14/$0.58/$0.035	$60	$70	21,507	25,091	14.3%	GOAT
Kimi K2.7 Code	$0.95/$4.00/$0.19	$0.95/$4.00/$0.19	$60	$60	4,968	4,968	0.0%	tie
Kimi K3	$3.00/$15.00/$0.30	$3.00/$15.00/$0.30	$15	$20	490	654	25.0%	GOAT
MiMo V2.5	$0.14/$0.28/$0.0028	$0.14/$0.28/$0.0028	$60	$30	150,376	75,188	50.0%	Go
MiMo V2.5 Pro	$0.435/$0.87/$0.003625	$0.435/$0.87/$0.0036	$15	$20	16,291	21,772	25.2%	GOAT
MiniMax M3	$0.30/$1.20/$0.06	$0.30/$1.20/$0.06	$60	$47	16,038	12,563	21.7%	Go
Qwen 3.6 Plus	$0.50/$3.00/$0.05	$0.50/$3.00/$0.10	$60	$33	16,349	5,061	69.0%	Go
Qwen 3.7 Max	$2.50/$7.50/$0.50	$2.50/$7.50/$0.50	$60	$33	1,688	928	45.0%	Go
Qwen 3.7 Plus	$0.40/$1.60/$0.04	$0.40/$1.60/$0.08	$60	$33	21,552	6,517	69.8%	Go
Qwen 3.8 Max	$2.00/$6.00/$0.25	$2.00/$6.00/$0.25	$15	$20	809	1,079	25.0%	GOAT

Summary: GOAT wins 9 models, Go wins 6, 1 tie.

Key Takeaways

GOAT wins (9 models)

Mostly on premium models where GOAT's $20 allowance beats Go's $15, and on boosted models where GOAT negotiates bigger allowances:

• DeepSeek V4 Flash: 4x allowance ($60 vs $15) -- 75% gap (75K vs 19K req)
• GLM-5.2: boosted to $70 -- 14.3% gap (4.6K vs 4.0K)
• Hy3: boosted to $70 -- 14.3% gap (25K vs 21.5K)
• GPT-5.6 Luna, Kimi K3, Qwen 3.8 Max: $20 vs $15 -- ~25% gap
• DeepSeek V4 Pro, MiMo V2.5 Pro: $20 vs $15 -- ~25% gap

Go wins (6 models)

Mostly on mid-tier / cheap models where Go's $60 allowance crushes GOAT's $33-$47, and on Grok 4.5 where Go's cheaper cache-read price ($0.30 vs $0.50) compounds:

• Qwen 3.7 Plus / Qwen 3.6 Plus: Go's $60 + 2x cheaper cache reads -- ~70% gap
• Qwen 3.7 Max: Go's $60 -- 45% gap (1.7K vs 928)
• MiMo V2.5: Go's $60 vs GOAT's $30 -- 50% gap (150K vs 75K)
• MiniMax M3: Go's $60 vs GOAT's $47 -- 21.7% gap
• Grok 4.5: Go's $15 BUT 40% cheaper cache reads -- 15.2% gap (601 vs 509)

Tie

• Kimi K2.7 Code: Identical pricing and $60 allowance on both -- exactly 4,968 requests, 0% gap

Cache-read price differences

GOAT charges more for cache reads on 3 of 16 common models:

Model	Go cache-read/1M	GOAT cache-read/1M	Impact
Grok 4.5	$0.30	$0.50	Go wins despite lower allowance
Qwen 3.7 Plus	$0.04	$0.08	2x more expensive on GOAT
Qwen 3.6 Plus	$0.05	$0.10	2x more expensive on GOAT

Notes on Methodology

• Token assumptions: Taken from OpenCode Go docs (English) -- different per model. Example: Grok 4.5 uses 1,100 input / 71,500 cached / 220 output per request; DeepSeek V4 Flash uses 410 input / 71,300 cached / 310 output per request. GOAT's own published estimates use different defaults (~800 input / 50,000 cached / ~125-200 output), which inflate their numbers for cache-heavy models.
• Off-peak pricing: Both platforms show off-peak rates for DeepSeek V4 models. Peak hours (01:00-04:00 & 06:00-10:00 UTC) are 2x on both.
• GPT-5.6 Luna context tiers: Go lists <=272K ($0.20/$1.20/$0.02) and >272K ($0.40/$1.80/$0.04). GOAT shows one price ($0.20/$1.20/$0.02). Both use <=272K tier here.
• Processing fee: GOAT mentions "+ processing fee" but doesn't specify the amount. Go has no processing fee.
• Model availability: GOAT includes Grok 4.6, Gemini 3.7 Flash, Muse Spark, Inkling, Step Flash, Nemotron 3 Ultra -- none on Go. Go includes GLM-5.1, Kimi K2.6, MiniMax M2.7 -- none on GOAT.
• Allowance source (GOAT): Per-model monthly credit allowances from docs/plans/goat -- models with negotiated deals carry boosted allowances (e.g., GLM-5.2 $70, Hy3 $70, DeepSeek V4 Flash $60); new models start at 2x credits ($20 on the $10 GOAT plan).
• Allowance source (Go): Per-model "Usage" column ($15 or $60) from docs/en/go -- Usage limits.