Command Code is the agentic coding platform from commandcode.ai — a CLI and Studio toolset that wraps Anthropic, OpenAI, Google, MiniMax, DeepSeek and dozens of open-weight models behind one interface. Its pricing model is the most interesting part of the product: flat monthly subscription with a MASSIVE credit multiplier, rolling usage windows, and credits that never expire. This is my honest command code pricing review after reading the full pricing and limits documentation cover to cover.
What Is Command Code?
Command Code is an AI coding agent that runs in your terminal (CLI) and in a desktop Studio plus IDE integrations. You bring your own project, Command Code reads your codebase, and lets you plan, write, review and fix code using the model you pick. It is not a chatbot website widget — it is a developer tool aiming to replace the paid tiers of Anthropic and OpenAI coding planes with a subscription that bundles access to many models at once.
The key architectural choice: instead of a fixed monthly model fee, Command Code sells you a credit pool at a steep multiplier. You then spend those credits per token, per model, at the model’s own API rate. This is the same “buy a pool, spend by model” structure as OpenRouter, but wrapped in a flat monthly plan where the credits are heavily subsidized.
Command Code Pricing: The Plans at a Glance
The documentation on the Command Code pricing and limits page lists six individual plans and two team plans. Here is the real table from the doc:
| Plan | Price/mo | Credits/mo | Approx requests | 5-hour limit | Weekly limit |
|---|---|---|---|---|---|
| Go | $1 | $10 | ~15K | $3 | $6 |
| GOAT | $10 | $70 | ~75K | $14 | $35 |
| Pro | $20 | $80 | ~100K | $16 | $40 |
| Provider | $15 | Pay-as-you-go | — | — | — |
| Max 10× | $100 | $150 | ~230K | $45 | $90 |
| Max 20× | $200 | $300 | ~370K | $90 | $180 |
| Team Pro | $40 | ~35K requests | — | $12 | $24 |
| Enterprise | $5,000+ | Custom | Custom | — | — |
How the Credit Multiplier Actually Works
This is the single most surprising thing about command code pricing. On the Go plan you pay $1 and get $10 of credits. On GOAT you pay $10 and get $70. On Pro $20 for $80. Max 10× is $100 for $150, Max 20× $200 for $300. That is a 10× to 1.5× credit bonus depending on tier.
The credits are then spent at the model’s own per-token API rate. A cheap model like DeepSeek V4 Flash at $0.22 input / $0.66 output per million tokens stretches much further than Claude Opus 5 at $5.00 / $25.00. Command Code’s own estimate: on Go, DeepSeek V4 Flash runs about 32,000 requests with no cache, or ~15,000 once the typical 50K of cache reads are counted.
Rolling Usage Windows: The Hidden Constraint
Every subscription plan has two rolling limits on top of the monthly credit pool: a 5-hour window and a weekly window. They are designed to stop a single burst from draining a whole month in one afternoon.
Here is the tradeoff you need to understand before buying: your monthly credits are not immediately spendable all at once. On Go, the 5-hour window caps you at $3 of usage and the weekly window at $6 of your $10 pool. On Max 10× you can spend $45 in 5 hours and $90 a week out of $150. Windows roll from first use, not on a fixed clock, and reset each window-length.
The good news: on-demand top-up credits are exempt from the rolling windows. If you hit a window mid-session you can buy extra credits and keep working immediately, with the window check skipped entirely.
Do Credits Really Never Expire?
Yes — that is stated plainly. Monthly subscription credits reset at the start of each billing cycle, but top-up and on-demand credits roll over forever. They are not throttled, not capped, and you can buy them at model cost. This is genuinely consumer-friendly for a pay-per-usage product and a real differentiator versus many competing plans that expire credits monthly.
Model Pricing: The Depth of the Catalog
Command Code’s catalog is deep. Across all plans the docs list 65 models at the time of writing, with 7 deals and 4 free models. Here is what matters for real coding work:
Premium frontier models
| Model | Input/M | Output/M | Cache read/M | Cache write/M |
|---|---|---|---|---|
| Claude Opus 5 | $5.00 | $25.00 | $0.50 | $6.25 |
| Claude Sonnet 5 | $2.00 | $10.00 | $0.20 | $2.50 |
| Claude Haiku 4.5 | $1.00 | $5.00 | $0.10 | $1.25 |
| GPT-5.6 Sol | $5.00 | $30.00 | $0.50 | $6.25 |
Cost-efficient workhorses
| Model | Input/M | Output/M | Cache read/M |
|---|---|---|---|
| DeepSeek V4 Flash (off-peak) | $0.22 | $0.66 | $0.007 |
| DeepSeek V4 Pro (off-peak) | $0.66 | $1.98 | $0.022 |
| GLM-5.3 Flash | $0.15 | $0.50 | $0.03 |
| MiniMax M2.7 | $0.30 | $1.20 | $0.06 |
| Qwen 3.7 Plus | $0.40 | $1.60 | $0.08 |
| Tencent Hy3 | $0.14 | $0.58 | $0.035 |
Free Models in 2026: Real Zero-Cost Coding
At the time of writing, Command Code had four free models — some permanently, some time-bound:
- Laguna S 2.1 — free while capacity lasts, available on all plans (input, output and cache reads all $0.00).
- Ling 3.0 Flash — free while capacity lasts (256K context).
- MiniMax M3 and M2.7 — free through September 5, 2026 on GOAT and above (1M context for M3).
One caveat worth knowing before you rely on the free MiniMax lane: the free variants are served by GMICloud, which offers neither zero-data-retention nor a no-training guarantee. If you run with CMD_ZDR=1 to force zero retention, you cannot use that free lane at all. The free Laguna S 2.1 has its own terms too. The permanent free model is a limited-capacity offer, so treat it as a nice bonus, not a dependable base.
Active Deals That Change the Math
The docs flag several deals live as of mid-2026 that can stretch your credits dramatically:
- google/gemini-3.7-flash at 50% off through December 31, 2026 — every credit goes 2× further.
- minimax-m3 at 2× usage — every credit goes twice as far.
- mimo-v2.5 and mimo-v2.5-pro up to 99% off.
Deals stack with your plan’s credit bonus. On GOAT and Pro the deals are baked into per-model allowances automatically, with nothing to enable. On top-up credits the same discount applies when spent on the discounted model. The real-time Usage page shows the discounted per-request price as it happens, and deals auto-expire with no action needed.
Enterprise and Security
For organizations, Command Code offers an Enterprise tier from $5,000+/mo with custom model pools, SLAs and dedicated support on your own infrastructure. The documented security posture is strong for a coding agent: Command Code does not train on your code and does not store code snippets. Taste data (your personalization) is stored locally in your project directory. Commercial model traffic is sent to the provider’s API (Anthropic, OpenAI, Google, Azure) and handled per their privacy policy, with EU hosting on demand. There is a Zero Data Retention mode available, subject to the free-lane caveat above.
How Command Code Compares to Other Providers
If you already use OpenRouter or Google AI Studio’s free tier, Command Code is a different category. OpenRouter is a pure API gateway: you pay per token with no subscription bonus. Google AI Studio gives you a limited free tier. Command Code bundles a subscription plus access to both open-weight and premium models, with the credit multiplier as the main incentive. The closest analogues are the paid coding plans of Anthropic and OpenAI, but Command Code’s advantage is model choice and the never-expiring top-up credits.
For a website owner or chatbot operator rather than a developer, Command Code is not the tool for adding a chatbot to WordPress — that is a code-heavy workflow. But if you are building, deploying or maintaining that chatbot’s backend, plugins, or n8n workflows, a cheap Go plan gives you a serious coding agent for a dollar a month.
Who Should Buy Which Command Code Plan
- Go ($1/mo, $10 credits) — hobbyists, light script editors, first try. Enough for dozens of small tasks and a real test of the workflow.
- GOAT ($10/mo, $70 credits) — the best value if your work is mixed open-weight coding. ~75K requests.
- Pro ($20/mo, $80 credits) — heavy users who want premium models like Sonnet 5 and GPT-5.6 in the mix. ~100K requests.
- Max 10×/20× ($100/$200) — professional teams hammering code all day; the credit multiplier is weakest here (1.5×) but the pool is biggest and windows are generous.
- Provider API ($15) — pay-as-you-go raw API access, no subscription, for integration into your own apps.
Limitations and Honest Caveats
- Rolling windows are real throttles on included credits. Your 10× credit bonus is not instantly spendable — on Pro you cap at $16 per 5 hours. Plan around bursts.
- Free models are capacity-limited or time-bound. Laguna S 2.1 is “while capacity lasts”; MiniMax free ends September 5, 2026.
- No zero-retention on the free lane. The free MiniMax uses GMICloud with no ZDR/no-training guarantee.
- A developer tool, not a chatbot provider. If you want to embed a chat widget on your site, this is not that. It is for writing code.
- Request estimates vary wildly. 15K vs 32K vs 370K depends entirely on model choice and cache usage. The “typical request” includes ~42-56K cache reads that burn credits on every turn.
A Worked Example: What One Session Costs
To make the numbers concrete, let me run a realistic session through the pricing. Command Code states a typical request is about 700-1,000 input tokens, 125-200 output tokens, plus roughly 42,000-56,000 cache reads on average. The cache reads are the quiet cost driver: every new turn in a conversation re-reads the full context, so a long-running session is far more expensive than a fresh one.
Take three models doing the same 50-request feature build:
| Model | Input cost | Output cost | Cache cost | ~50 requests |
|---|---|---|---|---|
| DeepSeek V4 Flash | $0.22/M | $0.66/M | $0.007/M | ~$1.20 |
| Claude Sonnet 5 | $2.00/M | $10.00/M | $0.20/M | ~$11 |
| Claude Opus 5 | $5.00/M | $25.00/M | $0.50/M | ~$27 |
The gap is enormous: the same build costs roughly 22× more on Opus than on DeepSeek Flash. That is why Command Code’s “how far your credits go” is genuinely model-dependent, and why the docs repeatedly steer you toward cheaper models when you want many requests rather than maximum quality. It also means the monthly-request estimates (15K on Go, 75K on GOAT, 100K on Pro) are useful only if you favor efficient models. Pick ambitious premium models all day and you will burn the pool far faster.
A practical tip from the docs: start a new session (or use /clear) for unrelated tasks, because every new turn re-reads the full context in cache. Keeping conversations short is the single biggest lever on cost.
How Command Code Stacks Up Against Other Providers
Because I review AI providers for yakwp.com, I have tested several of the alternatives Command Code competes with, and the differences matter depending on what you are building.
Command Code vs OpenRouter
OpenRouter is a pure API gateway: you bring your own key and pay per token with no monthly subscription, no credit multiplier, and no free-tier coding models of its own. If you want direct API access to many models for your own application — such as the plumbing behind a WordPress chatbot — OpenRouter is the more direct choice. Command Code instead gives you a subsidized flat plan, which wins when you want a lot of coding done for one predictable monthly price. My OpenRouter review covers that tradeoff in depth.
Command Code vs OpenCode Go
OpenCode Go is the closest direct competitor: an agentic coding CLI with bundled model access at a low flat price. Both use a subscription-plus-many-models model. Command Code’s pricing documentation is unusually transparent (public per-token rates for all 65 models, real-time usage meters, rolling windows), which is a point in its favor for cost-sensitive developers. See my OpenCode Go review for the alternative.
Command Code vs Google AI Studio
Google AI Studio’s free tier is the standing reference point for zero-cost AI: a generous daily free allowance on Gemini models. It is free but limited to Google’s models. Command Code bundles a much wider catalog (Anthropic, OpenAI, DeepSeek, Qwen, MiniMax and more) behind a paid subscription, with only a few free models. If you want Google models for free, Google AI Studio’s free tier is still the unbeatable option; if you want a broad multi-model coding agent, Command Code wins.
All three reviews live in our AI providers cluster, so you can compare the whole field.
Who This Is For (and Who It Is Not For)
Command Code is squarely a developer tool. It makes sense for developers, technical founders, and automation builders who write, review and maintain code every day.
It is not the tool for adding a chatbot to your website, embedding a support widget, or sending visitors an AI assistant. For those, a WordPress chatbot plugin with its own model integration is the right starting point — and I recommend seeing how to add an AI chatbot to WordPress and our best free chatbot roundup. But if you are building the backend, plugins, or n8n automation behind that chatbot, a $1 Go plan gives you a serious coding agent to do it.
Command Code Pricing: Final Verdict
Putting the whole model together, here is how I rate Command Code across the dimensions that matter:
| Dimension | Rating | Notes |
|---|---|---|
| Value / dollar | Excellent | $1 → $10 of credits; ~10× multiplier on low tiers |
| Price transparency | Excellent | All 65 model rates public; real-time usage meter |
| Flexibility | Excellent | 65 models, BYO providers, switch with /model |
| Credit longevity | Excellent | Top-up credits never expire |
| Burst friendliness | Fair | Rolling 5-hour / weekly windows on included credits |
| Free tier | Good | 4 free models, but capacity-limited / time-bound |
| Audience fit | Narrow | Developers only; not a chatbot-widget provider |
Frequently Asked Questions
Is Command Code actually free?
Do Command Code credits expire?
Which Command Code plan is best value?
What models does Command Code support?
Is Command Code safe to use with my code?
Conclusion
Command code pricing is cleverly designed: a flat subscription with a big credit multiplier, model-level per-token spend, and never-expiring top-ups. The value is real on the low tiers — a dollar for $10 of credits is a genuinely good deal for light coding. The rolling windows keep that generosity honest, and the free model selection makes it easy to try with zero risk. The main thing to remember is that this is a coding agent, so it serves yakwp’s audience best as a backend tool for building the automations, plugins and n8n workflows behind a WordPress chatbot, not as the chatbot itself.
If you need a solid, cheap alternative to expensive Anthropic or OpenAI coding plans — or you want access to dozens of models behind one subscription — Command Code is worth a serious look. Start on the $1 Go plan, test the free Laguna S 2.1 model, and upgrade only when the usage windows start to bite.
Leave a Reply