Qwen 3.7 Max vs GPT-5.5 vs Claude Opus 4.8 for Coding: Real Costs, Real Benchmarks

TL;DR

Qwen 3.7 Max posts strong benchmark numbers at a headline price of $2.50/$7.50 per million tokens — roughly one-third of Claude Opus 4.8 or GPT-5.5. But the model generates about 4x more output tokens than competitors on the same task, which inflates the real bill until it’s neck-and-neck with the models it’s supposed to undercut. Opus 4.8 leads SWE-bench Pro at 69.2% and produces the most concise agentic sessions. GPT-5.5 wins SWE-bench Verified at 88.7% and leads Terminal-Bench for multi-turn agentic tasks. Qwen 3.7 Max is best when you need a 1M-token context window on a budget and can cap max_tokens aggressively.

Three Frontier Models, One Question

Since May 2026, three frontier-tier models have been competing for the same slot in agentic coding workflows: Alibaba’s Qwen 3.7 Max, OpenAI’s GPT-5.5, and Anthropic’s Claude Opus 4.8. Each claims to be the best at autonomous code generation, multi-file refactors, and tool-use chains. Each has a different pricing model that makes direct comparison harder than it looks.

I’ve been routing tasks across all three through OpenRouter and Claude Code for the past three weeks: debugging a FastAPI service, refactoring a Go CLI, and building a Python data pipeline. The benchmark numbers and the invoices don’t agree, so this piece covers both.

Benchmark Comparison

Numbers below are from Artificial Analysis, SWE-bench, and each provider’s published results as of June 2026.

A few things jump out. Opus 4.8 leads on SWE-bench Pro, which tests harder, multi-step GitHub issues that need more than a single-pass fix. GPT-5.5 tops SWE-bench Verified, the 500-task Python benchmark that most leaderboards use as their headline number. Qwen 3.7 Max dominates LiveCodeBench at 91.6%, but that benchmark skews toward competitive programming rather than real-world software engineering.

Terminal-Bench 2.0 measures multi-turn terminal agent performance (running commands, reading output, iterating). GPT-5.5 leads at 82.7%, with Opus 4.8 close behind at 74.6%. If your workflow involves an agent running tests, reading failures, and fixing code in a loop, these scores tell you more than a single-pass coding benchmark.

Pricing: The Headline Number vs the Real Bill

The pricing tables complicate the picture.

On paper, Qwen 3.7 Max is 3.3x cheaper than Claude and 4x cheaper than GPT-5.5 on output tokens. You can see why the model attracts attention.

The per-token rate doesn’t tell the full story, though.

The Verbosity Trap

During Artificial Analysis’s evaluation, Qwen 3.7 Max generated significantly more output tokens than competing frontier models running the same task set. In my own testing, Qwen consistently produced 3-4x the token output of Claude or GPT-5.5 for identical work.

This verbosity is baked into the model’s defualt behavior. With extended thinking enabled (which you need for agentic coding), Qwen 3.7 Max produces long reasoning traces, repeats itself across tool calls, and generates far more explanatory text than Claude or GPT-5.5 would for the same operation.

The per-task math shifts once you account for output volume. Take a realistic agentic coding task: debugging a failing test suite in a Python project, requiring 3-5 tool calls and some file edits.

The gap between Qwen and Claude shrinks from “one-third the price” to “roughly the same.” GPT-5.5 is slightly more expensive because of its higher output rate, but it also produces the most token-efficient responses for straightforward coding work.

On longer sessions (multi-file refactors, migration tasks, anything requiring 20+ tool calls), Qwen’s verbosity compounds. I saw one Go refactoring session generate 180K output tokens where Claude completed the same work in about 42K. At those volumes, Qwen cost more than Claude despite the lower per-token rate.

The fix is mechanical: set max_tokens to 4096 or lower per turn, and strip the thinking trace from responses when you don’t need it. This cuts Qwen’s worst-case output by 60-70% and brings the effective cost back down. But you have to know to do it, and most getting-started guides don’t mention it.

