
Qwen4 Max Lands in OpenCode Go: What the $15 Allowance Buys, and What a Cache Miss Costs
- GoogleNEWGoogle: Gemini 4 Carbon2026-11-10$2.00 / $10.00 per 1M tokens · 90 tok/s
- AnthropicNEWAnthropic: Claude Fable 5.22026-11-09$8.00 / $40.00 per 1M tokens · 97 tok/s
- orcaNEWOrca: OrcaC2 1.02026-11-0711 tok/s
- OrcaNEWOrcaCyber: GLM 5.3 Abliterated / Uncensored2026-11-04$3.00 / $5.00 per 1M tokens · 89 tok/s
- OrcaNEWOrcaCyber: Hy4 Abliterated / Uncensored2026-11-04$0.80 / $1.60 per 1M tokens · 133 tok/s
- OrcaNEWOrcaCyber: Kimi K3.1 Pro Abliterated / Uncensored2026-11-04$4.00 / $20.00 per 1M tokens · 86 tok/s
- OrcaOrcaCyber: MiniMax M3.1 Flash Abliterated / Uncensored2026-10-29$0.80 / $1.60 per 1M tokens · 127 tok/s
- OrcaOrcaCyber: GLM 5.3 Flash Abliterated / Uncensored2026-10-27$0.80 / $1.60 per 1M tokens · 67 tok/s
- OrcaOrcaCyber: Qwen3.8 Flash Next Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 92 tok/s
- OrcaOrcaCyber: MiMo V2.6 Flash Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M tokens · 45 tok/s
- MoonshotMoonshotAI: Kimi K3.1 Pro2026-10-2447Intelligence
- OrcaOrcaCyber: DeepSeek V4.1 Flash Abliterated / Uncensored2026-10-23$0.80 / $1.60 per 1M tokens · 194 tok/s
- minimaxMiniMax: M3.1 Flash2026-10-1929Intelligence
- OrcaOrca: OrcaCyber Ultra 1.02026-10-17$5.00 / $10.00 per 1M tokens · 136 tok/s
- deepseekDeepSeek: DeepSeek V4.1 Flash 10172026-10-1733Intelligence
- DeepSeekDeepSeek: DeepSeek V4.1 Flash2026-10-1740Intelligence
- OrcaOrca: OrcaCyber Zero 1.52026-10-10$3.00 / $7.50 per 1M tokens · 124 tok/s
- openaiOpenAI: GPT-6.1 Sol2026-09-2955Intelligence
- anthropicAnthropic: Claude Sonnet 5.52026-09-2855Intelligence
- typesafeTypeSafe: Jev 1.132026-09-24$0.04 / $0.00 per 1M tokens · 182 tok/s
OpenCode put Qwen4 Max behind its Go subscription on 16 November 2026, the same day the model moved from preview to metered general availability, and the number that decides whether that is a good deal is not the $1.50 input price. It is 66,000 — the cached-token count OpenCode assumes for a typical coding request when it works out how far your allowance stretches. That single assumption is why a $15 monthly budget is quoted as roughly 2,310 requests on Qwen4 Max and roughly 810 on Qwen3.8-Max, the model it replaces at the top of the same list, and it is also why the same $15 can collapse to about 149 requests if your harness never gets a cache hit. Everything below is arithmetic you can redo from two pages OpenCode publishes, plus one independent benchmark row that says the model is capable, slow and talkative.
What OpenCode actually published, and what it did not
Two surfaces carry the listing and they agree on everything that matters. The Go marketing page at opencode.ai/go shows a row reading "Qwen4 Max — New" with 463 estimated requests per five hours on the $10 Go plan and 1,850 on the $40 Go Plus plan, against a $15 and $60 monthly usage allowance. The documentation at opencode.ai/docs/console/go gives the same model the id qwen4-max, the endpoint https://opencode.ai/inference/go/anthropic/v1/messages, the AI SDK package @ai-sdk/anthropic, and a price line of $1.50 input, $4.50 output, $0.075 cached read and $1.875 cached write per million tokens. Its usage table lists 460 requests per five hours, 1,160 per week and 2,310 per month.
The three-request gap between 463 and 460 on the two pages is not a scandal; it is what happens when one surface is generated from a bar chart and the other from a table. Take the lower figure. What matters more is that the price line is the Singapore rate card to the cent, with no subscription discount applied underneath it.
Three details in that documentation do more work than the headline price:
• The model is served over the Messages protocol, not a chat-completions-compatible path. That is the same route OpenCode uses for Qwen3.8-Max and Qwen3.7 Plus, and it is why a harness that already speaks Messages can point at Go without a shim.
• Privacy is listed model by model. Qwen4 Max is recorded as "Training: Not used" and "Retention: 0 days" — the zero-retention column, not the 30-day column that Grok 4.7 and the Luna models sit in. Go's default also blocks paid endpoints that train on request data.
• Every response reports its cost back as opencode.allowance, and the allowance is denominated in dollars at list price, split into windows of 20% over five hours, 50% over a week and 100% over a month.
What OpenCode has not published is where the tokens come from. The docs explain that some models get large allowances because OpenCode negotiated a bulk discount or reserved GPU capacity, and that others get smaller allowances "either because the model is new or because their public pricing is already discounted" — in which case "you still get a little more than if you paid the model providers directly." Qwen4 Max sits in the second bucket at $1.50 and $4.50, exactly the rate Qwen4 Max carries everywhere. Whether that is a pass-through of the Singapore endpoint or OpenCode's own serving of a 2.4-trillion-parameter model is not stated anywhere, and anyone who tells you which it is, is guessing.
One thing worth correcting up front, because the phrasing around this model has been loose: Qwen4 Max is not an unannounced or leaked release. The launch came with a post titled "Qwen4-Max: Your New Teammate Has Arrived", its Model Studio documentation for the model was updated on 17 November, and there are no weights to inspect — Artificial Analysis records the model as proprietary, and no repository exists to read. The quiet part is OpenCode's listing, which is a coding platform wiring up somebody else's launch, not a launch of its own.

