Updated 2026-11-17 · Cameron Voss and Marcus Bell

Qwen4-Max Hands-On Test: Eight Builds, the Spec Sheet and a 1v1 Model Arena

Two months after the Apsara Conference promised Qwen4 was coming, the first retail model is here and it is the only one: Qwen4-Max. This is what eight builds actually produced, including the demo that failed, the spec numbers behind it, and the benchmark platform it built from a single PRD.

What actually shipped?

The September 22 Apsara Conference slide put Qwen4 on the calendar as “coming soon” and gave no date. The first model landed roughly two months later, and the release is deliberately narrow: Qwen4-Max and nothing else.

Neither Qwen4-27B nor the fast tier Qwen4-Flash is out, so anyone waiting for a small, locally runnable Qwen4 still has to wait. Only the largest model is available, and only as a hosted model.

What is inside Qwen4-Max?

Nothing in the block design is new. Qwen3.8-Flash-Next was the architecture preview, and Qwen4-Max is that design at production scale: a hybrid of GDN and QSA attention in a 3:1 ratio, a four-branch gated residual path, and an N-gram embedding layer injected at layer 2 only. Multi-token prediction is retained.

The change that matters is scale. The comparison published with the release puts the backbone at 2.4T parameters, up from 125B — an increase of 2.275T, or about 19.2 times — with 71B activated per token. The auxiliary N-gram embedding table grows from 51B to 328B, and published context support is 1M tokens.

The practical reason people care is the Strata design behind those numbers: experts tiered across VRAM and system RAM, with the large N-gram tables parked on SSD. In the preview generation that was enough to run a quantized 128B model on a 24GB card, which is the best explanation for why the open-weight release is still the thing worth waiting for.

Architecture comparison between Qwen3.8-Flash-Next and Qwen4-Max
Block-level comparison. The layer stack, attention mix, residual structure and N-gram injection point are identical between the preview and the production model.
Qwen4-Max versus the architecture preview
ItemQwen3.8-Flash-NextQwen4-Max
Backbone parameters125B2.4T (+2.275T, 19.2×)
Activated per token6B71B
N-gram parameters51B328B (6.4×)
AttentionGDN + QSAGDN + QSA
Layer mix3 GDN : 1 QSA3 GDN : 1 QSA
QSA indexerLightweight, micro-block selectionLightweight, micro-block selection
Residual pathFour-branch gated residual with read/write gatingFour-branch gated residual with read/write gating
N-gram injectionLayer 2 onlyLayer 2 only
Multi-token predictionAdopted, multi-step trainingRetained in the architecture diagram
Context262,144 native, YaRN to 1MPublished at 1M tokens
QSA retrieval budget512 micro-blocks, about 2,048 tokensNot disclosed
OptimizerMuon + AdamW, split by parameter classFull recipe not disclosed

How did we test it?

Eight runs, one prompt per artifact, no hidden retries. Each demo below was generated from a single prompt; where a run needed follow-up work, the section says so. Every clip is the recorded output, not a reconstruction.

Test set and outcomes
BuildRequirementClipResult
Retro typewriterTypeable text; keys, typebars, ribbon and carriage move in sync; finished paper can be removed0:17Pass
Voxel Japanese gardenDay-night cycle with consistent lighting logic0:17Pass
Nested dollsMatryoshka shells nest without intersecting0:08Bad case
Deep-sea line animationWhale pod outlined by glowing lines, camera through jellyfish, surfacing shot0:30Pass
City from one lineLine becomes road, houses, bridge, train, then a living city0:40Pass
Red umbrella narrative2D ink-line story held together by one umbrella, consistent shadows0:45Pass
Sokoban, six levelsPlan pushes, avoid dead corners, finish every level0:206/6
1v1 model arenaPRD to working benchmark platform with two live model APIs0:51Shipped

Can it build a usable front-end?

The first demo was a working retro typewriter: text you can actually type, a keyboard whose keys and typebars move with the input, a ribbon that advances, a carriage that tracks the line, and a finished sheet you can pull out and keep. It ran on the first attempt, and both the paper texture and the machine rendering held up.