I keep Qwen’s output in check with this OpenRouter setup:

import openai

client = openai.OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ["OPENROUTER_API_KEY"],
)

response = client.chat.completions.create(
    model="qwen/qwen3.7-max",
    messages=[
        {"role": "system", "content": "You are a senior Python developer. Be concise."},
        {"role": "user", "content": "Fix the failing test in tests/test_auth.py"},
    ],
    max_tokens=4096,
    temperature=0.3,
)
# With max_tokens=4096, typical output drops from ~12K to ~3.5K tokens
# Cost per task: ~$0.08 instead of ~$0.14
print(response.choices[0].message.content)

The max_tokens=4096 cap is the single most important cost control for Qwen 3.7 Max. Without it, the model defaults to its full 65,536-token budget and fills most of it.

Agentic Workflow Performance

Benchmarks measure isolated tasks, but real agentic coding involves chains — reading files, running tests, parsing errors, editing code, and iterating. Each model handles that loop differently.

Claude Opus 4.8: Fewest Iterations, Tightest Diffs

I’ve been running Opus 4.8 through the Anthropic API for the past month. It’s the most disciplined model in multi-turn sessions. It reads errors carefully, makes targeted edits, and converges on a fix in fewer iterations than either competitor. In my FastAPI debugging session, Opus identified a missing dependency injection and fixed the test in two iterations. GPT-5.5 took three. Qwen took four, partly because it kept regenerating explanations I hadn’t asked for.

Opus also has the strongest tool-use behavior. On MCP-Atlas (which measures tool orchestration), it scores 82.2%, seven points above GPT-5.5’s 75.3%. If your setup involves MCP servers, database connections, or multi-tool chains, this gap is real.

Both Opus 4.8 and GPT-5.5 support 128K max output per response. In practice, though, Opus rarely uses more than 8-10K per turn in agentic workflows — it’s just more disciplined about keeping responses focused.

GPT-5.5 Gets the Most Out of Each Token

Through the OpenAI API, GPT-5.5 produces the most concise output of the three. A typical coding task averages around 3,000 output tokens. That’s barely more than a good Stack Overflow answer. This makes it the cheapest model for high-volume workloads where you’re paying per token through the API.

The 1.05M context window is the largest of the three. If you’re dropping an entire monorepo into context and asking for a sweeping refactor, GPT-5.5 can hold slightly more than either competitor.

Where GPT-5.5 falls short: it occasionally misses subtle race conditions and second-order bugs. In my testing, it solved 4 out of 5 debugging tasks correctly but whiffed on a concurrency issue in a Go channel handler that both Opus and Qwen caught. I covered GPT-5.5’s strengths and weaknesses more thoroughly in my GPT-5.5 review. The SWE-bench Pro gap (58.6% vs Opus’s 69.2%) reflects this. On harder problems, GPT-5.5 drops off more steeply.

Above 272K input tokens, GPT-5.5 charges 2x on input and 1.5x on output. That makes the monorepo-in-context use case more expensive than it looks.

Qwen 3.7 Max — Cheap Rate, Big Bills

Qwen’s strongest argument is access. It speaks both the OpenAI and Anthropic API protocols, so you can point Claude Code, OpenClaw, or any compatible harness directly at the Qwen endpoint as a drop-in replacement. No code changes, no wrapper libraries.

The 35-hour autonomous coding session that the Qwen team demonstrated shows real engineering endurance. The model wrote code, ran tests, found bottlenecks, and redesigned the code autonomously for over a thousand iterations. For long-running background tasks where you’re not paying per token (or have negotiated a volume discount), Qwen’s endurance and 1M context window make it a contender.

The LiveCodeBench score of 91.6% is impressive but doesn’t translate directly to software engineering. LiveCodeBench skews toward competitive programming problems: clean inputs, clear specifications, single-file solutions. Real codebases are messier, and that’s where SWE-bench Pro (60.6%) paints a more accurate picture.

For individual developers and small teams on a budget, Qwen 3.7 Max at $2.50/$7.50 (or $1.25/$3.75 on promotional providers) is the cheapest way into frontier-tier coding without falling back to a mid-tier model. Just cap your tokens.

