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 a HumanEval score and a snippet of a model writing binary search. Alibaba took a different route with Qwen 3.8-Max. The claim is not just that it writes good functions—it can run a software project for weeks by opening issues, merging pull requests, and shipping features without a human in the loop.

Try Apidog today

That is a bold claim, and it deserves scrutiny. This post covers Alibaba’s three coding showcases at launch—all vendor demos, with one public repository you can audit—the coding benchmark results behind them, and the practical setup for using qwen3.8-max with Claude Code, Codex, Qoder, Qwen Code, and OpenClaw. It also covers how to test the API output produced by generated code.

If you are new to the model, start with what Qwen 3.8 is: 2.4T total parameters, 95B active parameters, a 1M-token context window, and open weights promised for the week after launch. This article stays focused on coding. 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 keep a long-horizon engineering task in context: plan work, execute across days, recover from mistakes, and produce something reviewable at the end.

Three details make this more interesting than a typical launch-day demo:

1. The demos are long. Sixteen days is a different operating regime from a 20-minute agent benchmark. Error recovery, context management, and task drift matter much more at that scale.
2. One demo is public. You can inspect the repository, commits, pull requests, and issues instead of relying on screenshots.
3. The harness is a competitor’s. Alibaba ran most coding benchmarks using the Claude Code harness and published an official configuration for it.

The standard caveat applies throughout this post: every number comes from Alibaba’s launch materials. As of early August 2026, there is no independent verification. Treat the showcases as demos, not audits.

The three coding showcases

oh-my-cli: 16 days of autonomous development

The headline demo is an unattended run building a command-line tool. As of July 30, Alibaba said the run had operated for 16 days and produced:

• 265 commits
• 127 pull requests
• 151 issues

The model opened, worked, and closed those issues itself.

The repository is public at qwen-code-dev-bot/oh-my-cli. That is the most useful part of the showcase because you can audit it directly.

When reviewing the repository, check more than commit volume:

• Do pull requests actually fix the issues they reference?
• Does the agent create artificial work just to close it later?
• Are tests added alongside changes?
• How does it recover from regressions it introduces?
• Are issue descriptions and PR summaries specific enough to be useful to a human reviewer?

Those signals tell you more about long-horizon reliability than a single benchmark score.

The paper reproduction run: research code, not app code

The second demo targets reproducing a machine learning research paper from scratch. According to Alibaba, the run:

• Took roughly 125 hours
• Produced about 7,600 lines of code
• Ran 33 GPU training rounds
• Reproduced 6 findings from the paper
• Beat the paper’s reported AIME24 result by 2.7 points

Research reproduction is unforgiving. Environments break, hyperparameters can be buried in footnotes, and one silent implementation bug can invalidate a training run hours later.

The demo aligns with Qwen 3.8-Max’s strongest coding-related benchmark result: PaperBench.

The Tianchi contest: 24 hours against human teams

The third showcase placed the model in a live data science competition on Alibaba’s Tianchi platform with a 24-hour limit.

Alibaba reports that Qwen 3.8-Max:

• Made 45 submissions
• Iterated based on submission scores
• Reached a final accuracy of 0.853
• Finished ahead of 458 of 526 human teams

The model did not win, but it reportedly beat 87% of the field. This demo measures something the other two do not: rapid iteration under a deadline, where every score informs the next attempt.

One caveat matters here: Tianchi is Alibaba’s own platform. The demo may be real, but the vendor controlled the venue.

The coding benchmarks behind the demos

Alibaba published a full benchmark table at launch. These are the coding-relevant rows.

Benchmark	Qwen 3.8-Max	Best rival, per Alibaba’s table
Terminal Bench 2.1	86.6	88.8, GPT-5.6 Sol
SWE-bench Pro	67.7	80.0, Fable 5
PaperBench	93.0	90.5, GPT-5.6 Sol

Three practical takeaways:

• Terminal Bench 2.1: 86.6. Alibaba’s table puts Qwen 3.8-Max ahead of Claude Opus 4.8 and Fable 5, both at 84.6, for terminal-driven agentic work. This is the result most closely associated with the oh-my-cli demo.
• SWE-bench Pro: 67.7. This is the weaker result. Fable 5 scores 80.0 in the same table. For repository-scale bug fixing—the benchmark closest to “fix this issue in my codebase”—Qwen 3.8-Max trails the reported leader by more than 12 points.
• PaperBench: 93.0. This is the model’s strongest flagship result and supports the paper-reproduction showcase directly.

Read the fine print, too: Alibaba ran most coding benchmarks on the Claude Code harness, including runs for rival models. The table footnotes also note that Fable 5 results may involve fallbacks.

Harness choice can materially affect agent benchmark scores. A vendor-run benchmark table on a specific harness is one data point, not a final verdict.

The useful part for developers is that Alibaba optimized for a harness you may already use and published the relevant configuration.

How to actually code with Qwen 3.8 today

Qwen 3.8-Max is GA on Alibaba Cloud Model Studio. Alibaba published official configurations for five coding tools at launch.

You need a DashScope API key from home.qwencloud.com.

According to the official Model Studio pricing page, pricing is:

• $2 per million input tokens
• $6 per million output tokens
• Flat pricing across the full 1M-token context window

Claude Code

Qwen 3.8-Max exposes an Anthropic-compatible endpoint. Configure Claude Code with these 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

Then start Claude Code normally.

This routes Claude Code requests to Qwen 3.8-Max instead of Claude. Since Alibaba ran its coding benchmarks with this harness, this setup has the least distance between the published measurements and your local workflow.

A practical workflow:

# Set credentials for the current shell session
export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN="$DASHSCOPE_API_KEY"
export ANTHROPIC_MODEL=qwen3.8-max

