API Qwen3.6-Plus: Surpasse Claude aux Benchmarks Terminal

En bref

Qwen3.6-Plus a été officiellement lancé. Il obtient un score de 78,8 % sur SWE-bench Verified et de 61,6 % sur Terminal-Bench 2.0, où il surpasse Claude Opus 4.5. Il dispose d'une fenêtre contextuelle d'1 million de jetons, d'un nouveau paramètre preserve_thinking pour les boucles d'agents, et fonctionne directement avec Claude Code, OpenClaw et Qwen Code via une API compatible OpenAI.

Essayez Apidog dès aujourd'hui

De la préversion à la version finale

Si vous avez lu notre guide précédent sur la préversion de Qwen 3.6 Plus sur OpenRouter, vous connaissez déjà ses capacités. La préversion a été lancée discrètement le 30 mars, sans liste d'attente et avec un accès gratuit via OpenRouter. En deux jours, elle a traité plus de 400 millions de jetons de complétion sur environ 400 000 requêtes.

La version officielle apporte une stabilité de production : disponible via Alibaba Cloud Model Studio avec une API stable, SLA garanti, et le nouveau paramètre d'API qui améliore significativement les tâches d'agent multi-étapes.

Ce guide détaille les nouveautés, la manière d'appeler l'API et comment tester votre intégration avec Apidog avant de passer en production.

Qu'est-ce que Qwen3.6-Plus ?

Qwen3.6-Plus est un modèle hébergé « mixture-of-experts » de l'équipe Qwen d'Alibaba. Comme Qwen3.5, il utilise une activation sparse (seule une fraction des paramètres activés par jeton) : performance élevée à coût réduit.

Spécifications clés :

• Fenêtre contextuelle d'1 million de jetons par défaut
• Raisonnement en chaîne de pensée obligatoire
• Nouveau paramètre preserve_thinking pour les agents
• Support multimodal natif (vision, vidéo, documents)
• API compatible OpenAI, API compatible Anthropic, API de réponses OpenAI

Des variantes open-source (plus petites) arrivent prochainement. Les poids pour auto-hébergement sont prévus.

Résultats des benchmarks

Agents de codage

Qwen3.6-Plus talonne Claude Opus 4.5 sur SWE-bench mais le dépasse sur Terminal-Bench.

Terminal-Bench 2.0 : opérations shell réelles (fichiers, processus, workflows multi-étapes, 3h timeout, 32 cœurs CPU, 48Go RAM). Qwen3.6-Plus : 61,6% vs 59,3% pour Claude Opus 4.5 – écart significatif pour des tâches pratiques de développement.

Agents généraux et utilisation d'outils

Benchmark	Claude Opus 4.5	Qwen3.6-Plus
TAU3-Bench	70.2%	70.7%
DeepPlanning	33.9%	41.5%
MCPMark	42.3%	48.2%
MCP-Atlas	71.8%	74.1%
WideSearch	76.4%	74.3%

MCPMark : appels d'outils GitHub MCP v0.30.3, réponses Playwright tronquées à 32K jetons. Qwen3.6-Plus domine sur MCPMark et DeepPlanning, essentiels pour l'automatisation et l'orchestration d'outils.

Raisonnement et connaissances

Benchmark	Claude Opus 4.5	Qwen3.6-Plus
GPQA	87.0%	90.4%
LiveCodeBench v6	84.8%	87.1%
IFEval strict	90.9%	94.3%
MMLU-Pro	89.5%	88.5%

Qwen3.6-Plus surpasse sur GPQA (raisonnement scientifique) et IFEval strict (suivi d'instructions complexes).

Multimodal

Qwen3.6-Plus est nativement multimodal et leader sur plusieurs benchmarks :

Benchmark	Qwen3.6-Plus	Remarques
OmniDocBench 1.5	91.2%	Meilleur du tableau
RefCOCO avg	93.5%	Meilleur du tableau
We-Math	89.0%	Meilleur du tableau
CountBench	97.6%	Meilleur du tableau
OSWorld-Verified	62.5%	Derrière Claude (66,3%)

OSWorld-Verified : Claude Opus 4.5 reste devant, mais Qwen3.6-Plus domine la compréhension de documents et la reconnaissance spatiale.

Comment appeler l'API

Qwen3.6-Plus est disponible sur Alibaba Cloud Model Studio. Récupérez votre clé API sur modelstudio.alibabacloud.com.

URLs régionales :

• Singapour : https://dashscope-intl.aliyuncs.com/compatible-mode/v1
• Pékin : https://dashscope.aliyuncs.com/compatible-mode/v1
• Virginie (US) : https://dashscope-us.aliyuncs.com/compatible-mode/v1

Appel de base avec streaming

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=[{"role": "user", "content": "Review this Python function and find bugs."}],
    extra_body={"enable_thinking": True},
    stream=True
)