The second was a voxel Japanese courtyard with a full day-night cycle. The sequencing logic is correct — light direction, shadow fall and palette move together — which is the part that usually breaks first. Whether the look lands is a taste call; the lighting logic is not.

Where it breaks is physics. Asked for a set of nesting Matryoshka dolls, the shells clip through each other instead of stacking, a failure that shows the model has a model of how solids look but not of how they occupy space. That same limitation shows up in 3D scenes: geometry is convincing until two objects must share a volume. Treat 3D output as a first draft that needs a human pass on contact points.

Separately, the default visual style is serviceable rather than good. Expect to art-direct: supply a reference, name the assets that must appear, and ask for a specific layout. Left alone, it produces something that works and looks like a template.

Clip 1 (0:17) — the typewriter demo: synchronized keys, typebars and carriage, with a removable sheet of paper.
Clip 2 (0:17) — voxel courtyard with a day-night cycle. The lighting logic holds; the aesthetic is a judgment call.
Clip 3 (0:08) — the bad case: nested dolls intersecting instead of enclosing one another.

How good is it at motion graphics?

Three animation briefs, three usable results — the strongest part of the test set. The first is a 30-second deep-sea sequence: glowing white lines draw a pod of whales out of black, the camera passes through drifting jellyfish, then follows one whale up to the surface.

The second starts from a single line on paper and turns it into a road, houses, a bridge, a passing train, and finally a city with people in it. Forty seconds, one continuous camera idea, no dead frames.

The third is the most narrative: a two-dimensional ink-line story carried by a single red umbrella. Shadow handling and small details are good; the human motion is over-amplified, which is the one thing to fix in review.

What made all three work was the shape of the brief, and you can copy it: a shot list with explicit camera moves, a fixed palette, stated durations per beat, and a hard rule against on-screen text. When any of those were missing, the model filled the gap with generic motion.

Clip 4 (0:30) — deep-sea line animation: whale pod, jellyfish pass, surfacing shot.
Clip 5 (0:40) — a drawn line becomes infrastructure, then a city.
Clip 6 (0:45) — red umbrella ink narrative. Strong continuity and shadow work; exaggerated character motion.

Does it solve Sokoban?

The Sokoban harness is a six-level puzzle built to measure three things at once: visual planning, spatial understanding, and how long the model thinks before it commits. Qwen4-Max cleared all six levels. A preview build of the same model family failed level five by pushing a box into a dead corner, and that failure is gone in the release build.

Two caveats. Every model in this harness still oscillates — it reverses a move, reconsiders, and reverses again — so a clean solve does not mean a clean plan. And on the same harness it used fewer tokens and fewer steps than the other domestic models tested, which matters more than the level count: the win is efficiency, not just correctness.

Clip 7 (0:20) — six-level Sokoban run. All levels cleared.

Can it plan and ship a real project?

The last test was deliberately not a demo. It was a full project: build a benchmark that pits two models against each other in a game with enough state to be interesting, then actually implement it.

Step 1, pick the game. Asked whether Werewolf or Sanguosha would make the better LLM benchmark, the model searched and compared, and argued reasonably that Werewolf measures social intelligence and is the more differentiated bet against existing math and code leaderboards. It also produced the counterargument that mattered more: Werewolf already has public leaderboards and each match is token-hungry, while Sanguosha fits a controlled 1v1 at a lower cost. It then recommended an open-source Sanguosha engine with existing content to build on.

Step 2, read the engine before writing code. Asked how hard it would be to turn a human-versus-human game into AI-versus-AI, it pulled the repositories and read the source instead of guessing. The answer came back with file-and-line evidence: every player already instantiates an AI (serverplayer.lua, line 35, self.ai = SmartAI:new(self)), a per-request-type strategy layer exists, human and bot players share one request and reply path, and bots can be enabled from config. There is no native 1v1 mode in the core repo; the 1v1 rules live in a separate extension.

That produced a plan instead of a rewrite: implement an LLM adapter class, swap the mount point, serialize state into a prompt with per-player information isolation, parse the response back into legal move IDs, and fall back to the heuristic AI on timeout or invalid output. The rules engine, which is the genuinely hard part, is left untouched.