# Start Claude Code inside your repository
cd your-project
claude

Before giving the agent a broad task, start with a bounded change:

Read the repository README and package configuration.
Identify the test command.
Fix only the failing test in src/auth/token.ts.
Run the relevant test suite and summarize the changed files.
Do not modify dependencies.

This gives you a quick signal on repository understanding, tool use, and test discipline before assigning a larger refactor.

Codex

Codex requires a provider entry in its configuration:

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 instead of the Anthropic-compatible endpoint.

Set the API key before starting Codex:

export DASHSCOPE_API_KEY=your-dashscope-api-key

The model and key are the same; only the API protocol changes.

Qoder, Qwen Code, and OpenClaw

The remaining integrations are more direct:

• Qoder CLI: Select qwen3.8-max as the model. It is a first-party integration.
• Qwen Code: Set DASHSCOPE_API_KEY, then select qwen3.8-max. If you already use earlier Qwen coding models, the workflow does not otherwise change.
• OpenClaw: The official configuration sets the model ID and maxTokens to 65,536, which is also the model’s maximum output length.

Use the latest configuration from the launch post rather than treating a blog snapshot as a permanent config reference.

Set reasoning effort deliberately

Qwen 3.8-Max supports reasoning_effort with three levels:

• xhigh — default
• medium
• low

Choose it based on the task.

Task type	Recommended reasoning effort
Multi-file refactor	xhigh
Debugging a non-obvious failure	xhigh
Planning an agentic implementation	xhigh
Renaming symbols	low
Updating docstrings	low
Mechanical formatting or simple edits	low

Use xhigh for work where the model must inspect, plan, test, and revise. The showcase runs represent this mode.

Use low for simple edits where extended reasoning adds latency and output-token cost without improving the result.

Thinking tokens are billed as output tokens at $6 per million. For long-running coding agents, use the highest effort level only where it adds value.

If Qwen 3.8-Max is more model than the task requires, the earlier Qwen3 Coder line remains available for dedicated coding work, while Qwen3 Coder Flash targets faster and cheaper workloads. For another open-weight model in this space, see how Kimi K3 handles coding work.

Testing what the model builds: the Apidog step

Every autonomous coding demo has the same gap: the model can write code that calls APIs, but generated API behavior still needs verification.

An agent can produce thousands of lines that compile and pass local tests while still:

• Calling the wrong endpoint
• Sending an invalid request body
• Mishandling 429 Too Many Requests
• Skipping authentication edge cases
• Assuming a response shape that differs from production

Two practices help close that gap.

1. Test the endpoints your generated code calls

When Qwen 3.8-Max scaffolds a service or writes an API client, import the relevant API specification into Apidog and test the endpoints directly.

Validate at least:

• Authentication and authorization flows
• Required and optional request fields
• Invalid payloads
• Error response formats
• Rate-limit behavior
• Pagination and cursor handling
• Timeout and retry behavior

For example, if the generated client calls POST /users, test both the expected request and invalid variations before merging:

{
  "email": "[e-mail]",
  "name": "Dev User"
}

Then test invalid input:

{
  "email": "not-an-email"
}

Verify that your generated client handles the actual status code and error body, rather than the response it assumed existed.

If you are evaluating Qwen 3.8-Max’s own API before committing to it, the Qwen 3.8 API guide covers the OpenAI-compatible and Anthropic-compatible setup in detail. Apidog can help inspect both protocol shapes side by side, including streaming responses and reasoning deltas.

2. Mock APIs so agent runs do not hit production

This becomes more important as runs get longer.

Do not let an unattended coding agent make unrestricted production calls. A multi-day run can trigger rate limits, mutate data, or generate unexpected bills.

Use Apidog mock servers to provide realistic API responses without touching real systems.

A safe implementation pattern looks like this:

# Local or agent-run environment
API_BASE_URL=https://your-mock-server.example

# Human-reviewed production deployment
API_BASE_URL=https://api.example.com

For an agent-generated API client, make the base URL configurable:

export const apiBaseUrl =
  process.env.API_BASE_URL ?? "https://your-mock-server.example";

Then point the agent environment at the mock URL during development and switch to the real URL only after a human review.

Download Apidog for free to set up a mock server in a few minutes.

The broader pattern is simple: the more autonomy you give a coding model, the more the API layer becomes a control surface. You may not review every commit in real time, but you can control what generated code is allowed to call.

FAQs

Is Qwen 3.8 good for coding?

Based on Alibaba’s own numbers, it is strong at agentic and research-style coding:

• Terminal Bench 2.1: 86.6
• PaperBench: 93.0

It is less competitive on repository-scale bug fixing:

• SWE-bench Pro: 67.7
• Fable 5, in Alibaba’s table: 80.0

All results are vendor-run and had no independent verification as of early August 2026. The practical read is that Qwen 3.8-Max appears suited to long-horizon autonomous work, but is not the reported leader for conventional issue-fixing tasks.

Can I use Qwen 3.8 in Claude Code?

Yes. Configure Claude Code with:

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

Alibaba published this configuration and used the Claude Code harness for most of its coding benchmarks.

How much does coding with Qwen 3.8 cost?

Alibaba lists:

• $2 per million input tokens
• $6 per million output tokens
• Flat pricing across the 1M-token context window

Thinking tokens are billed as output tokens. Since xhigh is the default reasoning effort, budget above the nominal request size for long agentic sessions.

For cost details and comparisons, see the Qwen 3.8 benchmarks breakdown.

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

That is Alibaba’s claim. The useful difference from most vendor demos is that the artifact is public: qwen-code-dev-bot/oh-my-cli had 265 commits, 127 pull requests, and 151 issues as of July 30, 2026.

You can inspect the repository yourself and judge whether the code quality supports the autonomy claim.