Qwen3-Max-Thinking: mãos na massa com o maior LLM do mundo

O Qwen3-Max-Thinking ficou disponível publicamente em novembro de 2025. Ao ativar o thinking mode, o modelo exibe seu raciocínio antes de responder. Você consegue ver como ele resolve problemas de matemática, quebra-cabeças lógicos e código complexo. O modelo tem mais de 1 trilhão de parâmetros e suporta até 262 mil tokens.

Neste tutorial, você vai configurar o acesso via API, testar o thinking mode em diferentes problemas e construir um app em Streamlit que roda o mesmo prompt no Qwen3-Max-Thinking, no GPT-5 e no Claude Sonnet 4.5. Você vai ver como cada modelo aborda o problema e quando o thinking mode ajuda. Aqui vai um preview do app:

O que é o Qwen3-Max-Thinking?

Qwen3 Max Thinking é a implementação do modelo Qwen3-Max na Alibaba Cloud, lançada em 5 de setembro de 2025. O "thinking" no nome se refere a um modo especial em que o modelo expõe seu processo de raciocínio passo a passo antes de fornecer a resposta.

O desempenho do modelo em benchmarks de matemática e raciocínio mostra o que esse recurso entrega. Combinado ao uso de ferramentas (como interpretadores de código para rodar cálculos) e ao aumento de compute em tempo de inferência, ele marcou 100% no AIME25, o American Invitational Mathematics Examination que avalia matemática avançada do ensino médio com raciocínio em múltiplas etapas. Também atingiu 100% no HMMT, o Harvard-MIT Math Tournament que mede resolução de problemas complexos. Esses benchmarks testam a habilidade real de raciocinar, não apenas reconhecimento de padrões ou memorização.

Como funciona o compute em tempo de inferência

O compute em tempo de inferência é como o modelo alcança seu desempenho excepcional em benchmarks. Em vez de usar recursos computacionais apenas durante o treinamento (quando o modelo aprende), ele também os usa durante a inferência (quando você faz uma chamada à API e o modelo gera uma resposta). Combinado ao uso de ferramentas, o modelo consegue verificar seu raciocínio e checar o trabalho em recursos externos.

Como o Qwen3-Max-Thinking se compara ao GPT-5 e ao Claude Sonnet 4.5

Embora o Qwen3 acompanhe o GPT-5 e o Claude Sonnet 4.5 em benchmarks como o AIME25, os modelos diferem em outras áreas. Em tarefas de engenharia de software medidas pelo SWE-bench Verified, o Claude lidera com 77,2%, seguido pelo GPT-5 com 72,8% e o Qwen3 com 69,6%. O GPT-5 oferece a maior janela de contexto com 400 mil tokens, frente a 262 mil do Qwen3 e 200 mil do Claude.

A vantagem de preço fica com o Qwen3 a US$ 1,20/US$ 6,00 por milhão de tokens para entrada/saída — cerca de metade do custo do GPT-5 (US$ 1,25/US$ 10,00) e 2,5 vezes mais barato que o Claude (US$ 3,00/US$ 15,00). O thinking mode diferencia o Qwen3 por mostrar etapas explícitas de raciocínio.

Como o modelo ainda está em prévia e treinamento, resultados abrangentes de benchmarks em todas as tarefas estarão disponíveis quando a Alibaba lançar a versão final.

Mas benchmarks não contam a história toda. Para sentir na prática como o modelo performa, vamos criar um app de comparação mais adiante para confrontá-lo com o GPT-5 e o Claude Sonnet 4.5.

Configurando o acesso à API do Qwen3-Max-Thinking

Antes de usar o Qwen3 Max Thinking, você vai precisar do Python 3.8 ou superior, do pip e de um cartão de crédito para se registrar na Alibaba Cloud. Ao criar a conta, você recebe um limite gratuito de uso, mas ainda assim precisa informar os dados de pagamento.

Cadastre-se na Alibaba Cloud e ative o Model Studio

Acesse Alibaba Cloud e crie uma conta. Durante o cadastro, você vai escolher entre duas regiões: International (Cingapura) ou China (Pequim). A maioria dos leitores fora da China continental deve escolher a região International.

Essa escolha importa porque cada região tem seu próprio endpoint e chave de API, que não são intercambiáveis.

Após o cadastro, navegue até o Model Studio no console. Você precisa ativar o serviço antes de poder gerar chaves de API. O tutorial do Qwen (Alibaba Cloud) mostra todo o processo de configuração da conta, com capturas de tela e explicações detalhadas.

Crie e proteja sua chave de API

