API Qwen3.6-Plus: Desempenho Superior ao Claude em Testes de Terminal

TL;DR

Qwen3.6-Plus foi lançado oficialmente. Ele atinge 78,8% no SWE-bench Verified e 61,6% no Terminal-Bench 2.0, superando o Claude Opus 4.5 nesse benchmark. Possui janela de contexto de 1M de tokens, novo parâmetro preserve_thinking para loops de agente e integração direta com Claude Code, OpenClaw e Qwen Code via API compatível com OpenAI.

Experimente o Apidog hoje

Da prévia ao lançamento

Se você acompanhou nosso guia anterior sobre o Qwen 3.6 Plus Preview no OpenRouter, já conhece o potencial do modelo. A prévia foi lançada em 30 de março, sem lista de espera e com acesso gratuito via OpenRouter. Nos dois primeiros dias, processou mais de 400 milhões de tokens em 400.000 requisições.

Agora, o lançamento oficial traz a versão de produção: API estável, SLA garantido e o novo parâmetro de API para agentes multi-etapas.

Este guia explica o que mudou, como integrar com a API e como validar tudo no Apidog antes do deploy.

O que é Qwen3.6-Plus

Qwen3.6-Plus é um modelo MoE (mixture of experts) hospedado pela equipe Qwen da Alibaba. Utiliza ativação esparsa, ativando apenas parte dos parâmetros por token, garantindo desempenho forte com menor custo computacional.

Principais especificações:

• Janela de contexto: 1 milhão de tokens
• Raciocínio em cadeia de pensamento (CoT) obrigatório
• Novo parâmetro preserve_thinking para agentes
• Suporte multimodal: visão, vídeo, documentos
• API compatível com OpenAI, Anthropic e OpenAI Responses

Versões menores open source serão lançadas em breve. Se você precisa dos pesos, fique atento.

Resultados dos benchmarks

Agentes de codificação

Qwen3.6-Plus fica um pouco atrás do Claude Opus 4.5 no SWE-bench, mas lidera nas operações de terminal.

No Terminal-Bench 2.0 (operações reais de shell, múltiplas etapas, 3h de timeout, 32 CPUs), Qwen3.6-Plus faz 61,6% vs 59,3% do Claude Opus 4.5 — diferença relevante para automação de terminal.

Agentes gerais e uso de ferramentas

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%

Destaque para o MCPMark (integrações GitHub MCP) e DeepPlanning (tarefas de planejamento de longo prazo).

Raciocínio e conhecimento

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%

GPQA e IFEval são importantes para tarefas de raciocínio e instruções complexas.

Multimodal

Qwen3.6-Plus é nativamente multimodal e lidera benchmarks de documentos, espaciais e contagem.

Benchmark	Qwen3.6-Plus	Notas
OmniDocBench 1.5	91.2%	Líder na tabela
RefCOCO avg	93.5%	Líder na tabela
We-Math	89.0%	Líder na tabela
CountBench	97.6%	Líder na tabela
OSWorld-Verified	62.5%	Atrás de Claude (66,3%)

Em tarefas de compreensão de documentos e ancoragem espacial, Qwen3.6-Plus se destaca.

Como chamar a API

O Qwen3.6-Plus está disponível no Alibaba Cloud Model Studio. Pegue sua chave em modelstudio.alibabacloud.com.

URLs regionais:

• Singapura: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
• Pequim: https://dashscope.aliyuncs.com/compatible-mode/v1
• Virgínia (EUA): https://dashscope-us.aliyuncs.com/compatible-mode/v1

Chamada básica com 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)

O parâmetro preserve_thinking

Na prévia, só o raciocínio atual era mantido. Agora, com preserve_thinking: true, o modelo retém toda a cadeia de pensamento da conversa — recomendado para loops de agente multi-etapas.

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=conversation_history,
    extra_body={
        "enable_thinking": True,
        "preserve_thinking": True, # mantém toda a cadeia de raciocínio
    },
    stream=True
)

Use Qwen3.6-Plus com Claude Code

A API Qwen é compatível com o protocolo Anthropic. Basta ajustar as variáveis de ambiente para usar com Claude Code:

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

Use Qwen3.6-Plus com OpenClaw

OpenClaw é um agente de codificação open source auto-hospedado. Instale e aponte para o Model Studio:

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

export DASHSCOPE_API_KEY=your_key
openclaw dashboard

Edite ~/.openclaw/openclaw.json e adicione:

{
  "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"]}
  }
}

Use Qwen3.6-Plus com Qwen Code

Qwen Code é o agente de terminal open source da Alibaba, com 1.000 chamadas de API gratuitas por dia via OAuth.

npm install -g @qwen-code/qwen-code@latest
qwen
# Digite /auth para ativar o nível gratuito

Por que preserve_thinking muda o comportamento do agente

A maioria das APIs LLM descarta o raciocínio de etapas anteriores. Em agentes multi-turn, isso gera inconsistência: o modelo não lembra por que tomou decisões passadas.

