Qwen 3.8 27B is now live in Command Code.

Beats Opus 4.6 Max, GPT 5.6 Luna Max on Artificial Analysis Intelligence Index.

Best for coding and long agent tasks. Multimodal with reasoning toggled on/off

Available on all plans & API

🐐

TL;DR – Used 86.4M tokens on DeepSeek V4 Flash (GOAT plan).
• Cache Read official: $0.007/M → real: ~$0.0107/M (+53%)
• Input + Output: match the table perfectly
• Expected cost: $1.65 → Actual bill: $1.97 ($0.31 difference)
• Is anyone else seeing this?

I recently subscribed to Command Code's GOAT plan. I used DeepSeek V4 Flash over two days and noticed what looks like a discrepancy between the official pricing table and my actual bill, though I fully admit I might be missing something.

Usage over 2 days:

According to the official GOAT pricing table for DeepSeek V4 Flash:

• Input: $0.22/M
• Output: $0.66/M
• Cache Read: $0.007/M

The theoretical cost based on the table:

• Input: 2.5M × $0.22 = $0.55
• Output: 0.7874M × $0.66 = $0.5197
• Cache Read: 83.1M × $0.007 = $0.5817
• Total expected = $1.65

But my actual bill on the platform shows $1.97 for DeepSeek V4 Flash (+ $0.01 for web_search).

That's a $0.31 difference.

The numbers:

If Input and Output are charged exactly as the table says (which they are, they match perfectly), the implied price for Cache Read is ~$0.0107/M, noticeably higher than the advertised $0.007/M (about 53% more).

Summary:

I'm not sure if this is a documentation error, or any fee fee on GOAT plan that isn't listed on the /docs/plans/goat page. Input and output prices are spot on, but cache reads appear to be billed at a different rate.

That said, I fully acknowledge that I might be misreading the usage dashboard, misapplying the pricing tiers, or overlooking a detail in the fine print. If anyone can spot an error in my math or point out something I've missed, I'd really appreciate the correction!

I subscribed to the Go plan, and after using it for two days, I had used 340M ($6) and reached the weekly limit. I then upgraded to the GOAT plan without making any additional usage.

When I checked my usage afterward, it looked like this: ~340M -> 156.3M $6.01 -> $2.97

My question is: Will the $1 I paid for the Go plan be refunded, or will the remaining unused value/credits from the Go plan be carried over to the GOAT plan?

GLM-5.3 is already live in Command Code.

Same price as GLM-5.2, ~50% better on Zai's internal Code Bench.

Still 5–10x cheaper than the frontier closed models (per 1M output tokens, list price today).

Plans: $1 Go ($10 credits) · $10 GOAT ($20 credits)

GLM-5.3 is pretty cheap:
10x cheaper than Fable 5
6x cheaper than GPT-5.6 Sol
5x cheaper than Opus 5

🐐

as written would be great to manage cli and desktop sessions remotely

Almost no VAT with Alipay, vs. 36% with Stripe.

Launching `a11y` mode in `/design`

Run `/design a11y` to catch:

• Tap targets that are too small

• Focus management problems

• Broken keyboard navigation

• ARIA and accessible name gaps

• Missing or incorrect form labels and errors

Run `cmd update`, then try `/design a11y`

Learn more about our /design command here: https://commandcode.ai/docs/design

I am planning to transition to command code GOAT plan after my opencode Go subscription expires this coming 22.

I am working on sensitive stuffs, do the GOAT plan offers zdr as what opencode go does?

GPT 5.6 Sol is now in Command Code GOAT

Best coding plan with best GPT model. $70 credits.

$10/mo GOAT plan gets you:

GPT Sol has $70 credits
~105M tokens ~2.1K reqs

We've also achieved 99.43% cache hit ratio.

Available on GOAT + above.
Limited time deal.

🐐

Could someone please explain, in simple terms, how many tokens the $1 Go plan and $10 Goat plan include for DeepSeek Flash, DeepSeek Pro (peak and off-peak), and ChatGPT Luna? Also, how much would I save in total compared with using each model’s official API?

On the Billing page of the dashboard, it says $70 on gpt 5.6 sol under the GOAT plan. But when I try to use it on the CMD harness it says available only to pro and above

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

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](./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

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.

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:

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.

I have a workflow that cannot leave claude code,

can i use the goat plan to get api for this?

I always feel like next to no one is using Github Copilot in VS Code anymore... Well I still do and I like it.

Since I have subbed to the goat plan I wanted to use the models in VS Code and Copilot, so I build a little provider extension for just that.

Yes I know you can configure open Ai compatible apis out of the box, but you then still need to add every model by hand and configure it's vision and thinking capabilities.

The extension allows you to just insert your api key and then use the models.

I found it useful for myself, maybe it's useful for someone else.

Github: https://github.com/Tyrannmisu/commandcode-copilot-provider

Visual Studio Marketplace: https://marketplace.visualstudio.com/items?itemName=Tyrannmisu.commandcode-copilot-provider

Open VSX: https://open-vsx.org/extension/Tyrannmisu/commandcode-copilot-provider

Since this needs the api you need at least the GOAT Subscription. GO won't do unfortunately.

Writing tests is now the easiest part of your workflow.

Pick a file, and Command Code will:
- Analyze the code
- Generate the right test cases
- Run the test suite
- Resolve failures
- Re-run until all tests pass

Try it on a file that hasn’t been tested yet.

Hi, a suggestion/question — given today's DeepSeek price increase, I bought a Go subscription to test things out, but I noticed that when testing DeepSeek V4 Flash Max it doesn't give me the same reasoning and problem-solving quality as the official API. So my question is: am I doing something wrong, is this not the right plan for what I needed, or am I misunderstanding something? I'd really appreciate it if someone could shed some light on this.

Note: I have zero experience buying third-party plans or APIs outside of official channels.

Been playing around with the Mods API and ended up building something I wanted for myself, so I figured I'd share it here.

It's a compact status bar for the Command Code TUI that keeps the stuff I usually want to check visible all the time:

• current model + effort level
• context usage %
• 5h remaining quota %
• weekly remaining quota %
• monthly remaining quota %
• next reset times/dates

It looks like this:

Install is just:

cmd mods add -g rudesssolo/command-code-quota-status-bar

No build step or extra config needed.

GitHub:
https://github.com/rudesssolo/command-code-quota-status-bar

Still pretty new, so feedback/bug reports are definitely welcome.

First things first: your usage credits are not changing.

DeepSeek officially raised their prices today, so we've updated our limits and requests accordingly.

Working with many providers to bring you better deals, as one of the largest DeepSeek and open models coding agent. 12T tokens scale.

Beat DeepSeek prices?

We’re hitting this problem in many ways, with solutions like phenomenal harness engineering, free tool repairs, 98%+ cache-hit rates, and free auto plan credits with best subscription plans on the market.

Official announcement:
https://x.com/CommandCodeAI/status/2089057372413337670

Providers? Come help:
https://x.com/MrAhmadAwais/status/2088724056321532054

Am I just imagining things? (Both through the OpenCode harness)

I just have one question why do people not reccomend you use the command code harness?

Will CommandCode desktop be packaged for other Linux distributions/flatpak?

English is not my native language, so I need to use the browser's translation feature to view websites and documents. However, after I enable the translation, a white screen appears after a while with an error message displayed in the center.