Com o Model Studio ativado, vá até a seção API Keys no console. Gere uma nova chave e copie imediatamente. A Alibaba Cloud exibe a chave apenas uma vez.

Guarde sua chave em um arquivo .env para mantê-la separada do seu código e adicione esse arquivo ao .gitignore para evitar subir a chave para o controle de versão por engano.

Instale os pacotes Python e configure o ambiente

O Qwen3 Max Thinking usa uma API compatível com a do OpenAI, então você pode usar o SDK Python padrão do OpenAI. Instale-o junto com o python-dotenv para gerenciar variáveis de ambiente:

pip install openai python-dotenvTecnologia

Crie um arquivo .env no diretório do seu projeto:

DASHSCOPE_API_KEY=your_key_hereTecnologia

Substitua your_key_here pela sua chave de API. Agora escreva um script rápido para verificar se está tudo funcionando:

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

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

completion = client.chat.completions.create(
   model="qwen3-max-preview",
   messages=[{"role": "user", "content": "Say hello in one sentence."}]
)

print(completion.choices[0].message.content)Tecnologia

Execute esse script. Se você vir um erro sobre chaves de API inválidas, confira se copiou a chave corretamente e se está usando a base URL certa para a sua região.

Se o script rodar sem erros, você deve ver uma saída como esta:

Hello! How can I assist you today?Tecnologia

Entendendo o thinking mode do Qwen3-Max

Você acabou de fazer uma chamada básica à API. Agora ative o thinking mode para ver o modelo resolver problemas passo a passo.

Ative o thinking mode com extra_body

Para ativar o thinking mode, adicione enable_thinking: True dentro do parâmetro extra_body. Veja um exemplo com um prompt que funciona bem com raciocínio passo a passo:

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

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

completion = client.chat.completions.create(
   model="qwen3-max-preview",
   messages=[
       {"role": "user", "content": "If I have 3 apples and buy 2 more packs of 4 apples each, then give away half, how many do I have left?"}
   ],
   extra_body={"enable_thinking": True}
)

print("Reasoning:", completion.choices[0].message.reasoning_content)
print("\nFinal answer:", completion.choices[0].message.content)Tecnologia

A resposta vem em duas partes. O campo reasoning_content mostra o processo interno de raciocínio do modelo, onde ele trabalha o problema passo a passo. O campo content traz a resposta final. Quando o thinking mode está desativado, reasoning_content retorna None.

Veja como a saída fica (raciocínio truncado):

Reasoning: The problem: "If I have 3 apples and buy 2 more packs of 4 apples each, then give away half, how many do I have left?" Starting with 3 apples. Then buy 2 packs of 4 apples each: that's 2 * 4 = 8 apples. So total after buying is 3 + 8 = 11 apples. Then give away half: half of 11 is 5.5 apples...

Final answer:
1. Start with: 3 apples.
2. Buy 2 packs of 4 apples each → 2 × 4 = 8 apples.
3. Total after buying: 3 + 8 = 11 apples.
4. Give away half: 11/2 = 5.5 apples.

Answer: You have 5½ apples left.Tecnologia

Controle custos com thinking_budget

Como o raciocínio consome tokens adicionais, você pode controlar custos com o parâmetro thinking_budget. Adicione-o ao extra_body junto com o enable_thinking:

completion = client.chat.completions.create(
   model="qwen3-max-preview",
   messages=[
       {"role": "user", "content": "Explain why 0.1 + 0.2 doesn't equal 0.3 in Python."}
   ],
   extra_body={
       "enable_thinking": True,
       "thinking_budget": 1000
   }
)Tecnologia

O parâmetro thinking_budget define o máximo de tokens que o modelo pode usar para raciocinar. Para problemas simples, 500–1000 tokens funcionam. Raciocínios complexos em múltiplas etapas podem precisar de 2000–5000 tokens. Se o modelo atingir o limite de orçamento, ele interrompe o processo de raciocínio e fornece uma resposta final com base no que foi desenvolvido até aquele ponto.

Agora você já trabalhou com o thinking mode do Qwen3. GPT-5 e Claude também têm recursos de raciocínio, com sintaxes e abordagens diferentes. Para ver como esses modelos se comparam, vamos construir um app que testa os três lado a lado.

Construindo um chat de comparação multi-modelo

Você vai construir um app em Streamlit que envia o mesmo prompt para o Qwen3 Max Thinking, o GPT-5 e o Claude Sonnet 4.5 ao mesmo tempo. O app mostra as três respostas lado a lado para você comparar como cada modelo raciocina sobre os problemas.

Você pode ver o código completo do projeto neste Gist no GitHub. 

