Qwen 3.7-Max, the newest AI model from Alibaba, was released at the Alibaba Cloud Summit this month, and the benchmark numbers got my attention, as well as the reactions on X from developers who had already spent time with it. As expected, when a new model gets that kind of early noise I do not just read about it, I test it myself.

My go-to test is a physics-driven cloth flag simulation built in raw WebGL, contained in a single HTML file with no external libraries. It sounds niche but it is a genuinely hard brief. The model has to handle 3D graphics, real physics, user interaction, and a clean UI all in one pass with no shortcuts. I have run this same test with GPT-5.5 and Cursor Composer 2.5, both of which I have written about here, and it has become my personal benchmark for seeing what a new model can actually do rather than what a spec sheet says it can do.

Qwen 3.7-Max was next. The journey to getting it set up and running on my Mac is quite a story on its own. But the output at the end of it was something I would genuinely put on a landing page.

Here is how it went.

What is Qwen 3.7-Max?

Qwen 3.7-Max is Alibaba’s newest flagship AI model, announced on May 20 at the Alibaba Cloud Summit in Hangzhou. Alibaba is the Chinese tech giant behind AliExpress and Alibaba Cloud, and Qwen is their family of AI models, similar to how OpenAI has GPT and Anthropic has Claude.

This particular model is built for what Alibaba calls the agent era, meaning tasks that require an AI to work autonomously across many steps rather than just answering a single question. Think of the difference between asking someone a question and handing them a project to run unsupervised.

The headline claim is 35 hours of continuous autonomous execution on a real engineering task, with over 1,000 tool calls and no human stepping in. On independent benchmarks it currently sits at number three out of 117 models overall and number four specifically in coding. It edges out GPT-5.5 on reasoning and coding, though GPT-5.5 takes the lead on agentic tasks specifically.

One thing worth knowing before you go looking for it: Qwen 3.7-Max is closed weights, meaning there is no file to download and run on your own computer. Access is API only, which means you send requests to Alibaba’s servers and the model runs there. Alibaba has said an open-source version is coming but as of this writing nothing has shipped.

Pricing sits at $2.50 per million input tokens and $7.50 per million output tokens. If you are not familiar with token pricing, a rough rule of thumb is that one million tokens is roughly 750,000 words of text. For casual testing and small projects the cost is minimal.

Setting up Qwen 3.7-Max: the part nobody documents

This is where most write-ups skip straight to the demo. I am not going to do that because the setup is where I lost the most time, and if you want to try this yourself you should know what to expect.

Qwen 3.7-Max is accessed through a service called Alibaba Cloud Model Studio. Think of Model Studio as the dashboard where Alibaba manages access to their AI models, similar to how OpenAI has the Platform dashboard or Anthropic has their Console.

The first thing to know is that, if you have used Alibaba Cloud before for hosting or infrastructure, you are probably used to something called an AccessKey and Secret pair, which is essentially a username and password for their APIs. Model Studio does not use those. It uses what they call a Standard API key, which you generate separately from the Token Plan section inside Model Studio.

I initially created a RAM user, which is Alibaba’s way of creating a restricted sub-account with specific permissions rather than using your main account for everything. That is a good security habit, but I learned the hard way that Qwen Code, which is Alibaba’s own coding tool, specifically expects the Standard API key. Feeding it RAM credentials just produces auth errors with no clear message telling you what went wrong.

The fix is straightforward once you know it: go into Model Studio, find the API Key section on the Dashboard, and generate a Standard API key from there. That is the key you will use for everything in this guide.

Verifying the setup with a curl test

Before installing any tools, I wanted to confirm the key was working with a simple raw test. I did this in the Mac Terminal, which is the built-in command line application on any Mac. You can find it by searching Terminal in Spotlight.

A quick note for Windows users: the commands below use curl, which is a tool that sends web requests from the command line. On Mac and Linux it comes pre-installed. On Windows 11 and recent Windows 10 builds, curl is available in PowerShell, but the single-quote syntax in the examples below may not work in the standard Command Prompt. Windows users are better off using PowerShell or a free tool like Postman to run the same test visually without the command line.

Here is the test I ran in Mac Terminal. Run each line one at a time by pasting it into Terminal and pressing Enter.

bash

export DASHSCOPE_API_KEY="your_modelstudio_api_key"

This first line stores your API key as a temporary variable in your current Terminal session so you do not have to type it out every time you need it. Replace the text inside the quotes with your actual key from Model Studio. The word export just tells your Terminal to make this variable available to any commands you run in the same session.

bash

curl https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -d '{
    "model": "qwen3.7-max",
    "messages": [
      {"role": "user", "content": "Reply with only the word: working"}
    ]
  }'

What this does: curl is sending a message to Alibaba’s international API endpoint and asking the qwen3.7-max model to reply with just the word “working.” The -H lines are headers that tell the server what format the data is in and authenticate your request using the key you stored above. The -d section is the actual message you are sending, structured the same way any AI chat API expects it.