The $15 is a dollar meter, so here is the arithmetic
An allowance in dollars is only meaningful next to the request shape it assumes, and OpenCode publishes that shape: 420 fresh input tokens, 66,000 cached tokens and 200 output tokens per request. Run those three numbers against the Qwen4 Max price line:
• Fresh input — 420 tokens at $1.50 per million is $0.00063.
• Cached input — 66,000 tokens at $0.075 per million is $0.00495.
• Output — 200 tokens at $4.50 per million is $0.00090.
• Per request — $0.00648, which divides into $15 exactly 2,315 times. OpenCode's published estimate of 2,310 per month is that number rounded down.
The same arithmetic on Qwen3.8-Max, which the Go catalogue still sells at $2.00 input, $6.00 output and $0.25 cached read, gives $0.01854 per request and 809 requests for $15 — OpenCode publishes 810. So the switch to Qwen4 Max is worth 2.9× more requests on an identical allowance, and two thirds of that gain comes from one line: the cached read price falling from $0.25 to $0.075 per million, a 70% cut. The headline input price moved 25%. The cache price moved the outcome.
The five-hour window is the constraint you will actually hit. At 20% of the monthly allowance, a rolling five-hour block on the Go plan can spend $3 on Qwen4 Max — 463 requests at the modelled shape, which is roughly a hard afternoon of agent turns if you are not careful. Go Plus lifts that to $12 and 1,850 requests. Go Teams sets each member's allowance at $20 a month, which is more than Go's $15 and less than Plus's $60, at $20 per member.

Where 66,000 cached tokens comes from, and why it is the whole story
Sixty-six thousand cached tokens is not an arbitrary round number: it is a plausible prefix for a coding agent that sends a system prompt, tool definitions and a moderately sized file set on every turn, and it is the reason the modelled request is cheap at all. At $0.075 per million, that 66,000-token prefix costs less than half a cent. At the fresh-input rate of $1.50 it would cost $0.099 — twenty times more, and more than fifteen times the entire rest of the request.
Follow that through. A request whose prefix misses the cache costs $0.1005 instead of $0.00648, so the same $15 buys about 149 requests rather than 2,315. Nothing else about your usage has to change for the allowance to fall by 94%; the prefix just has to stop being reusable. The three ways that happens are mundane: a system prompt with a timestamp or a changing tool list in it, a harness that reorders its context between turns, or a session that keeps rewriting the earliest messages so the cacheable prefix never stabilises.
There is a second, quieter cost. OpenCode prices cached writes at $1.875 per million, which is 25% above the fresh input rate — you pay a premium to establish a prefix that later turns read at a 95% discount. Writing that 66,000-token prefix costs $0.124, about nineteen times a warm request. A session that keeps invalidating its cache pays the write repeatedly and never collects the discount.
This is the reason the allowance is worth understanding rather than just observing. On a model priced like this, cache hit rate is not an optimisation you get to later; it is the difference between two very different subscriptions.
What you give up, measured
The independent scoreboard is full now, and it is less flattering than the price card. Artificial Analysis scores Qwen4 Max 43 on its Intelligence Index — above its stated median of 41, ranked 38th of 81 models on the board — at $3.27 of measured cost per index task. The performance panel, which was still empty when the model was first listed, now carries real figures: 54 tokens per second of output, 159 seconds to the first answer token, and 32.1 minutes to complete one Intelligence Index task against a 13.3-minute median. On the tracker's own ranking that is 75th of 79 for time to first answer token.
• Capability — 43 on the Intelligence Index, 38th of 81, $3.27 per measured task.
• Performance — 54 output tokens per second, 159 seconds to the first answer token, 32.1 minutes per index task against a 13.3-minute median, ranked 75th of 79 on time to first answer token.
• Verbosity — 127 million output tokens to finish the index run, against a 78.6-million median, ranked 65th of 80 on the tracker's own verbosity scale.
• Context — 984k tokens on the tracker's measurement, against the documented 1,000,000-token window with a 991,808-token input ceiling in non-thinking mode.
For an interactive coding loop, the first-answer-token figure is the one that bites. Reasoning models emit nothing until the thinking ends, so 159 seconds is the gap between pressing enter and seeing the first character of an answer, and a long thinking budget pushes that number around rather than away. For batch work — a queue of refactors, a nightly sweep — it is irrelevant, and the $3.27-per-task capability-per-dollar is respectable against frontier models charging several times that.
The verbosity figure deserves its own sentence, because it is the one that interacts with a dollar allowance. A model that generates 127 million tokens where the median generates 78.6 million burns roughly 60% more output tokens for the same set of tasks, and on Qwen4 Max output is the most expensive line in the request at $4.50 per million. Your $15 allowance is denominated in dollars, so a talkative model at the same per-token price simply runs out sooner.

