Tencent Hy3 vs Qwen 3.7: Which Open Chinese Model Wins for Coding?

Two open-weight Chinese models, both strong at coding, both under permissive licenses. Tencent Hy3 brings a 295B MoE with 74.4% SWE-bench Verified. Qwen 3.7 from Alibaba brings a dense architecture with strong benchmark performance of its own. The question for developers: which one should you actually use?

This comparison focuses on what matters for coding workflows: performance, efficiency, deployment options, and practical tradeoffs.

The Numbers

Spec	Tencent Hy3	Qwen 3.7
Architecture	MoE (192 experts, top-8)	Dense
Total parameters	295B	~72B
Active parameters	21B	72B (all active)
Context window	256K	128K
SWE-bench Verified	74.4%	~65%
Coding score	47.37	~44
License	Apache 2.0	Apache 2.0
API pricing	~$0.14/M input	~$0.20/M input
Local feasibility	Hard (295B total)	Easier (72B)
Release date	July 6, 2026	Q1 2026

The headline: Hy3 scores significantly higher on coding benchmarks while using fewer active parameters. But “total parameters” tells a different story for deployment.

Coding Performance Gap

The SWE-bench gap (74.4% vs ~65%) is substantial. Nearly 10 percentage points is not noise. In practical coding:

Where Hy3 beats Qwen 3.7:

• Complex multi-file refactoring
• Large codebase navigation (256K context helps)
• Subtle bug diagnosis requiring deep reasoning
• Architecture-level code decisions
• Tasks requiring sustained reasoning over many steps

Where Qwen 3.7 is competitive:

• Single-file edits and completions
• Standard web development tasks
• Code explanation and documentation
• Quick completions where speed matters
• Smaller-scale projects where 128K context is sufficient

The gap narrows on simpler tasks and widens on complex ones. If your typical coding task is “write this function” or “fix this bug in one file,” both models serve you well. If your task is “refactor this module across 15 files to use the new API,” Hy3 has a clear advantage.

Architecture Tradeoff: MoE vs Dense

This is the crux of the deployment decision.

Hy3 (MoE, 295B total, 21B active):

• Needs memory for all 295B parameters (even though only 21B activate)
• Once loaded, inference is fast (only 21B compute per token)
• Better suited for high-throughput serving (less compute per request)
• Harder to fine-tune (expert routing adds complexity)
• Harder to run on consumer hardware

Qwen 3.7 (Dense, 72B):

• Needs memory for 72B parameters (all are used)
• Inference uses all 72B parameters per token (more compute)
• Simpler to deploy, fine-tune, and understand
• Runs on consumer hardware with quantization (single RTX 4090 at Q4)
• Slower at high concurrency (more compute per request)

The irony: Hy3 has more total parameters (harder to load) but uses fewer per token (faster inference). Qwen 3.7 has fewer total parameters (easier to load) but uses all of them per token (slower inference).

Running Locally: Practical Reality

For developers who want to run these models on their own machines:

Qwen 3.7 local deployment:

• Q4 quantized: fits in ~40GB VRAM (single RTX 4090)
• Q8 quantized: fits in ~72GB (single A6000 or 2x RTX 4090)
• Full precision: needs ~144GB VRAM (2x A100 80GB)
• Interactive speeds achievable on consumer hardware
• Works well with Ollama out of the box

Hy3 local deployment:

• Q4 quantized: needs ~148GB VRAM minimum (multi-GPU required)
• Full precision: needs ~590GB (8x A100 80GB)
• Fast per-token inference once loaded, but loading is the bottleneck
• Requires more complex setup (MoE-aware serving)
• See our Hy3 local setup guide for details

Clear winner for local: Qwen 3.7. If running on your own hardware is a priority, Qwen 3.7 is dramatically easier and cheaper to deploy. A single high-end consumer GPU handles it.

For VRAM planning, check our hardware requirements guide.

API Access: Price and Availability

If you are using these models through an API rather than locally:

Hy3 via OpenRouter: ~$0.14/M input tokens Qwen 3.7 via various providers: ~$0.20/M input tokens

Both are extremely cheap compared to closed models (Sonnet 5 at $3/M, Opus 4.8 at $5/M). The 30% price difference between them matters less than the 90%+ savings vs closed alternatives.

Via API, the deployment complexity disappears. You call an endpoint and get results. The MoE vs dense architecture difference becomes invisible to the consumer. In this scenario, choose purely on quality, and Hy3 wins on coding benchmarks.

For the full pricing landscape: AI API pricing compared 2026.

Context Window: When 256K Matters

