Qwen 3.8 for Coding: 16-Day Autonomous Runs and the Claude Code Connection

Most model launches pitch coding ability the same way: here’s our HumanEval score, here’s a snippet of the model writing a binary search. Alibaba took a different route with Qwen 3.8-Max. The claim isn’t “it writes good functions.” The claim is that it can run a software project on its own for weeks: opening issues, merging pull requests, and shipping features with no human in the loop.

That’s a bold pitch, and it deserves scrutiny. This article walks through the three coding showcases Alibaba published at launch (all vendor demos, one with a public repo you can audit), the coding benchmark numbers behind them, and then the part you can act on today: how to actually code with qwen3.8-max in Claude Code, Codex, Qoder, Qwen Code, and OpenClaw, and how to test the API output your generated code produces.

If you’re new to the model itself, start with the overview of what Qwen 3.8 is: 2.4T total parameters, 95B active, a 1M-token context window, and open weights promised for the week after launch. Here we’ll stay focused on the coding story. Everything below reflects the state of things as of August 3, 2026.

What Alibaba is actually claiming

The framing in the official Qwen 3.8 release post is autonomy over snippets. Alibaba positions Qwen 3.8-Max as a model that can hold a long-horizon engineering task in its head: plan the work, execute it across days, recover from its own mistakes, and deliver something reviewable at the end.

Three things make this claim more interesting than the usual launch-day marketing:

1. The demos are long. Sixteen days is a different regime from a 20-minute agent benchmark. Error recovery, context management, and drift matter far more at that scale.
2. One demo is public. You can browse the repo, read the commits, and judge the code quality yourself. Most vendor showcases don’t offer that.
3. The harness is a competitor’s. Alibaba ran most of its coding benchmarks with the Claude Code harness, and published an official config so you can do the same. More on that below.

Standard caveat, and it applies to this entire article: every number here comes from Alibaba’s own launch materials. No independent verification exists yet as of early August 2026. Treat the showcases as demos, not audits.

The three coding showcases

oh-my-cli: 16 days of autonomous development

The headline demo. Alibaba set Qwen 3.8-Max loose on building a command-line tool and let it run unattended. As of July 30, the run had been going for 16 days and produced 265 commits, 127 pull requests, and 151 issues, all opened, worked, and closed by the model itself.

The repo is public at qwen-code-dev-bot/oh-my-cli, which is the most useful part of the whole showcase. You don’t have to take the commit count on faith. You can read the PR descriptions, check whether the issues are real bugs or busywork, and see if the code holds up. Sixteen days of output from a model with no human review is a genuinely rare artifact, whatever you end up concluding about the quality.

What to look for when you audit it: whether PRs actually fix the issues they reference, whether the model creates artificial work to close, and how it handles its own regressions. Those patterns tell you more about long-horizon reliability than any single benchmark score.

The paper reproduction run: research code, not app code

The second demo targets a harder class of coding: reproducing a machine learning research paper from scratch. Per Alibaba’s numbers, the run took roughly 125 hours, produced about 7,600 lines of code, and executed 33 GPU training rounds along the way.

The result: the model reproduced 6 of the paper’s findings, then went one step further and beat the paper’s reported result by 2.7 points on AIME24. Reproducing research is notoriously unforgiving work. Environments break, hyperparameters hide in footnotes, and a single silent bug invalidates a training run you find out about hours later. A model that can push through 33 training rounds and come out with matching numbers is doing something beyond autocomplete.

This demo pairs with Qwen 3.8-Max’s strongest benchmark row, PaperBench, covered below.

The Tianchi contest: 24 hours against human teams

The third showcase put the model in a live data science competition on Alibaba’s Tianchi platform with a 24-hour limit. The model made 45 submissions in that window, iterating on its approach each time, and finished with a final accuracy of 0.853. That placed it ahead of 458 of the 526 human teams competing.

Worth noting the shape of this result: the model didn’t win. It beat 87% of the field, which is impressive and honest at the same time. It also shows a capability the other two demos don’t: rapid-fire iteration under a deadline, where each submission’s score feeds the next attempt.

One more caveat that applies with extra force here: Tianchi is Alibaba’s own platform. The demo is real, but the vendor controlled the venue.

The coding benchmarks behind the demos

Alibaba published a full benchmark table at launch. Here are the coding-relevant rows, with the honest parts left in. All numbers are Alibaba’s own runs.

Three takeaways:

• Terminal Bench 2.1 (86.6) puts Qwen 3.8-Max ahead of Claude Opus 4.8 and Fable 5 (both 84.6 in Alibaba’s table) on terminal-driven agentic work. This is the number that backs the oh-my-cli demo.
• SWE-bench Pro (67.7) is the loss, and it’s not close. Fable 5 scores 80.0 on the same table. On repository-scale bug fixing, the benchmark that maps most directly to “fix this issue in my codebase,” Qwen 3.8-Max trails the leader by over 12 points. Alibaba published this number anyway, which is to their credit.
• PaperBench (93.0) is the model’s single best flagship row, beating everything in the comparison set. It backs the paper-reproduction demo directly.

Now the fine print that most coverage will skip: Alibaba ran most of these coding benchmarks on the Claude Code harness, including runs for rival models, and the table’s footnotes note that Fable 5 results may involve fallbacks. Harness choice materially affects agentic benchmark scores, so a vendor-run table on a particular harness is one data point, not a verdict.

The Claude Code detail cuts both ways, though. It means Alibaba optimized for the harness you might already be using, and they published the config to prove it.

How to actually code with Qwen 3.8 today

