Qwen3-Max-Thinking: práctico con el LLM más grande del mundo

Qwen3-Max-Thinking se lanzó públicamente en noviembre de 2025. Cuando activas el modo thinking, el modelo muestra su razonamiento antes de responder. Podrás ver cómo trabaja con problemas de matemáticas, acertijos lógicos y código complejo. El modelo supera el billón de parámetros y soporta hasta 262k tokens.

En este tutorial, configurarás el acceso por API, pondrás a prueba el modo thinking con distintos problemas y crearás una app en Streamlit que ejecuta el mismo prompt en Qwen3-Max-Thinking, GPT-5 y Claude Sonnet 4.5. Verás cómo cada modelo aborda el problema y cuándo ayuda el modo thinking. Aquí tienes una vista previa de la app:

¿Qué es Qwen3-Max-Thinking?

Qwen3 Max Thinking es la implementación de Alibaba Cloud del modelo Qwen3-Max, lanzada el 5 de septiembre de 2025. El "thinking" de su nombre hace referencia a un modo especial en el que el modelo expone su razonamiento paso a paso antes de dar una respuesta.

El rendimiento del modelo en benchmarks de matemáticas y razonamiento muestra lo que aporta esta función. Combinado con el uso de herramientas (como intérpretes de código para ejecutar cálculos) y el cómputo en tiempo de inferencia escalado, obtuvo un 100% en AIME25, el American Invitational Mathematics Examination que evalúa matemáticas avanzadas de secundaria con razonamiento de varios pasos. También logró un 100% en HMMT, el Harvard-MIT Math Tournament que mide la resolución de problemas complejos. Estos benchmarks evalúan la capacidad real de razonar y no el simple emparejamiento de patrones o la memorización.

Cómo funciona el cómputo en tiempo de inferencia

El cómputo en tiempo de inferencia es la clave del rendimiento excepcional en benchmarks. En lugar de usar recursos computacionales solo durante el entrenamiento (cuando el modelo aprende), también los utiliza durante la inferencia (cuando haces una llamada a la API y el modelo genera una respuesta). Combinado con el uso de herramientas, el modelo puede verificar su razonamiento y contrastar su trabajo con recursos externos.

Cómo se compara Qwen3-Max-Thinking con GPT-5 y Claude Sonnet 4.5

Aunque Qwen3 iguala a GPT-5 y Claude Sonnet 4.5 en ciertos benchmarks como AIME25, los modelos difieren en otras áreas. En tareas de ingeniería de software medidas por SWE-bench Verified, lidera Claude con un 77,2%, seguido de GPT-5 con un 72,8% y Qwen3 con un 69,6%. GPT-5 ofrece la ventana de contexto más grande con 400k tokens, frente a los 262k de Qwen3 y los 200k de Claude.

La ventaja en precio es para Qwen3 con $1.20/$6.00 por millón de tokens de entrada/salida, aproximadamente la mitad del coste de GPT-5 ($1.25/$10.00) y 2,5 veces más barato que Claude ($3.00/$15.00). El modo thinking diferencia a Qwen3 al mostrar pasos de razonamiento explícitos.

Como el modelo sigue en preview y entrenamiento, los resultados de benchmark completos en todas las tareas estarán disponibles cuando Alibaba publique la versión final.

Ahora bien, los benchmarks no cuentan toda la historia. Para hacerte una idea real de cómo rinde el modelo, crearemos más adelante una app de comparación para enfrentarlo a GPT-5 y Claude Sonnet 4.5.

Configurar el acceso por API a Qwen3-Max-Thinking

Antes de usar Qwen3 Max Thinking, necesitas Python 3.8 o superior, pip y una tarjeta de crédito para registrarte en Alibaba Cloud. Al crear tu cuenta por primera vez, tendrás un límite de uso gratuito, pero aun así deberás introducir un método de pago.

Regístrate en Alibaba Cloud y activa Model Studio

Ve a Alibaba Cloud y crea una cuenta. Durante el registro, elegirás entre dos regiones: International (Singapur) o China (Pekín). La mayoría de lectores fuera de la China continental deberían escoger la región International.

Esta elección importa porque cada región tiene su propio endpoint y clave de API que no son intercambiables.