Who Should Use What

A Note on Claude Fable 5

Anthropic’s Claude Fable 5, released June 9, technically leads this comparison: 95.0% SWE-bench Verified and 80.3% SWE-bench Pro at $10/$50 per million tokens. But since June 12, it’s been unavailable to non-US users due to an export-control directive. If you have access, it beats everything else on the scoreboard. For everyone else — which includes me, writing from Cyprus — Opus 4.8 is the practical ceiling. Anthropic has since made Claude Sonnet 5 the default model, and for most daily coding it now covers what you’d have reached for Opus to do, at less than half the price.

FAQ

Is Qwen 3.7 Max really cheaper than Claude for coding?

Per token, yes — $7.50/M output vs $25/M. Per completed task, not necessarily. Qwen generates roughly 4x more output tokens than Claude on comparable work. If you cap max_tokens at 4096 per turn and strip extended thinking when it’s not needed, Qwen runs 30-40% cheaper than Opus. Without those controls, it can cost more.

Can I use Qwen 3.7 Max with Claude Code?

Yes. Qwen 3.7 Max speaks the Anthropic API protocol natively. You can configure Claude Code to route through an OpenRouter or Yotta AI endpoint and use Qwen as the backing model. The tool-use interface works, though Qwen’s verbosity means longer turn times.

Which model is best for multi-file refactors?

Claude Opus 4.8 produces the most targeted edits across multiple files. GPT-5.5 is better when the refactor spans many files and you need concise, efficient responses across all of them. Qwen handles large-context refactors well but tends to over-explain each change, which adds noise to diffs.

What about DeepSeek V4 Pro?

DeepSeek V4 Pro scores 80.6% SWE-bench Verified at $0.44/$0.87 per million tokens (after the May 2026 permanent price cut), making it the best value in the open-weight tier. I covered it in my DeepSeek V4 Pro review. It’s a strong choice if you need self-hosting or data sovereignty, but it doesn’t match Opus or GPT-5.5 on SWE-bench Pro.

Does GPT-5.5’s long-context surcharge matter?

Only above 272K input tokens. Below that, standard pricing applies. For typical coding tasks (5K-30K input), the surcharge never kicks in. It kicks in for the “dump the entire repo in context” workflow, where a 500K-token input would cost 2x ($10/M) on input. At that scale, Qwen’s $2.50/M flat rate is genuinely cheaper.

Sources

• Qwen3.7-Max benchmarks and pricing — Artificial Analysis — independent benchmark evaluation and output token analysis
• Best AI Model for Coding (June 2026) — MorphLLM — 12 models ranked by SWE-bench Pro and cost per task
• Claude Opus 4.8 launch — Anthropic — official release and benchmark numbers
• GPT-5.5 pricing and specifications — OpenAI — official API documentation
• Qwen 3.7 Max technical blog — Qwen — 35-hour autonomous coding session details
• SWE-bench Pro leaderboard — CodingFleet — current rankings across all models

Bottom Line

Qwen 3.7 Max is the model that looks cheapest on a spreadsheet and runs up a comparable bill in production. The benchmark numbers are legitimate — 60.6% SWE-bench Pro from a Chinese lab at $7.50/M output is a serious result. But the 4x output verbosity is the number that most comparison tables leave out, and it changes the economics from “one-third the price” to “roughly the same.”

If I’m picking one model for a daily coding agent, it’s Opus 4.8. Highest SWE-bench Pro score among available models, most disciplined output, best tool orchestration. GPT-5.5 is the pick for batch API work where you’re optimizing for token efficiency. Qwen 3.7 Max earns its spot for budget-constrained teams willing to tune max_tokens and for fire-and-forget overnight sessions where the 1M context and API compatibility make workflows possible that the others can’t touch.

Competition is the real story here. A year ago, a single model dominated the coding benchmarks with no price pressure. Now three providers are within spitting distance on quality, and the cost of a solved coding task has dropped below twenty cents.