Here’s the practical half. Qwen 3.8-Max is GA on Alibaba Cloud Model Studio, and Alibaba published official configs for five coding tools at launch. You need a DashScope API key (from home.qwencloud.com) for all of them. Pricing is $2 per million input tokens and $6 per million output, flat across the full 1M context, per the official Model Studio pricing page.

Claude Code

The model ships with an Anthropic-compatible API endpoint, so pointing Claude Code at it takes three environment variables:

export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=your-dashscope-api-key
export ANTHROPIC_MODEL=qwen3.8-max

Start Claude Code as normal and it routes every request to Qwen 3.8-Max instead of Claude. Given that Alibaba ran its coding benchmarks on this exact harness, this is the config with the least daylight between what was measured and what you’ll experience.

Codex

Codex needs a provider entry in its config. The sketch from the official docs:

model = "qwen3.8-max"
model_provider = "qwencloud"

[model_providers.qwencloud]
name = "QwenCloud"
base_url = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
env_key = "DASHSCOPE_API_KEY"
context_window = 1000000

This uses the OpenAI-compatible endpoint rather than the Anthropic one. Same model, same key, different protocol shape.

Qoder, Qwen Code, and OpenClaw

The remaining three are quicker to summarize:

• Qoder CLI: Alibaba’s own agentic coding tool. Select qwen3.8-max as the model; it’s a first-party integration, so setup is a config value.
• Qwen Code: the open-source CLI from the Qwen team. Set DASHSCOPE_API_KEY and pick the model. If you’ve used it with earlier Qwen coding models, nothing else changes.
• OpenClaw: the official config sets the model ID and a maxTokens of 65,536, which is also where the model’s maximum output length comes from.

All five configs are in the launch post, so grab the exact current version there rather than pinning to a blog snapshot.

Set reasoning effort deliberately

Qwen 3.8-Max supports a reasoning_effort parameter with three levels: xhigh (the default), medium, and low. For coding, this setting matters more than most knobs:

• Keep xhigh for agentic work: multi-file refactors, debugging sessions, anything where the model plans before it edits. The showcase runs represent this mode.
• Drop to low for quick edits: renaming, docstring passes, mechanical changes where deep reasoning wastes time and tokens.

Remember that thinking tokens bill as output tokens at $6 per million, and xhigh is the default. A long agentic session at full effort costs real money; a mechanical edit at xhigh costs it for no benefit.

If Qwen 3.8-Max is more model than your task needs, the earlier Qwen3 Coder line still exists for dedicated coding work, and Qwen3 Coder Flash covers the fast-and-cheap end. For the other open-weight heavyweight in this space, see how Kimi K3 handles coding work.

Testing what the model builds: the Apidog step

Here’s the gap in every autonomous coding demo, including Alibaba’s: the model writes code that calls APIs, and nobody talks about verifying those calls. An agent can produce 7,600 lines that compile cleanly and still hit the wrong endpoint, mishandle a 429, or ship a request body that fails validation in production.

Two habits close that gap.

Test the endpoints your generated code calls. When Qwen 3.8-Max scaffolds a service or writes an API client, import the relevant spec into Apidog and exercise the endpoints directly: auth flows, error responses, edge-case payloads. It’s much cheaper to find a wrong assumption in a test run than in a stack trace two days into an autonomous session. If you’re evaluating the model’s own API before committing to it, the Qwen 3.8 API guide covers the dual OpenAI and Anthropic protocol setup in detail, and Apidog is a convenient place to inspect both protocol shapes side by side, including the streaming responses and reasoning deltas.

Mock APIs so agent runs don’t hit production. This one matters more the longer your runs get. A 16-day autonomous session making live calls against production infrastructure is a genuinely bad idea: rate limits, data mutations, surprise bills. Mock servers in Apidog give the agent realistic responses without touching real systems. Point the generated code at the mock URL during the run, swap in the real base URL when a human has reviewed the output. Download Apidog for free to set up a mock in a few minutes; it’s the cheapest insurance an unattended agent run can have.

The pattern generalizes: the more autonomy you give a coding model, the more the API layer becomes your control surface. You can’t review every commit in real time, but you can control what the code is allowed to talk to.

FAQs

Is Qwen 3.8 good for coding?

By Alibaba’s own numbers, it’s strong at agentic and research-style coding (Terminal Bench 2.1 at 86.6, PaperBench at 93.0) and mid-pack at repository-scale bug fixing (SWE-bench Pro at 67.7 versus Fable 5’s 80.0). All numbers are vendor-run with no independent verification yet. The honest read: excellent for long-horizon autonomous work, not the leader for classic issue-fixing.

Can I use Qwen 3.8 in Claude Code?

Yes, officially. Set ANTHROPIC_BASE_URL to https://dashscope-intl.aliyuncs.com/apps/anthropic, ANTHROPIC_AUTH_TOKEN to your DashScope key, and ANTHROPIC_MODEL to qwen3.8-max. Alibaba published this config itself and ran most of its coding benchmarks on the Claude Code harness.

How much does coding with Qwen 3.8 cost?

$2 per million input tokens and $6 per million output, flat across the 1M context. Thinking tokens bill as output, and the default xhigh reasoning effort produces plenty of them, so budget above the sticker price for agentic sessions. Full cost math and comparisons are in the Qwen 3.8 benchmarks breakdown and the pricing coverage linked there.

Was the 16-day oh-my-cli run really autonomous?

That’s Alibaba’s claim, and unlike most vendor demos you can check the artifact: the repo is public at qwen-code-dev-bot/oh-my-cli with 265 commits, 127 PRs, and 151 issues as of July 30, 2026. Whether the code quality justifies the framing is a judgment you can make yourself by reading it, which is exactly what makes this showcase more credible than a screenshot.