Three $10 Go Plans Instead of One $100 Max Plan: The Peak-Hour Math

I pay $30 a month for what used to cost $300

For the last few months my main workhorse has been DeepSeek V4.1 Flash (1017). Good enough at code, fast, and cheap on paper — but my bill never felt cheap. Around $250 a month of usage, every month.

Then I did the arithmetic on a different way of buying the exact same model, and it stopped making sense to pay list price at all. Three subscriptions, $10 each, cover the same workload with room to spare. This post is that arithmetic, with the peak-hour detail that nobody puts on the pricing page.

Two ways to buy inference

Every provider sells tokens one of two ways:

1. Pay as you go. Metered, list price, no commitment. You pay for exactly what you burn.
2. Monthly commitment. You pay a fixed amount and receive a pool of usage credits worth more than the price.

The gap between the two is the whole story. A normal subscription might multiply your money by 2× or 3×. Ollama does 3× on its Max plan: $100 a month buys $300 of usage credits. That is a good deal, and until now it was the deal I recommended.

The new “Go” plans multiply by ten. Ten dollars in, one hundred dollars of usage out. Same model, same API shape, a tenth of the effective price.

The three plans I actually run

Plan	Price	DeepSeek V4.1 Flash allowance	Pacing caps
Command Code GOAT	$10/mo	$100/mo	14 credits per 5h, 35 per week
OpenCode Go	$10/mo	$100/mo	20% of the monthly pool per 5h, 50% per week
OpenDesign Go	$10/mo	$120 in Design Plan credits, and DeepSeek V4.1 Flash has a 0.5× multiplier — so roughly $240 of model usage	$10 per 5h, $30 per 7 days

Add the three up: $30 a month for about $300 of listed allowance, and if you count OpenDesign’s multiplier honestly, closer to $440 of DeepSeek V4.1 Flash usage.

This is why the combination matters more than any single plan. Each one is a $10 experiment. Together they are a full working budget — and none of them is the single point of failure when one provider has a bad day or rotates its model list.

Two details worth knowing before you subscribe:

• Command Code GOAT is the $10 tier above their $1 “Go” plan. The GOAT plan carries the boosted deepseek-v4.1-flash allowance ($100); the $1 plan carries only $10. The plan naming is genuinely confusing, so check the model row, not the plan name.
• OpenDesign Go is a design-agent plan, not a coding-agent plan. It works as a general model endpoint through their API key, but it does not include image generation, and its credits are paced hard: $30 a week means you cannot front-load a month of work into one weekend.

The part everyone gets wrong: peak hours

All four of these providers follow DeepSeek’s own time-of-day pricing. Peak hours cost double. So an allowance is not really a dollar figure — it is a dollar figure multiplied by when you spend it. Spend $100 of credits at peak and you get half the tokens that same $100 buys off-peak.

Here are the windows in Malaysian time, which is what actually matters if you live here:

Provider	Peak (MYT)	Peak (UTC)	Peak hours / weekday
Command Code, OpenCode Go, OpenDesign	09:00–12:00 and 14:00–18:00, Mon–Fri	01:00–04:00 and 06:00–10:00	7 hours
Ollama	20:00–02:00, Mon–Fri	12:00–18:00	6 hours

Weekends are off-peak everywhere, and DeepSeek also skips Chinese public holidays.

Look at the numbers for a second. Both windows are short. Both leave most of the day at the cheap rate — 17 hours for the Go plans, 18 for Ollama. Ollama keeps its cheap window open an hour longer, and that is a real, measurable advantage.

But here is the more useful observation: the windows barely overlap. The Go plans go quiet at 18:00 Malaysian time; Ollama does not get expensive until 20:00. Between 18:00 and 20:00 everything is cheap, and outside those two blocks there is always at least one provider charging the off-peak rate.

So is Ollama still worth it?

Yes, for one specific reason: its off-peak window is longer and its billing is simpler. Ollama Max is $100 for $300 of credits with no 5-hour caps, no weekly caps, and 10 concurrent requests. There is no pacing to think about. If you want one bill, one key, and no scheduling, it is still the calmer choice.

What it is not, is cheaper. Three Go plans cost 30% of one Max plan and return about the same allowance in usage dollars. If you are already spending $300 a month of DeepSeek V4.1 Flash usage through Ollama Max, the same work fits inside three $10 subscriptions.

My own number: I use roughly $250 a month. It fits, with headroom, and it fits even when I spend it badly.

Making it seamless

Three subscriptions means three API keys and three base URLs, which is exactly the kind of friction that makes people give up and go back to one expensive plan. Two ways to avoid it.

1. A router that knows the schedule

I wrote offpeak-router for this: a single static Go binary, OpenAI-compatible, no dependencies. Point any client at http://127.0.0.1:8788/v1 and it picks a provider per request, in this order:

1. allowance left and off-peak — covers about twice as many requests as the same money at peak
2. another provider’s allowance, still off-peak
3. any allowance left, even at peak — a prepaid token is never worse than a metered one
4. metered, whichever is cheapest right now

It falls through to the next provider on a 5xx or transport error, and skips a provider for 60 seconds after three consecutive failures. On my own workload, routing between two subscriptions with disjoint peak windows cut the monthly bill by about 35%. Your mileage will differ — measure it with /status before believing anyone’s number, including mine.

2. If you use an agent, just use fallbacks

Honestly, if you are running Hermes Agent, you do not need a router. Hermes already supports a fallback model chain: when one provider fails or is rate-limited, it moves to the next one in the list. Three keys in a fallback chain gets you the same resilience with no extra process to babysit.

The router earns its keep when you have many clients, or when you specifically want the allowance spent at the right hour — not just the request served somehow.

The fine print I would check before paying

• The caps are real. Every one of these plans paces usage: a 5-hour window and a weekly window. A $100 monthly allowance is not $100 you can burn in an afternoon. If your work is bursty, the pacing hurts more than the price.
• Allowances are denominated in usage dollars, not requests. Spending at peak halves the requests your allowance covers. Timing is part of the product.
• Promo multipliers expire. OpenDesign cut the DeepSeek multiplier to 0.25× for one week and then put it back to 0.5×. Do not build a budget on a temporary number.
• Model lists move. All three change what is included. Check the model is still in the plan before you commit a month.
• Prices and windows change. Everything above is what the docs said when I wrote this. Verify against the provider pages before you switch: Command Code, OpenCode Go, OpenDesign, Ollama.

Who this is for

If you spend more than about $50 a month on inference for coding agents, the three-plan combination is very likely cheaper than whatever you are doing now, and worth one evening of setup.

If you spend $10, this is overkill — take one Go plan, learn where its caps bite, and add the second only when you hit them.

And if you value not thinking about any of this, Ollama Max at $100 for $300 is still a perfectly defensible way to buy peace of mind. The peak windows are shorter than they look from the outside, and the weekday afternoon surcharge is survivable.

But the multiplier is the multiplier. Ten times is a different category from three times, and once you have seen your own bill at a tenth of the price, it is hard to go back.