Qwen3-Siguiente: Una guía con proyecto de demostración

El equipo de Qwen ha lanzado recientemente el modelo Qwen3-Next-80B-A3B , que combina razonamiento avanzado, manejo de contexto ultralargo y una velocidad de inferencia excepcional utilizando una arquitectura híbrida Mixture-of-Experts (MoE).

En esta guía, me centraré en el rendimiento del Qwen3-Next-80B-A3B en tareas prácticas y reales en comparación con modelos Qwen anteriores, como el Qwen3-30B-A3B. En lugar de comparativas abstractas, realizaremos pruebas prácticas comparativas, que incluirán razonamiento, código y documentos ultralargos, para que puedas ver las ventajas e inconvenientes en cuanto a velocidad, calidad de salida y uso de la memoria de la GPU.

Paso a paso, te mostraré cómo:

• Accede e interactúa con Qwen3-Next-80B-A3B y Qwen3-30B-A3B a través de la API OpenRouter, sin necesidad de configuración.
• Crea una aplicación Streamlit para comparar al instante y de forma paralela las respuestas de los modelos, la latencia y el uso de recursos.
• Realizar experimentos de recuperación de contexto ultralargos (más de 100 000 tokens) para poner a prueba los límites reales de los modelos.
• Analiza métricas de rendimiento del mundo real, como latencia, tokens/segundo y uso de VRAM.

Al final, tu aplicación tendrá este aspecto:

¿Qué es Qwen3-Next?

Qwen3-Next es un modelo de 80B parámetros de mezcla de expertos (MoE). En la práctica, solo activa 3B parámetros por token, lo que hace que sea hasta diez veces más barato de entrenar y diez veces más rápido de ejecutar que los modelos densos más antiguos (como Qwen3-32B), al tiempo que iguala o supera su calidad.

Algunos avances clave en este modelo incluyen:

• Arquitectura híbrida: Qwen3-Next utiliza una combinación 75:25 de Gated DeltaNet (para una atención lineal rápida) y Gated Attention (para una memoria profunda), combinando las ventajas de ambos métodos.
• e MoE ultraesparso: Emplea a 512 expertos, pero solo activa 10+1 por inferencia, lo que reduce el cálculo en más de un 90 % en comparación con los LLM densos.
• Predicción multitoken: Este modelo admite decodificación especulativa para obtener un enorme aumento de la velocidad, especialmente en streaming o chat.
• o de contexto extremadamente largo: Procesa hasta 256 000 tokens de forma nativa (más de 1 millón con escalado YaRN) con una caída mínima del rendimiento, y es ideal para libros largos, bases de código, etc.

Fuente: Qwen

El modelo Qwen 3 Next está disponible en dos variantes:

• Qwen3-Next-80B-A3B-Instruct: Este modelo está diseñado para chatear sobre temas generales, programar y realizar preguntas y respuestas abiertas.
• Qwen3-Next-80B-A3B-Pensamiento: Aunque este modelo se puede utilizar para razonamientos avanzados, cadenas de pensamiento y flujos de trabajo de investigación.

Demostración: Preguntas y respuestas y razonamiento con Qwen3-Next con la API de OpenRouter

En esta sección, mostraré cómo utilizar el modelo Qwen3-Next a través de API OpenRouter para crear un asistente interactivo de preguntas y respuestas y razonamiento.

Así es como funciona:

• Introduce una pregunta en el cuadro de texto o arrastra y suelta un documento PDF largo.
• Selecciona el tamaño máximo de token y el nombre del modelo en el menú desplegable.
• Consulta al instante dos modelos en paralelo para comparar directamente los resultados.
• Consulta métricas detalladas de cada ejecución, incluyendo el tiempo de respuesta (latencia), los tokens por segundo y la longitud de salida, para comprender tanto el rendimiento como la eficiencia en escenarios prácticos.

Paso 1: Requisitos previos

Antes de ejecutar esta demostración, asegurémonos de que cumplís con todos los requisitos previos.

Paso 1.1: Importaciones 

En primer lugar, asegúrate de tener instaladas las siguientes importaciones:

pip install streamlit requests pypdf

Este comando instala todas las dependencias básicas necesarias para compilar la aplicación, a saber, Streamlit para la interfaz de usuario, requests para realizar llamadas a la API y pypdf para gestionar la extracción de documentos PDF.

