TLDR: On the first 3 days I wasted lots of tokens on CommandCode. Now I have rtk + better AGENTS.md and I save lots of them.
My take:
CommandCode gives way more value than Codex, but the monthly limit kills it. The monthly limit is equivalent to 2 week limits.
Codex daily and weekly limits provide way less allowance. Not worth it at all. The only positive is that you can run it without worrying of monthly limits, but it's still not worth it. (I only have it because of ChatGPT)
Been using DeepSeek for the last month, and it has been an absolute dream. But I swear to God, the last three days it feels like it's the dumbest model on the planet, and it is with Command Code as well.
When I use the API direct with DeepSeek, I get great results, but then when I get it through Command Code, I actually feel like I'm talking to a model from a year ago, maybe two years ago. It is so dumb, it's ridiculous.
Work has come to an absolute crushing stop across every single one of the dozens of agents I have open. I've started new sessions, and they're all as dumb as the next, and the inference is like up to nearly 20 times slower than what it was a week ago. I'm getting tokens of like 10 tokens per second compared to the 170 I used to get.
I don't know, I actually feel like this is like OpenCode, where they're basically routing a lot of requests now to really bad computers. There's a good video on YouTube that describes exactly how models are starting to feel dumb on OpenCode, and I wouldn't be surprised if Command Code is doing a similar thing now.
I’m currently on the Go plan and had been seriously considering upgrading to GOAT, but the Usage page changes introduced around August 20–21 made me pause before spending more on the service.
My concern is not simply that the UI changed. The previous Usage page gave customers substantially more information to understand and independently audit their usage, including:
historical period selection
Spend by Model
Requests by Model
token breakdowns for Cache Read, Input (uncached), Output, and Cache Write
dollar values for the 5-hour and weekly usage limits
The redesigned Usage page now mainly shows Total Tokens, Total Runs, and percentage-based 5-hour / weekly / monthly limits, while the more detailed usage data is now limited to only the last 24 hours and the most recent 100 entries, making older usage inaccessible from the Usage page.
Once that detailed data disappears from the visible window, I can no longer use the Usage page to determine which models and token categories generated previous consumption or independently verify historical usage against CommandCode’s published pricing.
Because of that, I followed the guidance that billing questions should be sent to [email protected].
Aug 21: I sent a detailed billing-transparency request asking how customers can now access and independently audit their historical usage and billing data after these changes.
Aug 21: I received only the automated acknowledgment, which said their typical response time is 2–5 business days.
Aug 28: I sent a follow-up asking for the status of the request and whether it had been forwarded to Billing Support.
Sep 16: Still no human response. That is 26 days with no actual reply.
To be clear, my support request was not about disputing one specific charge or investigating one request ID.
The question is structural:
How can a paying customer now access the historical data necessary to independently audit their own usage and billing after the detailed analytics were removed from the Usage page?
This matters to me because I was considering upgrading from Go to GOAT. I do not feel comfortable increasing my spending on a usage-based service until I understand how I can independently audit historical usage and billing.
There are already several related discussions from other users about the Usage page redesign, removed telemetry, cache-read accounting, or differences between displayed and exported data:
I am not presenting those posts as proof that my own billing is incorrect. I’m referencing them because they show that questions about usage transparency and auditability are not isolated besides not being answered.
In Discord, users asking billing questions have been told to send those questions by email to Billing/Support. That is exactly what I did, and after 26 days I still have no human response.
The CEO has also publicly explained that simplifying the Usage page was an intentional decision and mentioned that CommandCode is building a data lake that should make access to this information easier in the future.
I understand that explanation for why the interface was simplified, but it still leaves an important question unanswered:
What are paying customers supposed to do right now if they need to access and audit historical usage that is no longer visible on the Usage page?
If anyone here has actually received a clear answer from Billing Support, I would genuinely like to know:
Is there currently a CSV/JSON export, API, billing ledger, or another method that provides the same historical detail that used to be visible?
How are customers supposed to independently audit usage older than the current visible window?
If CommandCode staff see this, I would still appreciate a response to the billing-transparency questions I originally sent through the support channel that users are directed to use.
I renewed my Command Code GOAT subscription only to find out that the time-series trend charts: Requests by Model, Spend by Model, and All Tokens were purged from the dashboard completely. Even the explicit dollar values in the usage limits were replaced with percentages? The request log history is also only capped at 100 entries. This seems to be a deliberate step-back from transparency, not good guys.
So I just checked the documentation and realized something. The front page "Pricing" section makes claims of "70$ in credits included" though when you check the actual documentation for those allotted credits, you'll quickly come to realize that
and
doesn't really align. Now, I understand you claim that the end user or customer can just read the docs and will quickly learn about the actual ramifications of the subscription, though the fact that pricing page - in large bold letters - makes claims of "70$ in credits included" while each model served is given a different capacity, could likely lead to some people waking up with a bitter surprise.
Perhaps I don't understand how the deal systems works, if models are discounted, but if you factor in that by saying you get 70$ in credits I'd also get to spend my credits on these models:
Once again, correct me if I'm wrong or had superstitious expections of what a 10$ subscription will get you (No, I'm not a current subscriber or dissatisfied customer) but without doing digging yourself, you'd likely not go on a hunt to find not-so-trivial information in some far tucked away documentation. Especially not if the claims are made as big as they are.
I know the founder of CommandCode is quite active here, so I'd like to hear from him as well what he thinks of this.
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:
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:
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).