The response came back with the model field showing qwen3.7-max and the content showing “working.” That confirmed three things: the endpoint is correct, the key is valid, and 3.7-Max is actually available on my account. Only after that did I move on to installing Qwen Code.

Wiring Qwen Code to Qwen 3.7-Max

Qwen Code is Alibaba’s terminal-based coding agent. If you have heard of Claude Code, it is the same concept: you run it from your project folder in the Terminal, and instead of writing code manually you describe what you want in plain English and the model writes and edits the files for you. It is the vibe coding workflow applied to a real project folder on your computer.

To install Qwen Code, open your terminal (on a Mac) or Powershell or CMD (on windows) and ran the command:

npm install -g @qwen-code/qwen-code@latest
qwen --version

Follow the instructions at the official Qwen Code documentation page. Once installed, you launch it by typing qwen in your Terminal from inside a project folder.

The first time you launch it, Qwen Code asks you to choose an authentication type. The options are:

• Coding Plan
• Token Plan
• Standard API Key

Choose Standard API Key and paste in the key from Model Studio. That part works without issues.

What did not work immediately was finding the right model. When I ran the model command inside Qwen Code to see what was available, the list only showed:

• qwen3.6-plus
• glm-5.1
• deepseek-v4-pro
• deepseek-v4-flash

Typing qwen3.7-max to switch to it produced this error:

model qwen3.7-max is not available for auth type openai

The issue is that Qwen Code organises models by provider type, and 3.7-Max lives under a specific Model Studio Standard API provider entry that is separate from the general model list. The fix is to go back into the Auth settings inside Qwen Code, find the Model Studio Standard API provider specifically, and set qwen3.7-max as the model there rather than trying to select it from the general list. Once done, the correct model name appears at the top of the Qwen Code screen and your prompts start routing to 3.7-Max.

With that sorted, setting up a project folder is straightforward. In Mac Terminal, here’s the command i ran to set up a folder ‘QwenTest1’ and then teh command that launched Qwen from that folder:

bash

mkdir -p ~/Documents/qwenTest1
cd ~/Documents/qwenTest1
qwen

Code breakdown: The first command creates a new folder called qwenTest1 inside your Documents folder. The mkdir -p part means “create this folder and any parent folders needed if they do not exist yet.” The second command, cd, stands for “change directory” and moves you into that folder. The third command starts Qwen Code from inside it, so the model can see any files you create there as context for your prompts.

The build: a WebGL cloth flag in one HTML file

I did not want the first real test to be a Python function or a basic CRUD app. I wanted something visual, something with physics, something that would push the model’s ability to hold a complex system together across multiple rounds of editing.

The brief was: raw WebGL with no external libraries, real cloth physics using a technique called Verlet integration where each point on the fabric remembers its previous position to calculate realistic movement, a draggable flag that reacts when you click and pull it, and everything contained in a single HTML file you can open directly in a browser.

WebGL, if you are not familiar with it, is a technology built into browsers that lets you render 3D graphics using the graphics card rather than the CPU. It is fast and powerful but also low-level, meaning there is a lot of boilerplate code involved. Asking an AI to write raw WebGL from scratch without any helper libraries is a genuine test of how much it can hold in context at once.

The refined prompt I used was detailed and strict about the output format are available in my Github repo here . The key requirements I gave it were:

• One HTML file only, no external dependencies
• Raw WebGL and vanilla JavaScript
• Cloth simulation using a particle grid with constraints
• Left edge pinned to act as a flagpole attachment
• Wind, gravity, damping, and turbulence forces
• Click and drag interaction on the fabric
• Control panel with sliders for each simulation parameter
• Dark premium UI aesthetic
• August Wheel branded flag texture generated procedurally

The first output ran in Chrome without errors. That alone was notable given how much the prompt was asking for. WebGL buffer setup, shader code, physics integration loop, mouse interaction, and UI sliders, all in one pass.

The initial version was dark though. The physics were working but the cloth was hard to read visually and the branding was minimal. That is where the real work started.

Iterating with vibe coding: from dark prototype to something I’d actually ship

This is the part of vibe coding that is hard to explain until you experience it. You stop thinking about code and start thinking about what you want.

The real test of any coding model is not whether it can write a first draft. It is whether it can take direction on top of its own code without breaking what already works.

I ran several focused passes after the initial build, each one layering something new on top without touching what was already working.

The first follow-up asked the model to brighten the environment, improve the key, fill, and rim lighting so the folds in the cloth were readable, and make the flagpole visible without blowing out the highlights. Qwen updated the shader code and lighting parameters while leaving the physics loop completely intact. The cloth immediately felt more three-dimensional. You could actually see the fabric bending.

Next I gave the model stricter visual direction: an ivory or warm white base for the flag, dark crisp typography, colour accents from the August Wheel palette, and the words AUGUST WHEEL clearly readable while the flag was moving.

Then I introduced a sunset sky image as the backdrop and asked Qwen to use it as the environment with a subtle overlay. I also asked it to refine the control panel into a proper sidebar with better spacing and type, and add a hero label at the top reading AUGUST WHEEL — INTERACTIVE FLAG LAB and a footer caption reading Physics-driven cloth simulation in raw WebGL. Again, the physics engine stayed untouched. Each pass was surgical.

