Back to Home

Qwen4 Max on OpenCode Go: A $15 Survival Guide

Qwen4 Max arrived on OpenCode's own endpoint on 16 November 2026, and by the 18th it sat in the Go catalogue next to the older Qwen3.8-Max. The pitch writes itself: same $10 plan, more than double the requests, a flagship model on a flat fee. The fine print says the deal rests on one assumption about your prompt prefix, and that assumption is yours to keep or break.

OpenCode prices Go in dollars, not requests. Your $15 monthly allowance is spent at list price, and every response reports what it cost in an opencode.allowance field. That single design choice means a model with a different cache policy is a different subscription, even when the plan price does not move.

The 66,000-token assumption

OpenCode models a typical coding request as 420 fresh input tokens, 66,000 cached tokens and 200 output tokens. Run that shape against the Qwen4 Max rate card, which reads $1.50 per million input, $0.075 per million cached read, $1.875 per million cached write and $4.50 per million output, and one request costs about $0.0065. Multiply by 2,310 and you have spent $15.

The same arithmetic on Qwen3.8-Max, at $2.00 input, $0.25 cached read and $6.00 output, gives $0.0185 per request and 809 requests. So the switch is worth roughly 2.9 times more turns on an identical allowance, and two thirds of that gain comes from one line item: the cached read price fell 70%. The headline input price only moved 25%. The cache price decided the outcome.

Two surfaces publish the same numbers with a rounding difference. The Go marketing page shows 463 estimated requests per five hours on the $10 plan, which is the $15 allowance, and 1,850 on the $40 Go Plus plan, a $60 allowance. The documentation table shows 460 per five hours, 1,160 per week and 2,310 per month. Take the lower of each pair; a three-request gap between a bar chart and a table is not the story.

If the prefix does not hit the cache, those 66,000 tokens bill at the fresh input rate instead of $0.075 per million. The formula goes from about $0.0065 to about $0.1005 per request, and the same $15 buys roughly 149 requests. Nothing else in your workflow has to change. The prefix merely has to stop being reusable.

Three ordinary things break it: a system prompt carrying a timestamp or a version string that changes, a tool list that reorders itself between turns, and a session that keeps rewriting its earliest messages. All three are invisible in a transcript and cost fifteen times the warm price.

There is a smaller trap on the other side. Cached writes bill at $1.875 per million, 25% above the fresh input rate. Establishing a 66,000-token prefix costs about $0.124, roughly nineteen times a warm request. A harness that invalidates constantly pays that write again and again and never collects the discount.

Four steps before your next session

Treat the first twenty responses as a measurement, not a workflow. The goal is a burn rate you can predict, not the highest possible request count.

  1. Freeze the prefix. Strip timestamps, session ids and anything generated per run out of the system prompt, and keep the tool definitions in a fixed order. A stable prefix is the whole product.
  2. Set effort to low for edits. Qwen4 Max ships with reasoning effort at high and a 131,072-token thinking budget when you specify nothing. Most single-file edits do not need that.
  3. Read opencode.allowance on the first twenty calls. Compare the actual spend against what the same session would have cost on the model you were using last week.
  4. Watch the five-hour window. It caps you at 20% of the monthly allowance, so a hard afternoon on the Go plan can spend your $3 slice long before the month is over.

The effort dial is documented and still widely ignored. Qwen4 Max maps five common effort values onto three real settings: minimal becomes low, medium becomes the default high, max becomes xhigh. Asking for medium does not buy half the reasoning, it buys the full default. Over the Messages protocol the knob is output_config.effort.

Output ceiling is shared with thinking: in thinking mode the 262,144-token ceiling covers chain of thought plus answer, and an agent that pins max_completion_tokens at the top while asking for xhigh spends its allowance on reasoning before a line of code exists.

What you are actually buying

The independent scoreboard is less flattering than the price card. Artificial Analysis scores Qwen4 Max 43 on its Intelligence Index, ranked 38th of 81 tracked models. It registers 54 output tokens per second, 159 seconds to the first answer token and 32.1 minutes to finish an index task against a 13.3-minute median. On verbosity it generated 127 million output tokens where the median generated 78.6 million.

Read that combination in money, not vibes. Output is the most expensive line on this model at $4.50 per million, so a model that talks 60% more than its peers drains a dollar-denominated allowance faster at the same per-token price. And 159 seconds to first token is the real cost of an interactive loop, because reasoning models emit nothing until the thinking ends; a long thinking budget moves that gap around rather than closing it.

Queue work, do not watch work. Batch refactors, nightly sweeps and test backfills belong on Qwen4 Max at low effort. Live pair programming does not, not until the first-token number changes.

One caveat worth carrying into next month: OpenCode's own documentation says usage limits may change as it learns from early usage. On a model this new, metered this tightly, the Qwen4 Max row is the most likely line on that page to be revised first. Keep the measurement habit after the novelty fades, because the number you are defending is the hit rate on your prefix.

Comments

No comments yet. Be the first to share your thoughts!