Paso 1.2: Configuración de la clave API de OpenRouter 

El modelo Qwen3-Next también está disponible a través de la API oficial de Qwen (AlibabaCloud), HuggingFacey como versión cuantificada a través de Ollama. Para este tutorial, he utilizado OpenRouter, que te permite acceder a varios modelos con una sola clave API. A continuación, se explica cómo configurar tu clave API para el modelo Qwen3-next-80b-a3b-instruct:

• Crea una cuenta en https://openrouter.ai/
• Ve a la pestaña Modelos y busca los modelos «Qwen3-next-80b-a3b-instruct» y «Qwen3-30B-A3B». Puedes elegir entre las variantes Thinking e Instruct en función de tu aplicación. Para este tutorial, compararé las dos variantes del modelo Instruct.

• Desplázate hacia abajo y haz clic en « » (Crear clave API). Rellena el nombre de la clave y el límite de crédito (opcional) y haz clic en Crear. Guarda esta clave API para usarla en el futuro. 

• A continuación, ve a la pestañaCréditos y añade la información de tu tarjeta o cuenta bancaria. También puedes pagar a través de Amazon Pay o criptomonedas. Para esta demostración, añadí unos 8 dólares, que fueron suficientes.

Ahora, configura tu clave API como variable de entorno antes de ejecutar la aplicación:

export OPENROUTER_API_KEY=your_api_key

Paso 2: Configuración del modelo

Empezamos configurando los modelos que queremos comparar. Cada modelo se define con un identificador (utilizado para las llamadas a la API), el recuento total de parámetros y el recuento de parámetros activos.

import streamlit as st
import requests
import time
import PyPDF2
MODEL_CONFIG = {
    "Qwen3-Next-80B-A3B": {
        "id": "qwen/qwen3-next-80b-a3b-instruct",
        "params_billion": 80,
        "active_params_billion": 3
    },
    "Qwen3-30B-A3B": {
        "id": "qwen/qwen3-30b-a3b-instruct-2507",
        "params_billion": 30,
        "active_params_billion": 3
    },
    "Qwen3-30B-A3B": {
        "id": "qwen/qwen3-next-80b-a3b-thinking",
        "params_billion": 30,
        "active_params_billion": 3
    },
}

Empezamos importando las bibliotecas necesarias para crear la aplicación web Streamlit, incluidas bibliotecas como streamlit para la interfaz de usuario, requests para las llamadas a la API, time para la sincronización y PyPDF2 para la extracción de texto en PDF.

A continuación, definimos el diccionario MODEL_CONFIG, que incluye los modelos disponibles para comparar, incluyendo sus ID únicos (para llamadas API) y el número de parámetros, lo que facilita la ampliación de diferentes modelos Qwen3 en toda la aplicación.

Paso 3: Funciones auxiliares

A continuación, definimos varias funciones auxiliares para el backend. Entre ellas se incluyen funciones para estimar los requisitos de memoria, realizar llamadas API en tiempo real a OpenRouter y extraer texto de archivos PDF cargados.

def estimate_vram(params_billion, fp16=True, active_params_billion=None):
    if active_params_billion and active_params_billion != params_billion:
        total_params = params_billion * 1e9
        active_params = active_params_billion * 1e9
        size_bytes = 2 if fp16 else 4
        storage_vram = total_params * size_bytes / 1e9
        moe_overhead = active_params * 0.5 / 1e9  
        system_overhead = storage_vram * 0.2  
        total_vram = storage_vram + moe_overhead + system_overhead
    else:
        size_bytes = 2 if fp16 else 4
        num_params = params_billion * 1e9
        base_vram = num_params * size_bytes / 1e9
        total_vram = base_vram * 1.3 
    return round(total_vram, 1)