Com preserve_thinking, toda a cadeia de raciocínio é mantida — essencial para tarefas complexas de múltiplas etapas.

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

# Exemplo: agente de revisão de código multi-etapas
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.")

Sem preserve_thinking, o modelo perde o histórico da análise. Com ele, a consistência aumenta e o raciocínio é compartilhado entre etapas.

Para que é melhor

• Correção de bugs em nível de repositório: SWE-bench Verified (78,8%) e SWE-bench Pro (56,6%) são altamente competitivos.
• Automação de terminal: Liderança no Terminal-Bench 2.0 para fluxos shell intensivos.
• Chamada de ferramentas MCP: Liderança no MCPMark (48,2%).
• Análise de documentos longos: Janela de 1M tokens, excelente para revisões extensas.
• Geração de código frontend: Empate técnico com Claude Opus 4.5 no QwenWebBench.
• Multilíngue: WMT24++ (84,3%) e MAXIFE (88,2%) mostram força em vários idiomas.

Testando chamadas de API do Qwen3.6-Plus com Apidog

O endpoint é compatível com OpenAI. Importe para o Apidog e teste como qualquer API.

Configure uma requisição POST para https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions e adicione sua chave de API como variável de ambiente: Authorization: Bearer {{DASHSCOPE_API_KEY}}.

Asserções de resposta:

pm.test("Response contains choices", () => {
  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("No empty reasoning when thinking enabled", () => {
  const choice = pm.response.json().choices[0];
  if (choice.message.reasoning_content !== undefined) {
    pm.expect(choice.message.reasoning_content).to.not.be.empty;
  }
});

Use o Smart Mock do Apidog para simular respostas durante o desenvolvimento — economize tokens e agilize testes.

Para agentes multi-turn, crie Cenários de Teste encadeando múltiplas requisições e valide que o preserve_thinking mantém o raciocínio entre etapas.

Baixe o Apidog gratuitamente para configurar esses testes.

O que vem a seguir

A equipe Qwen vai lançar variantes menores open source nos próximos dias — modelos MoE esparsos com pesos Apache 2.0.

No roadmap:

• Tarefas de repositório com horizontes mais longos e múltiplos arquivos
• Agentes multimodais mais avançados (GUI, codificação visual nativa)

Se seguir o padrão do Qwen3.5, essas variantes open source devem se tornar padrão para agentes de codificação auto-hospedados rapidamente.

Conclusão

O Qwen3.6-Plus fecha a distância com Claude Opus 4.5 em codificação e lidera em operações de terminal, MCP e planejamento. Janela de 1M de tokens, protocolo Anthropic e preserve_thinking tornam-no prático para agentes de produção.

O período de prévia no OpenRouter foi útil para testes. A API oficial garante estabilidade, SLA e recursos avançados para fluxos multi-turn.

O Apidog cuida dos testes: importe o endpoint OpenAI, escreva asserções, use mock, valide respostas e rode testes de regressão sempre que atualizar modelo ou API.

FAQ

Qual a diferença entre Qwen3.6-Plus e a prévia?

A prévia (qwen/qwen3.6-plus-preview) saiu no OpenRouter em 30 de março de 2026. O lançamento oficial adiciona o parâmetro preserve_thinking, SLA garantido e suporte ao Model Studio. Variantes menores open source estão a caminho.

O que é preserve_thinking e quando devo usar?

Por padrão, só o raciocínio da interação atual é mantido. Com preserve_thinking: true, o modelo guarda toda a cadeia de pensamento da conversa. Use em loops de agente multi-etapas.

Como o Qwen3.6-Plus se compara ao Claude Opus 4.5?

Claude lidera no SWE-bench Verified (80,9% vs 78,8%) e no OSWorld-Verified (66,3% vs 62,5%). Qwen3.6-Plus domina Terminal-Bench 2.0 (61,6% vs 59,3%), MCPMark (48,2% vs 42,3%), DeepPlanning (41,5% vs 33,9%) e GPQA (90,4% vs 87,0%).

Posso usar Qwen3.6-Plus com Claude Code?

Sim. Defina ANTHROPIC_BASE_URL para o endpoint Anthropic do Dashscope, ANTHROPIC_MODEL para qwen3.6-plus e ANTHROPIC_AUTH_TOKEN para sua chave de API.

O Qwen3.6-Plus é open source?

O modelo hospedado não é, mas variantes menores com pesos públicos serão lançadas em dias.

Como obtenho acesso gratuito?

Instale o Qwen Code (npm install -g @qwen-code/qwen-code@latest), rode qwen e use /auth para ativar 1.000 chamadas diárias gratuitas via OAuth.

Qual janela de contexto ele suporta?

1 milhão de tokens por padrão. Alguns benchmarks usaram 256K para comparação, mas a API suporta 1M.

Como testo a integração da API antes do deploy?

Importe o endpoint no Apidog, adicione sua chave de API como variável de ambiente, escreva asserções e use o Smart Mock para testar offline. Encadeie requisições em Cenários de Teste para validar comportamento multi-turn de ponta a ponta.