reasoning = ""
answer = ""
is_answering = False

for chunk in completion:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content:
        if not is_answering:
            reasoning += delta.reasoning_content
    if delta.content:
        if not is_answering:
            is_answering = True
        answer += delta.content
        print(delta.content, end="", flush=True)

Le paramètre preserve_thinking

La version stable introduit preserve_thinking : quand activé, la chaîne de raisonnement de tous les tours précédents reste accessible au modèle. Idéal pour les scénarios d'agent multi-étapes.

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=conversation_history,
    extra_body={
        "enable_thinking": True,
        "preserve_thinking": True,  # garder le raisonnement entre tous les tours
    },
    stream=True
)

Utiliser Qwen3.6-Plus avec Claude Code

L'API Qwen est compatible Anthropic. Pour utiliser Qwen3.6-Plus avec Claude Code, ajustez simplement les variables d'environnement :

npm install -g @anthropic-ai/claude-code

export ANTHROPIC_MODEL="qwen3.6-plus"
export ANTHROPIC_SMALL_FAST_MODEL="qwen3.6-plus"
export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=your_dashscope_api_key

claude

Utiliser Qwen3.6-Plus avec OpenClaw

OpenClaw (anciennement Moltbot / Clawdbot) est un agent de codage auto-hébergé. Installez et configurez-le :

# Installation (Node.js 22+)
curl -fsSL https://molt.bot/install.sh | bash

export DASHSCOPE_API_KEY=your_key
openclaw dashboard

Modifiez ~/.openclaw/openclaw.json et fusionnez :

{
  "models": {
    "providers": [{
      "name": "alibaba-coding-plan",
      "baseUrl": "https://coding-intl.dashscope.aliyuncs.com/v1",
      "apiKey": "${DASHSCOPE_API_KEY}",
      "models": [{"id": "qwen3.6-plus", "reasoning": true}]
    }]
  },
  "agents": {
    "defaults": {"models": ["qwen3.6-plus"]}
  }
}

Utiliser Qwen3.6-Plus avec Qwen Code

Qwen Code est l'agent terminal open-source d'Alibaba. Il offre 1 000 appels API gratuits/jour avec Qwen Code OAuth.

npm install -g @qwen-code/qwen-code@latest
qwen
# Tapez /auth pour activer la version gratuite

Pourquoi preserve_thinking modifie le comportement de l'agent

Sans preserve_thinking, chaque tour est indépendant. Pour les workflows complexes, le modèle ne se souvient pas des décisions prises aux étapes précédentes, ce qui nuit à la cohérence.

Avec preserve_thinking: true, la chaîne complète de raisonnement reste accessible : l'agent prend des décisions plus cohérentes à chaque étape, réduit le raisonnement redondant et utilise moins de jetons.

Utilisez ce schéma pour vos boucles d'agents :

conversation = []

def agent_step(user_message, preserve=True):
    conversation.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="qwen3.6-plus",
        messages=conversation,
        extra_body={
            "enable_thinking": True,
            "preserve_thinking": preserve,
        },
        stream=False
    )

    message = response.choices[0].message
    conversation.append({"role": "assistant", "content": message.content})
    return message.content

# Exemple : agent de revue de code multi-étapes
result = agent_step("Analyze the auth module for security issues.")
result = agent_step("Now suggest fixes for the top 3 issues you found.")
result = agent_step("Write tests that validate each fix.")

À l'étape 3, le modèle connaît toujours les problèmes identifiés à l'étape 1.

À quoi il est le mieux adapté

• Correction de bugs au niveau du référentiel : SWE-bench Verified à 78,8 % et SWE-bench Pro à 56,6 % – très compétitif.
• Automatisation du terminal : leader Terminal-Bench 2.0. Idéal pour les workflows shell, gestion de processus, pipelines.
• Appel d'outils MCP : MCPMark à 48,2 % – meilleur score pour les intégrations MCP.
• Analyse de documents long contexte : fenêtre de 1 million de jetons, scores LongBench v2 solides pour l'analyse de bases de code, specs, etc.
• Génération de code frontend : score QwenWebBench de 1501,7 vs 1517,9 pour Claude Opus 4.5. Presque à égalité.
• Multilingue : WMT24++ à 84,3 %, MAXIFE à 88,2 % sur 23 langues – solide hors anglais.

Tester les appels API de Qwen3.6-Plus avec Apidog