After the main three passes I kept going. I started experimenting with the flag itself as a design surface, asking Qwen to swap the color from the original to deep wine red, then to green, then to a checkered pattern. Each change came from a short prompt and applied cleanly. The cloth simulation did not care what the flag looked like. The physics just ran on top of whatever texture the model generated.

This is the part of vibe coding that is hard to explain until you experience it. You stop thinking about code and start thinking about what you want. The model handles the translation.

The final demo

The current version is live at qwen3-7-flag-demo.vercel.app and the full source with prompt is on GitHub.

When you open it you get an August Wheel branded flag flapping against a cinematic sky backdrop. You can grab the fabric with your mouse, drag it in any direction, and watch the mesh react with realistic physics. The right-hand control panel gives you sliders for wind strength and direction, turbulence and gust intensity, cloth stiffness and damping, gravity, and bend resistance.

There are also wind presets including Calm Breeze, Coastal Flow, and Storm Pulse, a Showcase gust button that triggers a dramatic wind burst, auto-orbit mode that slowly rotates the view around the flag, and a Flag Style toggle for switching between the color variants I built during the iteration passes. A Debug toggle and Quality setting let you inspect and tune the simulation if you want to go deeper into how it works.

The entire thing is one HTML file. Vanilla JavaScript. Raw WebGL. No libraries. Built through a series of natural language prompts in a terminal on a Mac.

What Qwen 3.7-Max did well and where it struggled

What impressed me was the combination of WebGL and physics in a single pass. Shader code, particle updates, constraint solving, UI, and interaction handling, all together without external libraries, and it ran first time. That is a lot of context to hold.

The iterative art direction also held up well. Most models start breaking things when you ask them to edit their own complex code across multiple rounds. Qwen kept the structure intact and applied targeted changes each time. Lighting, branding, environment, color variants, each pass landed without undoing the previous one.

Where it struggled was the setup story itself. The distinction between a RAM AccessKey, a Model Studio Standard API key, a Coding Plan credential, and a Token Plan credential is genuinely confusing, and the error messages when you pick the wrong one do not tell you what went wrong. That friction sits with Alibaba’s product team rather than the model, but it is real friction you will hit.

The early visual drafts also needed human direction. The model can build the system but it cannot supply taste. Knowing what premium looks like, when the colours are off, and when something is ready to ship, those judgements still come from you.

Try it yourself

If you want to replicate this experiment:

1. Create an Alibaba Cloud account and navigate to Model Studio
2. Generate a Standard API key from the Token Plan section, not an AccessKey pair
3. Open Terminal (if using a Mac) and verify the key works with the curl test above before installing anything
4. Install Qwen Code, choose Standard API Key as the auth type, and configure qwen3.7-max inside the Model Studio Standard API provider settings specifically
5. Create a project folder using the mkdir command above, start Qwen Code from inside it, and give it a detailed single-file brief
6. Iterate in focused passes: physics first, lighting second, branding third, then keep going

The model is real. The setup has rough edges. And the output, when you push it through a few focused iterations, is something you can actually ship.

FAQ

How do I set up Qwen 3.7-Max on my Mac for coding? You need an Alibaba Cloud account with access to Model Studio. From there, generate a Standard API key from the Token Plan section, not a regular AccessKey pair. Open your Mac Terminal, search for it using Spotlight if you have not used it before, and verify the key works using the curl test in this post. Then install Qwen Code, choose Standard API Key as your auth type, and configure qwen3.7-max inside the Model Studio Standard API provider settings specifically.

What is the difference between Qwen Code and Claude Code? Both are terminal-based coding agents that run from your project folder and accept natural language instructions. The main difference is which model they connect to by default. Qwen Code routes to Alibaba’s Qwen models through Model Studio. Claude Code routes to Anthropic’s Claude models. Both can be configured to use third-party models through compatible API endpoints, but out of the box they each point to their own provider.

Can Qwen 3.7-Max build a full app from a single prompt? For self-contained single-file projects with no external dependencies, yes, the first-pass output can be genuinely usable. Larger multi-file projects with databases, authentication, and deployment will need more iteration and more specific prompting. The model is strong on first-pass code generation but the polish and direction still come from you across multiple passes.

Will the setup commands work on Windows? The curl command works on Windows 11 and recent Windows 10 builds through PowerShell, but the single-quote syntax used in the examples above may cause issues in the standard Command Prompt. Windows users are better off running the curl test in PowerShell directly, or using a free tool like Postman to send the same API request through a visual interface without needing the command line at all. The Qwen Code installation and project folder steps work across platforms once you have it installed.

What is WebGL and why does it matter for this demo? WebGL is a technology built into modern browsers that allows web pages to render 3D graphics using your computer’s graphics card directly. Most interactive 3D things you see in a browser without downloading an app are using WebGL under the hood. The reason it matters for this demo is that writing raw WebGL is genuinely complex, which made it a meaningful test for the model rather than a simple task.