def query_openrouter(model_id, prompt, max_tokens=2048):
    api_key = "sk-or-v1-xxxxxxxxxxxxxxxxxxxxx" # Add your API Key here
    url = "https://openrouter.ai/api/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    data = {
        "model": model_id,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": max_tokens
    }
    try:
        start = time.time()
        response = requests.post(url, headers=headers, json=data, timeout=180)
        elapsed = time.time() - start
        response.raise_for_status()
        j = response.json()
        output = j["choices"][0]["message"]["content"].strip()
        usage = j.get("usage", {})
        prompt_tokens = usage.get("prompt_tokens", 0)
        completion_tokens = usage.get("completion_tokens", 0)
        tokens_per_sec = (completion_tokens or 0) / elapsed if elapsed > 0 else 0
        return {
            "output": output,
            "latency": elapsed,
            "output_tokens": completion_tokens,
            "tokens_per_sec": tokens_per_sec,
            "prompt_tokens": prompt_tokens
        }
    except Exception as e:
        return {"error": str(e)}
def extract_pdf_text(uploaded_pdf):
    text = ""
    try:
        reader = PyPDF2.PdfReader(uploaded_pdf)
        for page in reader.pages:
            text += page.extract_text() or ""
        return text[:120000]  
    except Exception as e:
        return f"[PDF extract error: {str(e)}]"

Veamos cómo encaja cada función en el proceso:

• estimate_vram() función: Esta función estima la VRAM de la GPU necesaria para ejecutar un modelo, teniendo en cuenta si se trata de un modelo denso o MoE (mezcla de expertos). Para los modelos MoE, se tienen en cuenta tanto los parámetros totales como los activos y se añade una sobrecarga por el enrutamiento y el uso del sistema.
• query_openrouter() función: Esta función se encarga de enviar indicaciones a un modelo LLM elegido alojado en OpenRouter y recuperar la respuesta. Mide la latencia total (tiempo de llamada API de extremo a extremo), extrae métricas útiles, como el número de tokens procesados, y calcula la tasa de generación de tokens por segundo. 

Ten en cuenta que la latencia aquí indicada incluye todos los retrasos de red, de cola y del servidor, no solo la velocidad pura de inferencia del modelo. Como tal, refleja la capacidad de respuesta real de extremo a extremo, que puede fluctuar en función de la carga de la API y las condiciones de Internet.

• extract_pdf_text() función: Esta función permite a los usuarios cargar y analizar archivos PDF como contexto de entrada para los modelos. Analiza el documento PDF utilizando PyPDF2 y extrae el texto sin formato, hasta un límite seguro para documentos muy largos. Si el análisis falla, la función devuelve un mensaje de error.

Estas funciones auxiliares garantizan un uso eficiente de la memoria, una inferencia fiable basada en API y una extracción de contexto fluida, lo que proporciona una experiencia de usuario perfecta.

Paso 4: Aplicación Streamlit

Con todos los componentes básicos listos, ya podemos crear nuestra aplicación Streamlit.

Paso 4.1: CSS personalizado

El primer paso para crear el flujo de trabajo orientado al usuario es el diseño visual y la maquetación. Aquí, configuramos la página Streamlit e inyectamos CSS personalizado para obtener un aspecto estructurado.

st.set_page_config(page_title="Qwen3-Next QA & Reasoning", layout="wide", page_icon=" ")
st.markdown("""
<style>
    .main-header {
        text-align: center;
        
        
    }
    .metric-card {
        background-
        
        border-radius: 0.5rem;
        border-left: 4px solid #1f77b4;
        
    }
    .output-box {
        background-
        border: 2px solid #e1e5e9;
        border-radius: 0.5rem;
        
        
        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
    }
    .model-header {
        background: linear-gradient(90deg, #1f77b4, #ff7f0e);
        color: white;
        
        border-radius: 0.5rem;
        
        text-align: center;
        font-weight: bold;
    }
</style>
""", unsafe_allow_html=True)
st.markdown('<h1 class="main-header"> QA and Reasoning With Qwen3-Next</h1>', unsafe_allow_html=True)
st.markdown("""
<div style="text-align: center; ">
    <p style="">
        Compare two Qwen3 models side-by-side with real-time performance metrics
    </p>
</div>
""", unsafe_allow_html=True)

Utilizamos tanto las opciones de configuración de Streamlit como los parámetros de estilo CSS personalizados. La llamada st.set_page_config establece el título de la página y un diseño amplio para la salida en paralelo. El CSS personalizado se inyecta a través de st.markdown para dar estilo a los principales elementos de la interfaz de usuario.

.main-header a el título y le da color, .metric-card y .output-box mejoran la visualización de las métricas y los resultados, y .model-header separa visualmente las respuestas del modelo con un degradado. El bloque final st.markdown muestra un título y una breve descripción de la aplicación.