Observe que as seções a seguir trazem um detalhamento desse script, então, se você só quer ver os resultados do app, pode pular diretamente para a próxima seção. O passo a passo do script é educacional e mostra como estruturar aplicativos similares baseados em LLM com uma interface em Streamlit. 

Passo 1: configuração do projeto e dependências

Instale o Streamlit para a interface web e o SDK da Anthropic para o Claude. Você já tem o SDK do OpenAI da etapa de configuração da API.

pip install streamlit anthropicTecnologia

Crie um novo arquivo chamado model_comparison_chat.py com os imports e a configuração de ambiente:

import os
import time
from typing import Dict, List
from concurrent.futures import ThreadPoolExecutor, as_completed
from dotenv import load_dotenv
import streamlit as st
from openai import OpenAI
from anthropic import Anthropic

load_dotenv()Tecnologia

Passo 2: configure as conexões de API

Você já configurou o Qwen3 na Seção 3. Agora adicione as chaves de API do GPT-5 e do Claude ao seu arquivo .env:

DASHSCOPE_API_KEY=your_alibaba_cloud_key
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_keyTecnologia

Para acesso e preços do GPT-5, veja o guia do GPT-5. Para o Claude Sonnet 4.5, confira a visão geral do Claude Sonnet 4.5.

Inicialize os três clientes de API:

QWEN_CLIENT = OpenAI(
   api_key=os.getenv("DASHSCOPE_API_KEY"),
   base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)
GPT_CLIENT = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
CLAUDE_CLIENT = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))Tecnologia

Passo 3: crie funções auxiliares para cada modelo

Em vez de escrever funções separadas para cada API, use uma função unificada que trate os três modelos. Aqui está o começo da função para o Qwen3:

def call_model(model_name: str, messages: List[Dict], **kwargs) -> Dict:
   """Call any model with unified interface."""
   try:
       start_time = time.time()

       if model_name == "Qwen3 Max Thinking":
           enable_thinking = kwargs.get("enable_thinking", True)
           extra_body = {"enable_thinking": enable_thinking}

           completion = QWEN_CLIENT.chat.completions.create(
               model="qwen3-max-preview",
               messages=messages,
               extra_body=extra_body
           )
           reasoning_content = getattr(
               completion.choices[0].message,
               'reasoning_content',
               None
           )
           # Extract content and token info, then continue belowTecnologia

O GPT-5 funciona de forma diferente, usando a API de responses com níveis configuráveis de esforço de raciocínio (continuação da mesma função):

       elif model_name == "GPT-5":
           reasoning_effort = kwargs.get("reasoning_effort", "medium")

           response = GPT_CLIENT.responses.create(
               model="gpt-5",
               input=messages,
               reasoning={
                   "effort": reasoning_effort,
                   "summary": "auto"
               }
           )
           # Extract response data, then continue belowTecnologia

O GPT-5 tem quatro níveis de esforço de raciocínio: minimal, low, medium e high. Quanto maior o esforço, melhor a qualidade — mas as respostas ficam mais lentas e custam mais.

O Claude Sonnet 4.5 segue outra abordagem (continuação da mesma função):

       else:  # Claude Sonnet 4.5
           enable_thinking = kwargs.get("enable_thinking", True)
           params = {
               "model": "claude-sonnet-4-5",
               "max_tokens": 10000,
               "messages": messages
           }
           if enable_thinking:
               params["thinking"] = {
                   "type": "enabled",
                   "budget_tokens": 5000
               }

           message = CLAUDE_CLIENT.messages.create(**params)
           # Parse thinking blocks from response, then continue belowTecnologia

Observação: o thinking mode do Claude funciona diferente do Qwen3. Em vez de um reasoning_content separado, o Claude inclui blocos de thinking no conteúdo da resposta que você precisa extrair. Essa é uma diferença chave ao comparar os modelos.

As três ramificações convergem para retornar a mesma estrutura (fim da função):

    return {
               "content": content_text,
               "reasoning_content": thinking_text,
               "response_time": time.time() - start_time,
               "tokens_used": {
                   "input": input_tokens,
                   "output": output_tokens,
                   "total": total_tokens
               },
               "error": None
           }

   except Exception as e:
       return {
           "content": None,
           "reasoning_content": None,
           "response_time": 0,
           "tokens_used": {"input": 0, "output": 0, "total": 0},
           "error": f"{model_name} Error: {str(e)}"
       }Tecnologia

Esse formato de retorno padronizado facilita exibir respostas de qualquer modelo com o mesmo código.

Passo 4: construa a interface no Streamlit

Agora que você entendeu como funciona a API de cada modelo, crie a interface web. Comece com a configuração básica da página no Streamlit:

def main():
   st.set_page_config(
       page_title="Multi-Model Comparison Chat",
       page_icon="🤖",
       layout="wide",
       initial_sidebar_state="expanded"
   )

   st.session_state.setdefault("messages", [])
   st.session_state.setdefault("model_responses", [])Tecnologia

O estado de sessão guarda o histórico da conversa e as respostas dos modelos entre as recargas (quando o Streamlit atualiza a página após interações do usuário).

Adicione o título e os controles na barra lateral para configurar o thinking mode:

st.title("🤖 Multi-Model Comparison Chat")
   st.markdown("""
   Compare **Qwen3 Max Thinking**, **GPT-5**, and **Claude Sonnet 4.5** side-by-side.
   All three models support reasoning modes - see how they approach problems differently.
   """)

   with st.sidebar:
       st.header("⚙️ Settings")

       st.subheader("Thinking Mode")
       qwen_thinking = st.checkbox("Enable Qwen3 Thinking", value=True)
       gpt5_reasoning = st.selectbox(
           "GPT-5 Reasoning Effort",
           options=["minimal", "low", "medium", "high"],
           index=2
       )
       claude_thinking = st.checkbox("Enable Claude Thinking", value=True)Tecnologia

Adicione indicadores de status das APIs:

st.subheader("API Status")
       st.markdown(f"""
       - Qwen3: {"✅" if os.getenv("DASHSCOPE_API_KEY") else "❌"}
       - GPT-5: {"✅" if os.getenv("OPENAI_API_KEY") else "❌"}
       - Claude: {"✅" if os.getenv("ANTHROPIC_API_KEY") else "❌"}
       """)Tecnologia

Isso mostra quais chaves de API estão configuradas. Se você vir um X vermelho, confira seu arquivo .env.

Passo 5: implemente a lógica de comparação

def call_models_parallel(messages: List[Dict], selected_models: List[str], qwen_thinking: bool, gpt5_reasoning: str, claude_thinking: bool) -> Dict[str, Dict]:
   """Call multiple models in parallel."""
   model_kwargs = {
       "Qwen3 Max Thinking": {"enable_thinking": qwen_thinking},
       "GPT-5": {"reasoning_effort": gpt5_reasoning},
       "Claude Sonnet 4.5": {"enable_thinking": claude_thinking}
   }

   with ThreadPoolExecutor(max_workers=3) as executor:
       futures = {
           executor.submit(call_model, m, messages, **model_kwargs[m]): m
           for m in selected_models if m in model_kwargs
       }
       return {futures[f]: f.result() for f in as_completed(futures)}Tecnologia

Em vez de esperar cada modelo responder em sequência, a execução paralela chama todos de uma vez, reduzindo o tempo total de espera.

Integre isso à sua interface de chat e exiba as respostas lado a lado:

if prompt := st.chat_input("Ask a question to all models..."):
       st.session_state.messages.append({"role": "user", "content": prompt})

       with st.spinner("🤔 Models are thinking..."):
           responses = call_models_parallel(
               st.session_state.messages,
               ["Qwen3 Max Thinking", "GPT-5", "Claude Sonnet 4.5"],
               qwen_thinking,
               gpt5_reasoning,
               claude_thinking
           )

       cols = st.columns(3)
       for idx, (model_name, response_data) in enumerate(responses.items()):
           with cols[idx]:
               st.markdown(f"### {model_name}")
               if response_data["reasoning_content"]:
                   with st.expander("🧠 Thinking Process", expanded=False):
                       st.markdown(response_data["reasoning_content"])
               st.markdown(response_data["content"])Tecnologia

Isso cria três colunas, uma para cada modelo. O processo de raciocínio fica recolhido por padrão, para que os usuários foquem nas respostas finais.

Passo 6: teste e refine

Rode o app com:

streamlit run model_comparison_chat.pyTecnologia

Comece com uma pergunta simples de verificação, como “Quanto é 2+2?”, para confirmar as conexões de API e se a execução paralela está funcionando.

Depois de confirmar o básico, você está pronto para testar os modelos com prompts complexos que revelam suas diferentes abordagens de raciocínio.

Testando o app com prompts complexos

Com o app de comparação rodando, teste-o com problemas mais difíceis. Experimente rodar estes prompts no app para ver como os modelos os abordam.

Os prompts de teste

Aqui estão três prompts que mostram padrões claros de como cada modelo pensa.

Teste 1: raciocínio matemático avançado

Uma pizza circular é cortada em 8 fatias iguais. Alice come 3 fatias, então Bob come metade do que sobrou. Depois, Charlie pega 1 fatia e, por fim, Dana come 40% das fatias restantes. Quantas fatias sobraram? Além disso, se a pizza original tinha diâmetro de 16 polegadas, qual é a área total (em polegadas quadradas) da pizza que foi consumida?