Tras el registro, ve a Model Studio en la consola. Tendrás que activar el servicio antes de poder generar claves de API. El tutorial de Qwen (Alibaba Cloud) te guía por todo el proceso de configuración de la cuenta si quieres capturas y explicaciones más detalladas.

Crea y protege tu clave de API

Cuando Model Studio esté activado, ve a la sección de API Keys en la consola. Genera una nueva clave y cópiala al instante. Alibaba Cloud solo muestra la clave una vez.

Guarda tu clave en un archivo .env para mantenerla separada del código, y añade este archivo a .gitignore para evitar subir tu clave de API al control de versiones por error.

Instala los paquetes de Python y configura el entorno

Qwen3 Max Thinking utiliza una API compatible con OpenAI, así que puedes usar el SDK estándar de OpenAI para Python. Instálalo junto con python-dotenv para gestionar variables de entorno:

pip install openai python-dotenvCon la tecnología de

Crea un archivo .env en el directorio de tu proyecto:

DASHSCOPE_API_KEY=your_key_hereCon la tecnología de

Sustituye your_key_here por tu clave de API. Ahora escribe un script rápido de prueba para verificar que todo funciona:

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)Con la tecnología de

Ejecuta este script. Si ves un error sobre claves de API no válidas, comprueba que copiaste la clave correctamente y que estás usando la base URL correcta para tu región.

Si el script se ejecuta sin errores, deberías obtener una salida como esta:

Hello! How can I assist you today?Con la tecnología de

Entender el modo Thinking de Qwen3-Max

Acabas de hacer una llamada básica a la API. Ahora activa el modo thinking para ver cómo el modelo resuelve problemas paso a paso.

Activa el modo thinking con extra_body

Para activar el modo thinking, añade enable_thinking: True dentro del parámetro extra_body. Aquí tienes un ejemplo con un prompt que se presta bien al razonamiento paso a paso:

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)Con la tecnología de

La respuesta tiene dos partes. El campo reasoning_content muestra el proceso de pensamiento interno del modelo, donde resuelve el problema paso a paso. El campo content te da la respuesta final. Cuando el modo thinking está desactivado, reasoning_content devuelve None.

Así es como se ve la salida (razonamiento 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.Con la tecnología de

Controla costes con thinking_budget

Como el razonamiento consume tokens adicionales, puedes controlar los costes con el parámetro thinking_budget. Añádelo a extra_body junto a 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
   }
)Con la tecnología de

El parámetro thinking_budget define el máximo de tokens que el modelo puede usar para razonar. Para problemas sencillos, 500–1000 tokens funcionan bien. El razonamiento complejo de varios pasos puede necesitar 2000–5000 tokens. Si el modelo alcanza el límite, detiene el razonamiento y proporciona una respuesta final basada en lo ya razonado.

Ya has trabajado con el modo thinking de Qwen3. GPT-5 y Claude también tienen funciones de razonamiento con sintaxis y enfoques distintos. Para ver cómo se comparan, vamos a crear una app que pruebe los tres en paralelo.

Crear una app de chat para comparar varios modelos

Construirás una app en Streamlit que envía el mismo prompt a Qwen3 Max Thinking, GPT-5 y Claude Sonnet 4.5 al mismo tiempo. La app muestra las tres respuestas en paralelo para que compares cómo razona cada modelo.

Puedes ver el código completo del proyecto en este Gist de GitHub. 

Ten en cuenta que las siguientes secciones desglosan ese script en detalle, así que si solo quieres ver los resultados de la app, pasa directamente a la siguiente sección. El desglose del script es didáctico y te muestra cómo estructurar aplicaciones similares basadas en LLM con una interfaz en Streamlit. 

Paso 1: configuración del proyecto y dependencias

Instala Streamlit para la interfaz web y el SDK de Anthropic para Claude. Ya tienes el SDK de OpenAI de la sección de configuración de la API.

pip install streamlit anthropicCon la tecnología de

Crea un archivo nuevo llamado model_comparison_chat.py con los imports y la configuración del entorno:

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()Con la tecnología de

Paso 2: configura las conexiones a las APIs

Ya configuraste Qwen3 en la Sección 3. Ahora añade las claves de API de GPT-5 y Claude a tu archivo .env:

DASHSCOPE_API_KEY=your_alibaba_cloud_key
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_keyCon la tecnología de

Para detalles de acceso y precios de GPT-5, consulta la guía de GPT-5. Para Claude Sonnet 4.5, revisa el resumen de Claude Sonnet 4.5.

Inicializa los tres 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"))Con la tecnología de

Paso 3: crea funciones auxiliares para cada modelo

En lugar de escribir funciones separadas para cada API, usa una única función unificada que gestione los tres modelos. Aquí empieza la función para 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 belowCon la tecnología de

GPT-5 funciona de otra manera: usa la API de responses con niveles de esfuerzo de razonamiento configurables (continuación de la misma función):

       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 belowCon la tecnología de

GPT-5 tiene cuatro niveles de esfuerzo de razonamiento: minimal, low, medium y high. A mayor esfuerzo, mayor calidad, pero respuestas más lentas y costes superiores.

Claude Sonnet 4.5 adopta otro enfoque (continuación de la misma función):

       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 belowCon la tecnología de

Nota: El modo thinking de Claude funciona de forma distinta a Qwen3. En lugar de un reasoning_content separado, Claude incluye bloques de thinking en el contenido de la respuesta que debes parsear. Esta es una diferencia clave al comparar los modelos.

Las tres ramas de la función convergen para devolver la misma estructura (final de la función):

    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)}"
       }Con la tecnología de

Este formato de retorno estandarizado facilita mostrar las respuestas de cualquier modelo con el mismo código.

Paso 4: construye la interfaz en Streamlit

Ahora que entiendes cómo funciona la API de cada modelo, crea la interfaz web. Empieza con la configuración básica de la página en 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", [])Con la tecnología de

El estado de sesión guarda el historial de la conversación y las respuestas de los modelos entre recargas (cuando Streamlit refresca la página tras interacciones del usuario).

Añade el título y los controles de la barra lateral para configurar el modo thinking:

st.title("🤖 Multi-Model Comparison Chat")
   st.markdown("""
   Compare **Qwen3 Max Thinking**, **GPT-5**, y **Claude Sonnet 4.5** en paralelo.
   Los tres modelos admiten modos de razonamiento: observa cómo abordan los problemas de forma diferente.
   """)

   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)Con la tecnología de