Paso 4.2: Sección de entrada

Hemos diseñado la sección de entrada, ofreciendo a los usuarios dos opciones intuitivas: subir un PDF largo como contexto o escribir directamente una pregunta personalizada.

st.markdown("### Input")
with st.container():
    col_upload, col_text = st.columns([2, 3])
    with col_upload:
        uploaded_pdf = st.file_uploader(
            "Upload PDF for context", 
            type=["pdf"],
            help="Upload a PDF document to provide context for your question"
        )
    with col_text:
        user_question = st.text_area(
            "Ask a question:", 
            height=100, 
            max_chars=12000,
            placeholder="Enter your question here...",
            help="Ask any question or provide a topic to analyze"
        )

Esta sección de entrada muestra dos columnas una al lado de la otra: la primera columna proporciona un cargador de archivos PDF para que ustedes añadan documentos de contexto, mientras que la segunda columna ofrece un área de texto para introducir preguntas o temas. Esta interfaz permite a los usuarios cargar un PDF, escribir una pregunta o utilizar ambos juntos como entrada para la comparación de modelos posterior.

Paso 4.3: Selección del modelo

La sección de selección de modelos ofrece a los usuarios un control total sobre los modelos Qwen que desean comparar, así como sobre la duración de las respuestas del modelo. Una vez establecido el contexto del documento, los usuarios pueden seleccionar fácilmente dos modelos cualquiera de un menú desplegable, junto con la longitud máxima de respuesta deseada (en tokens), lo que facilita la experimentación con resultados tanto cortos como largos.

context = ""
if uploaded_pdf:
    with st.spinner(" Extracting PDF text..."):
        context = extract_pdf_text(uploaded_pdf)
    st.success(f" PDF loaded: {len(context)//1000}K characters extracted.")
st.markdown("### Model Selection")
model_names = list(MODEL_CONFIG.keys())
col1, col2, col3 = st.columns([2, 2, 1])
with col1:
    model1 = st.selectbox(
        "Model A", 
        model_names, 
        index=0,
        help="Select the first model to compare"
    )
with col2:
    model2 = st.selectbox(
        "Model B", 
        model_names, 
        index=1 if len(model_names) > 1 else 0,
        help="Select the second model to compare"
    )
with col3:
    max_tokens = st.selectbox(
        "Max Tokens",
        [512, 1024, 2048, 4096],
        index=2,  
        help="Maximum length of response (higher = longer responses). Use 2048+ for reasoning questions."
    )

El código anterior extrae primero el texto de un PDF cargado utilizando una función auxiliar. A continuación, muestra tres menús desplegables: dos para seleccionar los modelos Qwen (o cualquier modelo según la aplicación) que se van a comparar, y uno para especificar el límite máximo de tokens para las respuestas.

Nota: El límite de tokens controla la longitud máxima de salida. Para tareas de razonamiento complejas o de varios pasos, establecer un límite de tokens más alto garantiza que el modelo pueda generar una respuesta completa.

Paso 4.4: Presentación

Este paso implementa la lógica principal de comparación de modelos. Cuando el usuario hace clic en «Enviar y comparar modelos», la aplicación valida la información introducida, crea un mensaje contextual y lanza consultas paralelas a los modelos seleccionados.