Teste 2: raciocínio lógico em múltiplas etapas

Cinco amigos — Amy, Ben, Clara, David e Emma — estão sentados em uma fileira no

cinema. As seguintes condições devem ser atendidas:

1. Amy deve sentar ao lado de Ben

2. Clara não pode sentar ao lado de David

3. Emma deve sentar em uma das pontas

4. Ben não pode sentar em nenhuma das pontas. Dadas essas restrições, liste todas as possíveis disposições de assentos da esquerda para a direita.

Teste 3: geração de código com restrições

Escreva uma função em Python que encontre a substring palindrômica mais longa em uma string dada, com estes requisitos específicos:

1. Complexidade de tempo deve ser O(n²) ou melhor

2. Deve lidar corretamente com caracteres Unicode

3. Deve retornar a primeira ocorrência se houver múltiplos palíndromos do mesmo tamanho

4. Incluir docstring detalhada com exemplos

5. Adicionar type hints

6. Tratar casos extremos (string vazia, único caractere, sem palíndromos).

Também explique sua escolha de algoritmo

e por que ela atende ao requisito de complexidade.

Resultados

Os três modelos acertaram todos os problemas. Veja como foi o desempenho:

O Qwen3 leva 10x mais tempo que o Claude e usa de 3 a 4x mais tokens.

A abordagem do Qwen3

Ele considera tudo. No problema da pizza, questionou se fatias fracionárias fazem sentido, considerou se deveria arredondar para números inteiros, validou cálculos várias vezes e examinou interpretações alternativas antes de fechar a resposta. 

Você vê o modelo pensando “e se…” e “mas talvez…” o tempo todo. No problema dos assentos, ele trabalhou “se o Ben senta aqui, onde a Amy pode ir” para todas as possibilidades. 

A solução de palíndromo veio com análise profunda do porquê escolheu aquele algoritmo em vez de alternativas, como lida com casos de Unicode e um detalhamento cuidadoso de complexidade. É como ver alguém pensar em voz alta e checar o próprio trabalho repetidas vezes.

A abordagem do GPT-5

É estruturado e metódico. Apresenta cada problema, segue os passos em ordem e verifica resultados. Menos exploração, mais execução. 

No quebra-cabeça dos assentos, colocou a Emma em uma ponta primeiro e depois preencheu as posições checando as regras. 

O código de palíndromo veio com uma justificativa clara da escolha do algoritmo e documentação sólida. Segue um plano sem muitos recuos. Você tem detalhe suficiente para entender o raciocínio, mas sem se autocuestionar o tempo todo.

A abordagem do Claude 

É rápido. Identifica o caminho da solução rapidamente e executa com limpeza. No problema dos assentos, organizou por casos (Emma na posição 1 vs. posição 5) e trabalhou cada um. O código de palíndromo ficou limpo e bem documentado, indo direto ao ponto. Ele mostra o trabalho, mas sem se alongar. Você vê o raciocínio, só que de forma concisa.

O recado prático: use o Qwen3 quando você precisa enxergar todas as considerações por trás de uma solução. O raciocínio detalhado ajuda quando você está aprendendo com o modelo ou validando decisões complexas. Use o Claude quando velocidade importa e você confia que ele vai chegar à resposta sem mostrar cada passo. Use o GPT-5 quando você quer algo entre esses extremos.

Observação: Esses testes não capturam totalmente as habilidades dos três modelos. Seus resultados podem variar com prompts diferentes.

Conclusão

Neste tutorial, eu mostrei como configurar o Qwen3 Max Thinking, testei seu thinking mode com diferentes tipos de problemas e construí um app de comparação que roda prompts no Qwen3, no GPT-5 e no Claude Sonnet 4.5 lado a lado. 

O principal insight é que cada modelo tem pontos fortes para cenários distintos. O Qwen3 se destaca quando você precisa de raciocínio detalhado e quer entender cada passo. O Claude vence em velocidade e execução limpa. O GPT-5 equilibra as duas abordagens.

Use seu app de comparação para testar esses modelos com seus próprios problemas. Conforme você experimentar diferentes tarefas, vai desenvolver um senso de qual modelo funciona melhor para as suas necessidades.

Para ir mais a fundo com o Qwen3 e desenvolvimento multi-modelo, confira o tutorial do OpenRouter para gerenciar múltiplas APIs de modelos, ou aprenda como rodar modelos menores do Qwen3 localmente com o Ollama para desenvolvimento offline.