Añade los indicadores de estado de las 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 "❌"}
       """)Con la tecnología de

Esto muestra qué claves de API están configuradas. Si ves una X roja, revisa tu archivo .env.

Paso 5: implementa la lógica de comparación

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)}Con la tecnología de

En lugar de esperar a que cada modelo responda de forma secuencial, la ejecución en paralelo llama a los tres a la vez y reduce el tiempo total de espera.

Integralo en tu interfaz de chat y muestra las respuestas en paralelo:

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"])Con la tecnología de

Esto crea tres columnas, una por modelo. El proceso de razonamiento queda plegado por defecto, para que los usuarios se centren en las respuestas finales.

Paso 6: prueba y ajusta

Ejecuta la app con:

streamlit run model_comparison_chat.pyCon la tecnología de

Empieza con una comprobación sencilla como «¿Cuál es 2+2?» para confirmar que las conexiones a las APIs funcionan y que la ejecución en paralelo está activa.

Una vez verificada la funcionalidad básica, ya puedes probar los modelos con prompts complejos que revelen sus distintos enfoques de razonamiento.

Probar la app con prompts complejos

Con la app de comparación en marcha, ponla a prueba con problemas más difíciles. Lanza estos prompts en tu app para ver cómo los afronta cada modelo.

Los prompts de prueba

Aquí tienes tres prompts que muestran patrones claros en la forma de pensar de cada modelo.

Prueba 1: razonamiento matemático avanzado

Una pizza circular se corta en 8 porciones iguales. Alice come 3 porciones, luego Bob come la mitad de lo que queda. Después Charlie coge 1 porción y, por último, Dana come el 40% de las porciones restantes. ¿Cuántas porciones quedan? Además, si la pizza original tenía un diámetro de 16 pulgadas, ¿cuál es el área total (en pulgadas cuadradas) de pizza que se ha consumido?

Prueba 2: razonamiento lógico de varios pasos

Cinco amigos —Amy, Ben, Clara, David y Emma— están sentados en una fila en el

cine. Se deben cumplir las siguientes condiciones:

1. Amy debe sentarse junto a Ben

2. Clara no puede sentarse junto a David

3. Emma debe sentarse en uno de los extremos

4. Ben no puede sentarse en ninguno de los extremos. Con estas restricciones, enumera todas las disposiciones posibles de izquierda a derecha.

Prueba 3: generación de código con restricciones

Escribe una función en Python que encuentre la subcadena palindrómica más larga en una cadena dada, con estos requisitos específicos:

1. La complejidad temporal debe ser O(n²) o mejor

2. Debe gestionar correctamente caracteres Unicode

3. Debe devolver la primera ocurrencia si hay varios palíndromos de la misma longitud

4. Incluye un docstring detallado con ejemplos

5. Añade anotaciones de tipo

6. Gestiona casos límite (cadena vacía, un solo carácter, sin palíndromos).

Explica también tu elección de algoritmo

y por qué cumple el requisito de complejidad.

Resultados

Los tres modelos resolvieron correctamente todos los problemas. Así rindieron:

Qwen3 tarda 10 veces más que Claude y usa entre 3 y 4 veces más tokens.

El enfoque de Qwen3

Lo considera todo. En el problema de la pizza, cuestionó si tiene sentido hablar de fracciones de porción, valoró si las cuentas debían redondearse a números enteros, validó los cálculos varias veces y examinó interpretaciones alternativas antes de fijar una respuesta. 

A lo largo del proceso ves su “¿y si…?” y “aunque quizá…”. En el problema de los asientos, recorrió “si Ben se sienta aquí, ¿dónde puede ir Amy?” para cada posibilidad. 

La solución del palíndromo vino con un análisis profundo de por qué eligió ese algoritmo frente a alternativas, cómo maneja casos límite de Unicode y desgloses exhaustivos de complejidad. Es como ver a alguien pensar en voz alta y comprobar su trabajo una y otra vez.

El enfoque de GPT-5

Estructurado y metódico. Plantea cada problema, recorre los pasos en orden y verifica los resultados. Menos exploración, más ejecución. 

En el rompecabezas de asientos, colocó primero a Emma en un extremo y luego fue llenando posiciones cumpliendo las reglas. 

El código del palíndromo llegó con un razonamiento claro sobre la elección del algoritmo y documentación sólida. Sigue un plan sin mucho retroceso. Ofrece el detalle justo para entender el pensamiento, pero sin dudar constantemente.

El enfoque de Claude 

Va rápido. Detecta pronto la vía de solución y ejecuta con limpieza. En el problema de los asientos, organizó por casos (Emma en la posición 1 vs posición 5) y resolvió cada uno. El código del palíndromo fue claro y bien documentado, pero fue al grano. Muestra su trabajo sin recrearse. Ves el razonamiento, pero es conciso.

La conclusión práctica: usa Qwen3 cuando necesites ver todas las consideraciones que han llevado a una solución. El thinking detallado ayuda cuando estás aprendiendo del modelo o validando decisiones complejas. Usa Claude cuando la velocidad importe y confíes en que dará la respuesta sin enseñarte cada paso. Usa GPT-5 cuando quieras algo intermedio.

Nota: Estas pruebas no capturan por completo las capacidades de los tres modelos. Tus resultados pueden variar según los prompts.

Conclusión

En este tutorial, he mostrado cómo configurar Qwen3 Max Thinking, he probado su modo thinking con distintos tipos de problemas y he construido una app de comparación que ejecuta prompts en Qwen3, GPT-5 y Claude Sonnet 4.5 en paralelo. 

La idea clave es que cada modelo tiene puntos fuertes según el escenario. Qwen3 destaca cuando necesitas razonamientos detallados y comprender cada paso. Claude gana en velocidad y ejecución limpia. GPT-5 equilibra ambos enfoques.

Usa tu app de comparación para probar estos modelos con tus propios problemas. A medida que experimentes con distintas tareas, irás viendo qué modelo te funciona mejor según tus necesidades.

Para profundizar en Qwen3 y el desarrollo multi-modelo, echa un vistazo al tutorial de OpenRouter para gestionar múltiples APIs de modelos, o aprende a ejecutar modelos Qwen3 más pequeños en local con Ollama para desarrollo sin conexión.