st.markdown("---")
col_btn1, col_btn2, col_btn3 = st.columns([1, 2, 1])
with col_btn2:
    if st.button("Submit & Compare Models", type="primary", use_container_width=True):
        if not user_question and not uploaded_pdf:
            st.warning(" Please enter a question or upload a PDF.")
        else:
            if context:
                base_prompt = f"DOCUMENT:\n{context}\n\nQUESTION: {user_question or 'Summarize the above document.'}"
            else:
                base_prompt = user_question
            prompt = f"""Please provide a detailed and thorough response. Think step by step and explain your reasoning clearly.
{base_prompt}
Please provide a comprehensive answer with clear reasoning and examples where appropriate."""           
            st.markdown("### Results")
            col_left, col_right = st.columns(2)
            models_to_process = [(model1, col_left, "Model A"), (model2, col_right, "Model B")]          
            for model_key, col, model_label in models_to_process:
                with col:
                    st.markdown(f'<div class="model-header">{model_label}: {model_key}</div>', unsafe_allow_html=True)                   
                    progress_bar = st.progress(0)
                    status_text = st.empty()                    
                    try:
                        progress_bar.progress(25)
                        status_text.text("Initializing model...")
                        model_info = MODEL_CONFIG[model_key]
                        vram_estimate = estimate_vram(
                            model_info["params_billion"], 
                            active_params_billion=model_info["active_params_billion"]
                        )
                        progress_bar.progress(50)
                        status_text.text("Querying model...")
                        result = query_openrouter(model_info["id"], prompt, max_tokens=max_tokens)                        
                        progress_bar.progress(100)
                        status_text.text("Complete!")
                        if "error" in result:
                            st.error(f"Error: {result['error']}")
                        else:
                            st.markdown(f'''
                            <div class="metric-card">
                                <strong>Performance Metrics</strong><br>
                                <strong>Latency:</strong> {result['latency']:.2f}s<br>
                                <strong>Speed:</strong> {result['tokens_per_sec']:.2f} tokens/sec<br>
                                <strong>Output tokens:</strong> {result['output_tokens']}<br>
                                <strong>Prompt tokens:</strong> {result['prompt_tokens']}<br>
                                <strong>Est. VRAM:</strong> {vram_estimate} GB
                            </div>
                            ''', unsafe_allow_html=True)
                            st.markdown("** Response:**")
                            st.markdown(f'''
                            <div class="output-box">
                                {result["output"] if result["output"] else "<em>No output received</em>"}
                            </div>
                            ''', unsafe_allow_html=True)                
                    except Exception as e:
                        st.error(f" Unexpected error: {str(e)}")                    
                    finally:
                        progress_bar.empty()
                        status_text.empty()            
            st.markdown("---")            

El gestor de envíos organiza el flujo de trabajo de evaluación comparativa de la siguiente manera: 

• Cuando el usuario hace clic en «Enviar y comparar modelos», la aplicación comprueba si se ha proporcionado una pregunta o un PDF y avisa si no hay ninguno.
• A continuación, crea una indicación a partir del contexto del documento y la pregunta del usuario, añadiendo instrucciones para obtener respuestas detalladas y paso a paso.
• El área de resultados se divide en dos columnas para poder comparar directamente los resultados de los modelos uno al lado del otro.
• Para cada modelo, muestra una barra de progreso, estima el uso de VRAM, consulta la API de OpenRouter y actualiza los mensajes de estado a medida que el modelo procesa la solicitud.
• Una vez completada, la aplicación muestra la latencia, los tokens por segundo, el recuento de tokens y el uso de VRAM como métricas de rendimiento en tarjetas.

Prueba de Qwen3-Next

Para comprobar el rendimiento real del modelo Qwen3-Next, realicé varios experimentos.

Prueba 1: Preguntas y respuestas en contexto extenso

Para evaluar el rendimiento de Qwen3-Next en contextos largos, realicé varios experimentos prácticos utilizando el libro electrónico del Proyecto Gutenberg «War and Peace», una de las novelas más largas y complejas jamás escritas.

A continuación se muestran tres casos de prueba que demuestran cómo los modelos manejan contextos ultralargos, evitan alucinaciones y ofrecen resúmenes de alta calidad.

Seguimiento de personajes 

En primer lugar, pedí a ambos modelos que identificaran a todos los personajes principales que aparecen tanto en el primer capítulo como en el último de la novela, y que describieran brevemente cómo cambia su papel a lo largo de la historia.

: Enumera todos los personajes principales que aparecen tanto en el primer capítulo como en el último de la novela. Describe brevemente cómo cambian sus funciones con el tiempo.»

Esta pregunta requiere que el modelo procese el texto completo y realice un seguimiento preciso de los arcos de los caracteres. Aunque ambos modelos mostraron una gran capacidad de respuesta, la respuesta de Qwen3 Next fue más clara y se adaptó mejor a cada capítulo del libro.

Prueba de alucinación

A continuación, quería ver si los modelos podían distinguir el contenido real de la información errónea. Les di a ambos modelos una frase que no aparece en Guerra y paz, pero que es famosa por aparecer en otra novela de Tolstói.

Indicación: ¿Aparece en la novela la frase «Todas las familias felices se parecen entre sí, pero cada familia infeliz es infeliz a su manera»? Si es así, ¿en qué parte del texto aparece?