Step 3, PRD to running platform. Given the PRD and two model API keys, it scaffolded the platform: secrets handling, a local config file, dependency install, and a connectivity check for both APIs before writing any game logic.

Step 4, first version, then art direction. The first build worked and looked like an admin dashboard, ignoring the card art already in the repository. Two constraints fixed that in a few rounds: supply a reference visual style, and require the hero and card images to actually appear. The refined build runs a real match in the clip below, Qwen4-Max as Guan Yu against Kimi K3.1 Pro as Sun Quan at seed 11.

The part that still needs engineering is thinking time. Some decisions took longer than the per-turn clock a match allows, so the harness needs a real timeout-and-fallback policy rather than a generous timer. Budget for it: a long reasoning trace helps right up to the moment it loses a turn on time.

Clip 8 (0:51) — the refined arena in a 1v1 match between two different models.

How does it compare with Claude and GPT?

It wins inside its own league and loses outside it. Among domestic models it is the head of the pack; this test set produced nothing that another domestic model clearly did better. Against Claude and GPT it still gives up ground on complex work, and that gap widened once the latest international release landed.

The nuance is that the gap is now mostly about the ceiling, not the floor. For the bulk of everyday work — drafting, refactoring, office-style agent tasks, game prototyping — the domestic tier is sufficient. It is the hard, long-horizon jobs where the difference shows, and those are exactly the jobs you cannot afford to have redone.

What should you try first?

Five patterns produced the results above, in the order they pay off. The first three matter most: almost every failure in this test set came from a brief that named the artifact but not its behaviour.

Prompt patterns that changed the output
PatternWhat to writeWhy it works
Name the artifact, then the rules"Build a typewriter where typed characters print, keys and typebars move with input, the ribbon advances, and the sheet can be removed."The behavioural list is what makes the demo work on the first pass; an artifact name alone does not imply the behaviour.
Write a shot list for animationCamera move, palette, beat durations, and an explicit ban on on-screen text.Without a shot list you get motion; with one you get a sequence.
Make it read before it writesFor any codebase task, ask for the mount points by file and line before any code is generated.You catch a wrong assumption in one message instead of one rewrite.
Art-direct UI work explicitlyA reference visual style plus the assets that must appear.Default output is competent and forgettable; constraints are what change it.
Cap thinking timeA timeout and a fallback branch for anything with a turn clock: a game, an agent loop, a UI with latency.Long reasoning traces are useful until they lose a turn on time.

FAQ

Is Qwen4-Max available right now?

Yes. As of November 17, 2026 it is the only Qwen4 model shipping. Qwen4-27B and Qwen4-Flash have not been released.

How big is Qwen4-Max?

The backbone is 2.4T parameters, up from 125B in the Qwen3.8-Flash-Next preview, an increase of about 19.2 times, with 71B activated per token. The N-gram embedding table grows from 51B to 328B.

What context window does Qwen4-Max support?

Qwen4-Max is published as supporting 1M tokens. The preview model had a native window of 262,144 tokens extended to 1M with YaRN, so treat the 1M figure as the long-context mode rather than free accuracy at any length.

Why does it fail at physics demos?

Because it models appearance better than it models solids. Nested shells intersect, and 3D scenes are convincing until two objects must occupy the same volume. Add a human pass on contact points before shipping that output.

Can Qwen4-Max replace Claude or GPT for coding?

For prototyping and everyday work, largely yes. For hard multi-step engineering it is still behind, and the cost of a wrong long-horizon decision is high enough that the gap matters.

Is Qwen4 open source yet?

No. Only the hosted Qwen4-Max is available. The Strata design — experts tiered across VRAM and RAM with N-gram tables on SSD — is why the open-weight release is still worth waiting for.

Qwen4-Max is not the generational step its version number implies. It is a larger, more efficient model on the same architecture: shorter thinking traces, fewer tokens per task, better planning, and a clear lead among domestic models. What it does not do is close the gap to Claude and GPT on hard work, and its weak spots — front-end taste and physical plausibility — are the ones that bite first in production. Score it as the best domestic model available today, not as a new ceiling.