What's new: the biggest gains are in long-horizon tasks

The official line is a boost across four areas: coding, office work, research, and long-running tasks. The core pitch: reliable end-to-end delivery, taking a task from start to finish without human intervention.

On the same benchmark sheet against the previous flagship, Qwen3.7-Max, the gains are concentrated in projects requiring many sequential steps:

In a simulated year-long online store, it ended with 152% more cash than the previous generation. Single-turn Q&A gains were far smaller: GPQA Diamond (graduate-level science Q&A) went from 92.4 to 92.6 — nearly flat. The improvements are all in long-horizon tasks.

Mixed benchmark results: coding lags behind Claude's best, but multimodal is a strength

The launch page directly compares Claude Opus 4.8, Claude Fable 5, GPT-5.6 Sol, and Gemini 3.1 Pro, openly showing both wins and losses:

The gap in coding is clear: it trails Claude Fable 5 by over twelve points on SWE-bench Pro. On the other hand, it beats the runner-up by 10 points on instruction following, leads in paper reproduction, and tops the leaderboard for document parsing, long video understanding, and computer operation. Multimodal is clearly its home turf, but it doesn't win everything—Fable 5 is still higher on screen element location and Android phone operation.

Official performance overview. Source: Qwen launch page

One footnote detail: a significant portion of the coding benchmarks used Claude Code as the evaluation harness. They tested their own model with a competitor's tool, ensuring the framework gives them no edge. The blank cells for Fable 5 are marked as no scores available.

16 days, no human intervention: it takes requirements, writes code, runs tests, logs 265 commits

First challenge: start from an empty folder and build a command-line tool called oh-my-cli — no human involvement at any point.

It set up an autonomous loop: user feedback and community practices became GitHub issues, assigned via a state machine. It wrote the implementation, ran builds, unit tests, and end-to-end tests, merging only when everything passed. If any step failed, the task was automatically sent back for revision. It also kept upgrading this very loop, adding features like /goal, /resume, session replay, and a desktop version along the way.

By July 30th, after about 16 days of autonomous operation, the repository had 265 commits, 127 PRs, and 151 issues. The entire process is publicly available in the GitHub repo qwen-code-dev-bot/oh-my-cli, where every commit can be reviewed.

A paper plus a GPU cluster: five days to reproduce six findings — and find a better method

Second challenge: research. It was given a data selection paper from May this year and a GPU cluster — but no existing code, and the sources section contained neither the paper's title nor a link. The paper addresses a practical problem: when training data is vast and budgets are tight, which samples should you keep? Its answer: select samples with more "hard choice points"—moments during problem-solving where the model genuinely hesitates about which direction to take.