Esta frase en realidad proviene de Anna Karenina, no de Guerra y paz. Un modelo ideal debería responder «No», lo que demuestra una gran precisión factual y un bajo nivel de alucinación. Sorprendentemente, Qwen3-Next proporcionó la respuesta correcta, mientras que el modelo Qwen3 30B respondió con una frase incorrecta.

Resumen

Por último, probé las capacidades de resumen pidiendo a ambos modelos que resumieran la novela en 300 palabras.

Indicación: Resume la novela «Guerra y paz» en 300 palabras, centrándote en el viaje personal de Pierre Bezukhov.

Aunque la evaluación resumida es en parte subjetiva, considero que los resultados de Qwen3-Next son más estructurados, coherentes y reveladores. El resumen no solo era conciso, sino que también captaba con claridad la evolución del personaje de Pierre.

Ejemplo 2: Razonamiento y lógica en varios pasos

Para poner a prueba las capacidades de razonamiento avanzadas de ambos modelos, los desafié con rompecabezas lógicos complejos de varios pasos, tareas que requieren no solo memoria, sino también deducción paso a paso y eliminación cuidadosa.

Rompecabezas lógico sobre la distribución de los asientos

Primero les di a los modelos un acertijo sobre la disposición de los asientos:

Indicación: «En la recepción de la boda, hay cinco invitados, Colin, Emily, Kate, Fred e Irene, que no están seguros de dónde sentarse en la mesa. Le preguntan a la madre de la novia, quien responde: «Por lo que recuerdo, Colin no está al lado de Kate, Emily no está al lado de Fred ni de Kate». Ni Kate ni Emily están al lado de Irene. Y Fred debería sentarse a la izquierda de Irene. Al mirarlos desde el lado opuesto de la tabla, ¿puedes sentar correctamente a los invitados de izquierda a derecha?

Explica tu razonamiento paso a paso.

Este rompecabezas requería analizar varias restricciones y deducir el único orden posible para sentarse:

• Realidad sobre el terreno: Emily, Colin, Irene, Fred, Kate
• Salida de Qwen3-Next: Kate, Fred, Irene, Colin, Emily (casi correcto, pero al revés)
• Salida Qwen3-30B: No se ha encontrado una respuesta válida.

Aunque ninguno de los dos modelos obtuvo la secuencia correcta exacta, Qwen3-Next se acercó mucho, solo invirtió el orden, mientras que el modelo 30B no logró encontrar ninguna solución. Esto demuestra que Qwen3-Next es capaz de realizar deducciones en varios pasos, aunque algunos casos extremos sigan siendo difíciles.

Eliminación deductiva 

A continuación, probé los modelos con un rompecabezas de deducción inspirado en el clásico «rompecabezas de la cebra».

Indicación: «Cuatro personas (Lisa, Mike, Nora y Omar) compraron cada una una fruta diferente (manzana, plátano, cereza, dátil) y condujeron un coche diferente (Ford, Honda, Kia, Mazda).

• Lisa no compró el plátano.
• El conductor del Ford compró la cereza.
• Mike conducía un Honda.
• Nora compró la manzana y no conducía un Mazda.
• El conductor del Kia compró la cita.
• Omar no conducía un Ford.

¿Quién compró qué fruta y condujo qué coche? Muestra tu trabajo.

Este problema es intencionadamente irresoluble con las restricciones proporcionadas, pero esto es lo que los modelos devolvieron en su lugar:

• Salida de Qwen3-Next: Identificó correctamente que no existe ninguna asignación válida.
• e de salida Qwen3-30B: Se quedó atascado en un bucle lógico y no pudo concluir en el número de tokens de salida dado.

Este ejemplo demuestra la capacidad de Qwen3-Next para razonar deductivamente y reconocer cuándo no hay solución posible.

Conclusión

Este tutorial muestra cómo utilizar Qwen3-Next-80B-A3B para tareas de preguntas y respuestas y razonamiento, comparándolo con Qwen3-30B-A3B en una aplicación Streamlit paralela. Los resultados destacan las fortalezas de Qwen3-Next en el manejo de documentos ultralargos, la rapidez de inferencia y el mantenimiento de la calidad de salida, incluso en problemas de razonamiento complejos.