The effort dial is not optional on this model
Qwen4 Max's own documentation sets reasoning_effort to high and thinking_budget to 131,072 when you omit both, and it maps the five-value vocabulary most SDKs use onto three real settings: minimal becomes low, medium becomes high, and max becomes xhigh. Over the Messages protocol, which is the route OpenCode exposes, the knob is output_config.effort with the same three values.
Two consequences follow. First, asking for "medium" effort does not get you a middle setting — it gets you high, the default. If you want the model to think less, you have to ask for low. Second, the output ceiling is shared with the thinking: 262,144 tokens covering chain of thought plus answer in thinking mode, 131,072 tokens of answer with thinking off, against a 983,616-token input ceiling when thinking is on. An agent that pins max_completion_tokens to 262,144 and picks xhigh has decided to spend its allowance on reasoning tokens before it has written a line of code.
The practical setting for an interactive coding session on a metered subscription is low for edits and small refactors, high for the turns where the model has to hold several files at once, and xhigh only for the tasks you would otherwise hand to a person. That is a judgement about your budget, not a benchmark claim — nobody has published a per-effort-level cost curve for this model, and the vendor's own token-reduction figures are vendor figures.
Trying it without moving your stack
OrcaRouter does not route Qwen4 Max today. That should be said plainly rather than implied around: the catalogue carries 215 models, and a request for a qwen4 identifier returns not-found, so if the new flagship is what you want on an OrcaRouter key, you are waiting. What the catalogue does carry is qwen/qwen3.8-max at $2.00 input and $6.00 output per million with a $0.25 cache read — the same rates both OpenCode and the model's first-party API publish — passed through at 0% markup, so a vendor price cut lands on our side the same day it lands on theirs.
Which makes the sensible test cheap rather than free. If you are weighing Qwen4 Max against what you already run, the question to answer first is not "is 43 a good score" but "does my harness keep a 66,000-token prefix warm" — and you can answer that against Qwen3.8-Max on the same account today, at rates you already know, before you spend a subscription on the answer. Pair it with automatic failover and an unproven model becomes a routing decision rather than a migration: send the work at the new model, keep the old one as the fallback, and let the error rate decide.
Who should move now, and who should wait
If you already pay for OpenCode Go, the change costs you nothing to try and the allowance is the reason to try it deliberately rather than casually. Qwen4 Max more than doubles the requests your $15 buys compared with Qwen3.8-Max at the same plan, but it does so through a cache assumption your harness has to earn, on a model that is measurably slow to first token and measurably verbose at default effort. Start at low effort, watch the opencode.allowance field on the first twenty responses, and compare the burn rate against what those sessions would have cost on the model you were already using. If the burn rate surprises you, the cause is almost certainly in your prefix, not in the price card.
If you are not on Go, this listing changes nothing about your options — Qwen4 Max is available through the first-party API in six regions at $1.50 and $4.50 in Singapore and $1.413 and $4.24 in the Global regions, and a subscription that resells it at list price is a convenience, not a discount. And if your work is latency-sensitive and interactive, the honest read of the independent numbers is that this is a model to queue work for, not one to sit and watch.
The thing to watch next is not another benchmark. It is whether OpenCode's $15 allowance for Qwen4 Max survives contact with real usage: the documentation says limits "may change as we learn from early usage and feedback", which is the sentence platforms write before they move a number. A model this new, metered this tightly, on an allowance this small, is the most likely row on that page to be revised first.
Compared in this article1
Detected from this article · Benchmarks: Artificial Analysis · updated daily
