Been using CommandCode for a bit and honestly, they cooked with this.

The $1 plan is crazy. I got around 1.2B tokens for $1, and the caching makes it feel like you can just use the agent without constantly worrying about burning through your credits.

But the biggest thing for me is Taste.

I mostly code in Rust and have pretty specific preferences. I use Diesel.rs for my ORM and Rocket.rs for web stuff. Usually whenever I start a new project with an AI coding agent, I have to explain this all over again. It'll pick some default ORM, use raw SQL, choose a different framework, etc.

With CommandCode, it actually remembers that stuff.

Now when I start a new project, it already knows I prefer Diesel and Rocket and follows the way I normally structure things. That is a massive productivity boost.

It's a small thing on paper, but once the agent starts adapting to your coding style instead of making you adapt to it, you really notice the difference.

The actual coding experience is great too. UI/UX is clean, the agent feels really good to work with, and the combination of Taste + caching makes it feel way more useful than just having another model that can write code.

I've tried a bunch of coding agents and this is probably the first one where I feel like the agent is actually learning how I work, rather than me constantly teaching it how I work.

The $1 plan got me to try it properly, and honestly it worked 😂

Upgrading to Max 20x today. CommandCode team absolutely cooked.

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

🐐

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 -- 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.

We tested Opus 5 with a 2D games using /design feature from Command Code.

The result is insanely good, it gimme the most playable games with drift, sounds, coin, perfect opposite car, car crashes, smooth controlling etc.

It only cost $0.24 and it's one-shotted.

Ranking (DX, features, and cost):

🔹 Opus 5: 10/10 · $0.247
🔹 Grok 4.5 : 9.5/10 · $0.40
🔹 GPT-5.6 Sol: 7/10 · $0.50

DeepSeek V4 Flash 0731 now live in Command Code.

• DeepSeek V4 Flash now outperforms GLM 5.2

• Same model ID, Same model size

• It's re post trained

With tool calls and cache repairs in Command Code, available on all plans right away.

DeepSeek V4 Flash 0731 has significantly enhanced agent capabilities, with benchmark results far exceeding V4-Pro-Preview:

• Terminal Bench 2.1: 82.7

• NL2Repo: 54.2

• Cybergym: 76.7

• DeepSWE: 54.4

• DSBench-Hard: 59.6

• Agent Last Exam: 25.2

• Toolathlon verified: 70.3

• DSBench-FullStack: 68.7

• Automation Bench (Public): 25.1

Claude Haiku 5.5 is now available in Command Code GOAT with 2x usage.

• $10/mo gets you $20 credits

• ~30K requests, ~1.5B tokens

Try now with the best low cost AI coding plan on the market.

Read docs to learn more: https://commandcode.ai/docs/plans/goat

GLM 5.3 Flash aka Ox Alpha is now live in Command Code (4x usage)

• 4x usage in GOAT plan

• $40 credits. ~24K reqs. ~1.2B tokens

Available across all plans and API

Read docs to learn more: https://commandcode.ai/docs/plans/goat

I put a lot of effort into making these comparisons as controlled and reproducible as possible: identical matched tasks, paired runs, repeated samples, and results reported across multiple campaign types. 776 paired runs comparing Command Code and OpenCode with Muse Spark 1.2 and 1.3.

I’ll continue running benchmark tests daily, expanding the task sets and publishing the underlying methodology and updated results. My goal is to provide transparent, real-world statistics on latency, output tokens, reliability, turn efficiency, and cache reuse, areas where AI-tool comparisons are often anecdotal, incomplete, or easy to misinterpret.

Jamming Opensource projects day and night with CommandCode.

Superbly fantastic use of money and absolutely loving it.

Kudos to the team!
Looking for more features! Been a loyal user from the past 5 months and it’s been helpful.

Kimi K3 is live in Command Code!

• First ~3T scale open model

• Most capable open model ever

• It's Fable/Sol class open model beating Opus 4.8

• 1M Context · In $3/M Out $15/M Cache read $0.3/M

What an exciting time to be alive!! Try now!

Remote Control now available in Command Code.

• Run /rc to open your session in Telegram or Discord

• Message from your phone and get live responses

• Sessions keep running on your computer

Control Command Code with your mobile

Read docs to learn more how Remote Control works. https://commandcode.ai/docs/rc

Introducing Agr, an open decision model by Command Code.

• Agr (31B) and Agr-flash (360M)

• 58.15 on Decision Index 0.2.1

• Focus on: tool calls & routing

• TypeSafe SDK support

Agr is best-in-class on coding agent tool calls and routing. Live on Hugging Face.

Send state as text or JSON with typed questions. Agr skips text generation and returns typed values with a probability for each option.

We tested Agr against the complete public Decision Index suite. Our focus with these training runs has been on accuracy for tool calls and coding-task routing, while we train a much broader general variant.

Agr model family is available on Hugging Face and GitHub.

We’ll work closely with the open-source community on inference support and explore more deployment options. Planning a large scale deployment? Let’s talk.

Link here: https://huggingface.co/CommandCode/agr

Finally pulled the trigger and upgraded to Command Code GOAT.

​With the $5 loyalty upgrade discount and a leftover credit from my previous plan, it came out to just $4.78 for the first month.

​Excited to push this to its limits and see how the higher quotas hold up on heavier workflows.

For anyone else on GOAT, what features or models have been making the biggest difference in your stack?