L'endpoint est compatible OpenAI. Importez-le directement dans Apidog et testez comme n'importe quelle API.

• Effectuez une requête POST vers https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions.
• Ajoutez votre clé API en tant que variable d'environnement : Authorization: Bearer {{DASHSCOPE_API_KEY}}.

Exemple d'assertions de réponse :

pm.test("La réponse contient des choix", () => {
    const body = pm.response.json();
    pm.expect(body).to.have.property("choices");
    pm.expect(body.choices[0].message.content).to.be.a("string").and.not.empty;
});

pm.test("Pas de raisonnement vide lorsque la pensée est activée", () => {
    const choice = pm.response.json().choices[0];
    if (choice.message.reasoning_content !== undefined) {
        pm.expect(choice.message.reasoning_content).to.not.be.empty;
    }
});

Utilisez le Smart Mock d'Apidog pour générer des réponses de test : développez et testez votre orchestration d'agent sans consommer de jetons API.

Pour les agents multi-tours, créez un scénario de test qui enchaîne plusieurs requêtes et vérifiez que preserve_thinking transmet bien le raisonnement à chaque étape.

Téléchargez Apidog gratuitement pour configurer ces tests.

Ce qui arrive ensuite

L'équipe Qwen a annoncé l'arrivée de variantes open-source plus petites, sur le modèle Qwen3.5 : MoE sparses, poids publics Apache 2.0.

La feuille de route inclut :

• Tâches référentiel multi-fichiers plus complexes
• Agents multimodaux en priorité : GUI, codage visuel

Les variantes open-source de Qwen3.5 sont devenues la référence auto-hébergée quelques semaines après leur sortie. Qwen3.6 devrait suivre la même trajectoire.

Conclusion

Qwen3.6-Plus comble l'écart avec Claude Opus 4.5 sur le codage, prend l'avantage sur les opérations terminales, les outils MCP et la planification à long terme. Sa fenêtre de 1 million de jetons, compatibilité Anthropic, et le paramètre preserve_thinking en font une solution pertinente et immédiatement exploitable pour les systèmes d'agents en production.

La période gratuite sur OpenRouter a permis d'évaluer, l'API officielle apporte stabilité et SLA. Le nouveau paramètre axé agents fiabilise les workflows multi-tours.

Apidog gère la partie test : importez l'endpoint, écrivez des assertions, simulez les flux, et exécutez des tests de régression à chaque mise à jour.

FAQ

Quelle est la différence entre Qwen3.6-Plus et la préversion ?

La préversion (qwen/qwen3.6-plus-preview) a été lancée sur OpenRouter le 30 mars 2026. La version officielle ajoute le paramètre preserve_thinking, une disponibilité SLA et la prise en charge complète Model Studio. Des variantes open-source plus petites sont prévues.

Qu'est-ce que preserve_thinking et quand l'utiliser ?

Par défaut, seul le raisonnement du tour actuel est conservé. Avec preserve_thinking: true, la chaîne de pensée de tous les tours précédents reste accessible. À utiliser pour les boucles d'agents multi-étapes.

Comment Qwen3.6-Plus se compare-t-il à Claude Opus 4.5 ?

Claude Opus 4.5 domine sur SWE-bench Verified (80,9 % vs 78,8 %) et OSWorld-Verified (66,3 % vs 62,5 %). Qwen3.6-Plus prend l'avantage sur Terminal-Bench 2.0, MCPMark, DeepPlanning et GPQA.

Puis-je utiliser Qwen3.6-Plus avec Claude Code ?

Oui. Définissez ANTHROPIC_BASE_URL sur l'endpoint Dashscope compatible Anthropic, ANTHROPIC_MODEL sur qwen3.6-plus, et ANTHROPIC_AUTH_TOKEN sur votre clé Dashscope.

Qwen3.6-Plus est-il open source ?

Le modèle API hébergé n'est pas open weights. Des variantes plus petites open weights sont attendues sous peu.

Comment obtenir un accès gratuit ?

Installez Qwen Code (npm install -g @qwen-code/qwen-code@latest), lancez qwen, puis /auth. Connectez-vous via Qwen Code OAuth : 1 000 appels API gratuits/jour.

Quelle fenêtre contextuelle est supportée ?

1 million de jetons par défaut. Certains benchmarks utilisent 256K pour standardisation, mais l'API propose 1M par défaut.

Comment tester l'intégration API avant déploiement ?

Importez l'endpoint dans Apidog, ajoutez votre clé API, écrivez des assertions, utilisez Smart Mock pour le développement hors-ligne. Enchaînez les requêtes pour valider le comportement agent multi-tours.