Qwen3.8 Max is the most expensive model on OpenCode Go — $2.00/M input and $6.00/M output, with the added twist of a $2.50/M cache-write fee that most models don't charge. It ships with a fixed $15/month usage allowance and only ~160 requests per 5-hour window, so every token — cached or not — counts.
So I wanted to answer a simple question: is the priciest model on the plan actually worth it? — without spending more than a coffee to find out.
I built a tiny benchmark that cost under a dime total. Here's what I did and what I found.
The budget math
Qwen3.8 Max has four price tiers, not the usual three:
| Price (per 1M tokens) | |
|---|---|
| Input | $2.00 |
| Output | $6.00 |
| Cached read | $0.25 |
| Cached write | $2.50 |
That cache-write fee is the unusual part — and it turned out to be the whole story (more below).
Setup
One line, same as any other Go model:
opencode run --model opencode-go/qwen3.8-max "your prompt"
The test
I reused the exact same 10-prompt harness from my GLM-5.3 test — a Bash loop running each prompt through opencode run, timing it and saving the output. The prompts span the categories a coding agent actually needs: code generation, bug fixing, code review, SQL, regex, logic, math, structured output, explanation, and format-following.
Results
| # | Category | Task | Result | Wall time |
|---|---|---|---|---|
| 1 | Codegen | Flatten a nested list (iterative) | ✅ Correct stack-based solution | 16.6s |
| 2 | Bug fix | Binary search off-by-one | ✅ Caught the return lo bug |
13.1s |
| 3 | Code review |
max() in Go |
✅ Found 3 real issues | 15.2s |
| 4 | SQL | Top-3 paid per department | ✅ DENSE_RANK() + tie handling |
8.4s |
| 5 | Regex | Valid IPv4 | ✅ Correct | 8.5s |
| 6 | Logic | 8-ball / 2-weighing puzzle | ✅ Correct 3-3-2 strategy | 11.8s |
| 7 | Math | Derivative of x³·ln x
|
✅ x²(3·ln x + 1)
|
5.7s |
| 8 | JSON | Structured output | ✅ Valid JSON, no fences | 5.5s |
| 9 | Explain | JS dedup snippet | ✅ Correct + 2 improvements | 8.0s |
| 10 | Format | Exact bullet-list format | ✅ Followed exactly | 6.2s |
10/10 correct. Total wall time ~99 seconds (avg ~10s/task).
Findings
1. It's fast because it doesn't "think"
Unlike the reasoning models I've tested, Qwen3.8 Max produced zero reasoning tokens — it answers directly. Every task completed in 5.5–16.6s. That's the trade-off this model makes: raw speed over deliberation.
2. The cache-write surprise (the big one)
This is what makes Qwen3.8 Max's cost non-obvious. Look at three requests I measured:
| Request | Cache write | Cache read | Output | Cost |
|---|---|---|---|---|
| Cold cache (first request) | 10,508 | 0 | 126 | $0.027 |
| Warm cache (easy) | 31 | 10,468 | 51 | $0.003 |
| Warm cache (hard) | 1,635 | 11,584 | 264 | $0.0086 |
The first request is ~9× more expensive than the ones that follow. Why? On a cold cache, OpenCode's ~10.5K-token system prompt gets written to the cache at $2.50/M (~$0.026). Once warm, that same prefix is read back at $0.25/M (~$0.0026) — a 10× discount.
So the headline "$6.00/M output" barely matters for short prompts. The real cost is cache-write, one-time per cache lifetime. In a sustained agentic session you pay it once and then cruise on cheap reads.
3. The quality bar is high
The code review was the standout — it caught the all-negative-input bug, the empty-slice edge case, and that the function shadows Go 1.21's built-in max, suggesting the idiomatic max(nums...). That's a detail most junior devs (and several models) miss.
Minor nitpick: the JSON task invented a name ("Jane Doe") when none was given — the same harmless hallucination I saw from other models on person-object prompts.
4. Cost is dominated by caching, not difficulty
Because there are no reasoning tokens, cost doesn't scale with problem difficulty the way it does on a reasoning model. Easy and hard tasks cost nearly the same — the variable is only output length (264 tokens max here) plus any new tokens that miss the cache.
The cost breakdown
| Scenario | Cost |
|---|---|
| Cold-cache request (first ever) | ~$0.027 |
| Warm-cache request (typical) | ~$0.003–0.009 |
| 10-prompt suite total | ~$0.05 |
Against the $15 monthly allowance, the whole test was ~0.3% of my monthly usage — and I did it on the most expensive model on the plan.
Verdict
Qwen3.8 Max is a fast, direct, high-quality model. 10/10 on a mixed coding suite at an average of 10s per task, for roughly a nickel.
The catch isn't the sticker price — it's knowing how you're charged. If you fire single-shot prompts, you'll pay the $2.50/M cache-write penalty on every cold request and think the model is expensive. If you run it the way it's meant to be used — as a sustained agent inside OpenCode — the cache warms up and your effective cost collapses ~10×.
For high-volume, latency-sensitive coding work, that makes Qwen3.8 Max quietly cost-effective. Just don't judge it by your first request.
Same open-source harness and prompts as my GLM-5.3 test. Total spend for this entire Qwen3.8 Max experiment: under **10 cents.
Top comments (0)