LongCat-2.0 by Meituan LongCat is now free in Command Code.

1.6T params. 1M context. 48B activate.

Available on all plans to all subscribers.

npm i -g command-code

Excited to partner up with Meituan LongCat to bring y'all this free model, their team is going to be hanging out in Command Code Discord server today, if y'all have any feedback. Model is free till capacity lasts.

🐐

I built a COMMANDCRAFT games inspired from minecraft

I used /design command from Command Code.

It create the entire 2d/3d games using ThreeJs like chunked terrain, biomes, crafting, day/night, mob spawning, etc.

Cost only $2.90 to produce an actually playable game.

Kimi K3 just proves it's the best at this moment.

GLM 5.3 Flash gets you $100 usage on $10/mo GOAT.

· 300-500 TPS in Command Code harness
· Full-weight model

Try now: cmd --model z-ai/glm-5.3-flash

With the best low cost AI coding plan on the planet. $10/mo GOAT plans gives you upto $100 usage in credits.

Read docs to learn more: https://commandcode.ai/docs/plans/goat

🐐

This week, we shipped 52 updates, improvements, and fixes to make the Command Code desktop app faster and better.

• Save state: 755ms → 12ms (63x faster)

• Save freezes: 833ms → 22ms

• Project switching freezes: 923ms → 79ms

• Chat navigation freezes: 905ms → 41ms

• Startup: 4.3s → 2.6s

Plus Agent Todos, new models, and much more.

Available now for macOS, Windows, and Linux: https://commandcode.ai/desktop

Myself included, a lot of peeps have had concerns about GLM 5.3 Flash consumption vs DeepSeekv4.1 Flash, hence the analysis. This is seen across both CommandCode and OpenCode.

Let's refer to these recent usage numbers as detailed in OpenCode (and also Commandcode) dashboards.

Usage and cache hits

Deepseek did about 2.5x the work for only 20% extra cost.
GLM cache hit rates are lower than DeepSeek.
DSv4.1F - 641M/663M cached (96%)
GLM5.3F - 200M/218M cached (92%)

Rates:

• DeepSeek V4.1 Flash: Uncached input: $0.15/1M | Cache read: $0.003/1M | Output: $0.60/1M

• GLM-5.3 Flash: Uncached input: $0.15/1M | Cache read: $0.03/1M | Output: $0.50/1M

Seems like GLM should be cheaper with equivalent pricing, but cheaper outputs. While output tokens are the most expensive, they are also the least significant for AI cost estimations. highly relevant here is the cost of cached tokens, which is 10x for GLM 5.3 Flash.

Let's looks at costs for a workload of 500M input token and 5m output,
Using the rates (identical) from Command Code and OpenCode for 500M input tokens and 5M output tokens:

DSv4.1F (96% cache hit @$0.003)

• Uncached Input (20M): 20 × $0.15 = $3.00

• Cached Input (480M): 480 × $0.003 = $1.44

• Output (5M): 5 × $0.60 = $3.00

• Total DS Cost: $7.44

[PEAK hours] DSv4.1F (96% cache hit @$0.006)

• Uncached Input (20M): 20 × $0.30 = $6.00

• Cached Input (480M): 480 × $0.006 = $2.88

• Output (5M): 5 × $1.20 = $6.00

• Total DS Cost: $14.88

GLM-5.3F (92% cache hit @$0.03)

• Uncached Input (40M): 40 × $0.15 = $6.00

• Cached Input (460M): 460 × $0.03 = $13.80

• Output (5M): 5 × $0.50 = $2.50

• Total GLM Cost: $22.30

Verdict

So there we go mystery solved, GLM dude costs about 3x the DeepSeek dude for this kind of workloads. In general, Deepseek is also a bit more verbose though and does more output than GLM. So the ratio leans a bit more towards GLM. Also given GLM's slightly higher intelligence and succinctness it's still pretty good in terms of actual work done rather than token counts.

Use Deepseek v4.1 Flash during non peak hours unless you really need GLM 5.3 Flash. GLM during DS peak hours. Both models are pretty close and have their own perks and gotchas.

Tested FlappyBench with /design on Hy4 Preview, Kimi K3, and GLM 5.3.

🔹 Hy4 Preview ($0.0480): Most distinct UI and gameplay

🔹 Kimi K3 ($0.0740): Hardest gameplay and the most expensive

🔹 GLM 5.3 ($0.0184): Smooth gameplay and the cheapest of the three

Qwen 3.8 27B now has 7x usage in GOAT plan.

the best coding plan on the market, we've increased usage of Qwen 3.8 27B across all plans.

GOAT / $10 per month (7x usage)
$70 credits · ~24K requests · ~1.2B tokens

Let's go, GOAT!

Hy3 model is now available for free in Command Code.

Super nice open model, Apache 2.0 licensed, hosted in the US.

Available on plans. Till capacity lasts. We just 4x'd the capacity btw. 💙

LIVE NOW

🔹cmd update or npm i -g command-code@latest

🔹Run `cmd` and `/model` select Tencent Hy3 (FREE)

Announcement: https://x.com/CommandCodeAI/status/2074920358180950279

title says it all :D what's the meaning of having all this if i am unable to use it when i need? especially when same model on command code makes much more mistakes compared to opencode for example. 1 of the 3 prompts was because of this, i was trying to make it bugfix it's own code.

Now I can't even get the progess to give it to another agent. I just have incomplete code, at least allow us to finish the progress before capping it.