Hy3 offers 256K tokens of context. Qwen 3.7 offers 128K. Both are large by historical standards, but the difference matters for:

Large project refactoring: When you need to see the entire module structure to make coherent changes across many files.

Code review of large PRs: Fitting the full diff plus surrounding context requires extensive window space.

Codebase Q&A: Asking questions about a project while keeping many files in context for accurate answers.

For single-file work or focused tasks, 128K is plenty. The 256K advantage is specific to large-scale operations where seeing more of the codebase at once produces better results.

Hybrid Thinking vs Standard Inference

Hy3 features hybrid fast-and-slow thinking. The model adaptively decides how much reasoning to apply based on input complexity. Simple completions are fast. Complex problems get more thinking.

Qwen 3.7 uses standard inference without this adaptive mechanism. You get consistent behavior regardless of complexity. Some developers prefer this predictability.

In practice, Hy3’s adaptive approach means:

• Quick tab completions feel snappy
• Complex debugging gets appropriate depth
• Token usage scales with task difficulty (you do not waste tokens on simple tasks)

Qwen 3.7’s consistent approach means:

• Predictable latency and token counts
• Easier to budget and plan around
• No “why is this response taking longer?” surprises

Fine-Tuning

If you plan to fine-tune for your specific codebase:

Qwen 3.7: Straightforward. Standard LoRA/QLoRA fine-tuning works. Good documentation. Active community sharing fine-tuning recipes. Fits on 1-2 GPUs for LoRA training.

Hy3: More complex. MoE fine-tuning requires handling expert routing. You can fine-tune all experts or target specific ones. Less community documentation available. Needs more GPUs for training.

For teams that want to specialize a model on their proprietary codebase, Qwen 3.7 is the pragmatic choice. The fine-tuning infrastructure is simpler and better understood.

Ecosystem and Tooling

Qwen 3.7 ecosystem:

• Mature (released earlier)
• Well-supported in Ollama, vLLM, TGI
• Multiple fine-tuned variants on Hugging Face
• Good integration with IDE tools
• Active community forums

Hy3 ecosystem:

• Newer (July 2026 full release)
• Growing support in major frameworks
• Fewer community fine-tunes (so far)
• Backed by Tencent’s resources for rapid development
• 50+ internal Tencent products validated

Give Hy3 a few months and the ecosystem gap will likely close. But right now, Qwen 3.7 has more community resources available.

Recommendations

Choose Tencent Hy3 if:

• Maximum coding performance matters most
• You use API access (deployment complexity is hidden)
• You need 256K context for large-scale work
• You want the highest SWE-bench score in an open model
• Your infrastructure handles multi-GPU deployment

Choose Qwen 3.7 if:

• You want to run locally on consumer hardware
• Fine-tuning on your codebase is planned
• You prefer a mature ecosystem with community support
• Predictable, consistent behavior matters
• You need something that “just works” with Ollama on one GPU

The pragmatic split: Use Hy3 via API for complex coding tasks where quality matters. Use Qwen 3.7 locally for routine completions, quick edits, and offline work. This gives you the best of both worlds.

For how both compare to Western models, see our coverage of Claude Sonnet 5 and the best open-source coding models.

FAQ

Which model is better for coding overall?

Tencent Hy3 scores higher on coding benchmarks (74.4% vs ~65% SWE-bench, 47.37 vs ~44 coding score). For peak coding performance in an open model, Hy3 wins. For ease of deployment and “good enough” quality, Qwen 3.7 is excellent.

Can I run Hy3 on a single GPU?

Not practically. Even at aggressive quantization (Q2_K), Hy3 needs approximately 75-96GB. No single consumer GPU has this capacity. You need at minimum 2 GPUs or CPU offloading (which is very slow). Qwen 3.7 fits on a single RTX 4090 at Q4 quantization.

Which license is more permissive?

Both use Apache 2.0. Identical license terms. No geographic restrictions on either. Use both commercially without limitations.

Is Qwen 3.7 from Alibaba going to be affected by the Claude Code ban?

The Alibaba Claude Code ban is about a specific tool (Claude Code) from a specific vendor (Anthropic). It does not affect Alibaba’s own model releases. Qwen 3.7 is developed by Alibaba and is unrelated to the steganography concerns that triggered the ban.

Which model will get better faster?

Both have strong backing (Tencent and Alibaba respectively). Hy3’s jump from Hy2 (53% to 74.4%) suggests rapid improvement. Qwen’s iteration cycle is also fast. Expect both to have significant upgrades within 6 months. The Chinese AI model landscape is evolving rapidly.