It spent about 37 hours writing the whole pipeline from scratch — roughly 7,600 lines of code covering data processing, training, and evaluation. Then it reproduced all six of the paper's main findings: using the paper's selection method and fine-tuning Qwen3-8B (an 80-billion-parameter open-source small model — the experiment wasn't run on itself) improved AIME24, a competition math benchmark, by 7.7 points over random selection.

Reproduction took the first 37 hours. For the next 88 or so, it entered a research loop: propose a hypothesis, write code, train on GPUs, analyze results, start the next round. Over four rounds, it proposed and tested 18 ideas:

Round three's score dipped 0.4 points from round two, and the table keeps that setback as is. The winning idea turned out to be the simplest: instead of a complex weighted score, just count the number of "hard choice points" in each sample. All told, about five days (125 hours) of continuous operation, over 1,100 steps, and 33 rounds of GPU training—with no one touching the keyboard.

A real Tianchi competition: 45 submissions, score climbs from 0.60 to 0.853, beats 87% of human teams

Third challenge: real opponents. The WWW2025 multimodal dialogue intent recognition competition on Alibaba Cloud's Tianchi platform had 526 human teams. The task was to read e-commerce customer service dialogues—text plus product screenshots—and determine what the customer truly wants. The time limit was 24 hours.

After reading the rules, it devised a strategy: fine-tune several Chinese text models and a vision model, fuse them into a weighted voting system, and calibrate the weights with cross-validation. Over 45 submissions, each leaderboard feedback informed the next iteration, pushing accuracy from 0.60 up to 0.853. That beat 458 human teams—87% of the field.

The case that can't be faked: bit-exact output required, chip shrinks from 8,298 gates to 678

The toughest long-horizon task: designing a hardware circuit for cryptographic operations (a GCD/RSA accelerator). There's no room for inflated numbers here. Functional verification requires bit-exact output: under random testing, the output for all four bit-widths must match the ground truth on every single binary digit. One wrong bit means failure. Only after passing this do you compete on using fewer logic gates, with the gate count calculated by the synthesis tool Yosys—not judged by humans.

It was given only a task description, an empty interface skeleton, and an evaluation script — no reference design. It worked continuously inside a tool sandbox for simulation, synthesis, and physical design, across about 500 rounds of interaction and 71 evaluations. The gate count dropped like this:

It was still making major structural changes even after hundreds of rounds: past round 170, it was still breaking module boundaries for architectural refactoring, not just making small tweaks. The final 678-gate result is, according to the official report, the best among models evaluated in the same setting, though the participant list wasn't made public.

The final design went through a real place-and-route flow (OpenROAD, Nangate45 process library) to generate an actual chip physical layout:

Meeting timing means the circuit genuinely runs stably at the target 500 MHz frequency; the 80% area savings translate into a real-world, physically manufacturable chip with measurable results.

Simulated Year-Long Online Store: ¥100,000 Grows to ¥416,000, While Spotting 152 Fraudulent Suppliers

E-Commerce Bench is a simulated environment built from real, anonymized Taobao and Tmall data: 365 days, 12 store types, 60 categories, 7,000 products, and nearly 600 suppliers. Starting with ¥100,000 across several shops, you handle product selection, pricing negotiations, inventory, pricing, and returns on your own, aiming for the highest total cash by year-end.

The difficulty is baked into the environment. Suppliers are driven by a game-theory core, each with distinct personalities and negotiation strategies, requiring rounds of natural language bargaining. Among the 600 suppliers, 152 are fraudulent, using tactics like membership fee traps, low-price bait, and shipping goods that don't match descriptions. The year also includes massive promotional surges and typhoon-induced supply chain disruptions.

The official highlight is how it "learns as it plays": prices for the same product from the same supplier get progressively pushed down through negotiation, and the lessons learned carry over to similar products. Across over 2,000 interaction rounds, its bargaining efficiency kept climbing, while other compared models generally peaked midway. During the year-end sales surge, its net profit exceeded ¥100,000—nearly 2.4 times that of GLM 5.2.

Trying Out Hundreds of Professions: A Week of a Legal Team's Work, Completed in One Hour with 1,284 Annotations

All the above are stress tests. Back to daily use: they selected high-frequency work scenarios from hundreds of high-value professions and tried them one by one, with six examples on the launch page that include comparisons.

One Sentence to Launch a Quantitative Research Project

Another major case was for a quantitative researcher: a single sentence describing the task, and it worked for hours on end. It built the data system, developed factors, ran backtests, changed direction based on evidence mid-course, detected overfitting signals (where in-design metrics improve but validation metrics decline), and then automatically pruned redundant factors. When multiple paths converged on the same signal set, it added multi-seed cross-validation. In breadth, six classic factor categories were broken down from six sentences into 50 research directions each, dispatching about 330 sub-agents for parallel mining. With roughly 6,000 backtests total, the selected factors achieved excess Sharpe ratios (a standard measure of returns per unit of volatility) between 0.64 and 1.48, and daily Rank IC (a metric for the accuracy of factor direction prediction) was positive across the board.

Where Does the Capability Come From: Training Environments Broken Down into Three Dimensions, Combined Like LEGO to Create Massive Variety

After the case studies, the launch page unusually details its training methodology: these work capabilities come mainly from large-scale reinforcement learning, where the model repeatedly works in real-world environments and is scored on results. The challenge is where to source the practice environments: real work is incredibly diverse, and hand-crafting environments one by one can't keep pace with training demand.

Their solution: decompose the environment into three independent dimensions, expand each separately, then cross-combine them:

Two supporting pieces: a unified reward system—if code runs, verify with execution results; for visual outputs like web pages, score the rendered appearance against a rubric, plus agentic checks, so all environments share a consistent scoring standard. And an online data balancer: it calibrates each training batch across tasks, difficulty, workspace, and harness, keeping gradients stable and enabling scalable compute.

Official chart: as RL training scales up, scores on dozens of work-related benchmarks steadily improve. Source: Qwen launch page

A harness is the tool system wrapped around the model that reads files, executes commands, and manages the workflow for it. Since it was trained and tested inside other people's tools like Claude Code and Codex, swapping the harness shell doesn't cause performance to collapse.

Official chart: the same model performs comparably across QwenWork, Claude Code, Codex, OpenClaw, and Hermes. Source: Qwen launch page

Eyes on the Work: Spots the TV is Backwards and Fixes It

The input specs get a brief mention: it can read a 200+ page financial PDF into a structured report across pages, and organize over 100 hours of long video into a searchable "video graph memory" where people, events, times, and scenes are linked into a network for instant retrieval.

The real shift this generation is on the other end: vision is now embedded in the execution process. While performing tasks, it continuously examines its own intermediate outputs—page layouts, object orientations, animation effects. If a rendered room has the TV backwards or the interface misaligned, it locates the issue, re-plans, and fixes it. Vision has evolved from a way to understand input into a feedback loop for verifying work as it goes.

To support this, they're also releasing a new benchmark, RecreationBench: treat a real app as a black box, understand it purely by watching the interface and clicking buttons—no source code, no internet—then recreate the entire app from scratch. It covers Ubuntu, macOS, Windows, Android, and Web. They also released the Qwen-MM-Plugins extension library to add image/video processing and multimodal memory to existing agent frameworks.

Available Now: Free Web Interface, Two Environment Variables to Connect Claude Code

The web version is at chat.qwen.ai, ready to use. The API is on the Qianwen AI platform, compatible with both OpenAI and Anthropic protocols. To make Claude Code use it as its engine, just set a few environment variables:

export ANTHROPIC_MODEL="qwen3.8-max"
export ANTHROPIC_SMALL_FAST_MODEL="qwen3.8-max"
export ANTHROPIC_BASE_URL=https://dashscope.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=<your-API-key>

Official configs are also available for Codex, OpenClaw, Qoder, and Qwen Code. The API supports adjusting reasoning depth via the `reasoning_effort` parameter with three tiers: `xhigh` (default, deepest thinking), `medium`, and `low` (fast and economical). The launch page doesn't mention pricing, nor the open-source license type—both are pending for next week.

To make its case, the launch page shows five tasks completed start-to-finish without a human touch, ranging from 24 hours to 365 days.

The ability to run this long comes from how the training environment is built: Qwen splits the practice space into three dimensions—task, workspace, and the tool harness (the software layer that reads files, runs commands, and manages the workflow for the model). Expanding each and cross-combining them multiplies the number of environments. Since it trains and tests inside other tools like Claude Code and Codex, performance holds up when you swap the shell.

Given only a one-sentence task description and an empty interface—no reference design—it had to build a crypto circuit. This one can't be inflated: functional verification requires bit-exact output (every output bit must match ground truth; one wrong bit is a fail). Only after passing that does the comparison shift to using fewer logic gates, with the gate count calculated by the synthesis tool, not judged by anyone.

This final version went through a real place-and-route flow: the chip area shrank from 106×106 µm to 46×46 µm, an 80% saving, with total wire length down to one-eighth and timing met at 500 MHz—the circuit genuinely runs stably at that frequency.

Benchmarks take up just a small section of the launch page. Placed next to Claude's best, even its losses are published openly.

The coding gap is the most tangible, trailing by over twelve points. Multimodal tasks (handling text, images, and video together) are its strong suit, also leading in document parsing and long-video understanding. On terminal operations, GPT-5.6 Sol's 88.8 takes the top spot, with Qwen's 86.6 in the middle. All these scores come from the Qwen team's own testing, with no third-party verification yet; a significant portion of the coding benchmarks were run using Claude Code as the evaluation harness.

The web interface at chat.qwen.ai is ready to go, and the API supports both OpenAI and Anthropic protocols.