Qwen 3.6: El Modelo IA de Código Abierto 2026

Actualizado el 22/07/2026 — Este artículo fue actualizado con información reciente, secciones nuevas sobre descarga de archivos GGUF, instalación con SGLang y guía expandida de decisión para elegir entre Qwen, Claude y GPT.

Para probarlo sin instalar nada, acá está la guía para usar Qwen 3.6 gratis.

Qwen 3.6-35B es un modelo de lenguaje open source de Alibaba bajo licencia Apache 2.0 que usa arquitectura Sparse Mixture of Experts (MoE) para activar selectivamente solo 3 mil millones de parámetros de un total de 35 mil millones. Alcanza 49.5% en SWE-bench Pro (benchmarks reales de programación), es 1.7x más rápido que Claude Opus, cuesta 17 veces menos en API (USD 0.08 por 1M tokens versus USD 1.35 de Claude), soporta contexto de 1 millón de tokens y 201 idiomas incluyendo español nativo, y corre completamente localmente sin conexión a Internet en hardware estándar con 24GB VRAM mínimo usando quantización Q4.

En pocas palabras: Qwen 3.6-35B es el modelo open source de Alibaba que activa solo 3B de 35B parámetros por consulta. Alcanza 49.5% en SWE-bench Pro, es 1.7x más rápido que Claude Opus, cuesta 17 veces menos, soporta 1 millón de tokens de contexto, habla español nativo, y corre localmente en hardware estándar con 24GB VRAM.

¿Qué es Qwen 3.6-35B? El modelo open source de Alibaba

Qwen 3.6-35B es un modelo de lenguaje grande (LLM) lanzado por Alibaba en abril de 2026 bajo licencia Apache 2.0, lo que significa que podés descargarlo, modificarlo, entrenarlo, y usarlo sin restricciones comerciales. El punto clave: es un modelo open source profesional que compite directamente con propuestas propietarias de Anthropic y OpenAI en tareas de programación, sin costos de API recurrentes y sin dependencias de infraestructura externa.

El nombre “3.6-35B” es confuso a primera vista. No son 3.6 mil millones de parámetros, sino 35 mil millones totales. El “3.6” hace referencia a los parámetros activos por cada token que genera el modelo. La magia está en que solo 3 mil millones de esos 35 mil millones están “despiertos” simultáneamente. Es como tener la potencia de un modelo enorme pero pagando el costo computacional de un modelo mucho más pequeño. Eso se logra con una arquitectura llamada Sparse Mixture of Experts (MoE), que es la innovación fundamental de Qwen 3.6.

Según el repositorio oficial en Hugging Face (modelo Qwen/Qwen3.6-35B-A3B), Qwen 3.6 soporta 201 idiomas, incluyendo español nativo — es decir, no es una traducción pobre de un modelo entrenado en inglés, sino soporte integrado desde el entrenamiento. El contexto base es 262K tokens, pero con técnicas de attention patterns específicas se expande a 1 millón de tokens, lo que lo hace ideal para agentes automatizados que procesan documentos extensos sin perder coherencia ni contexto.

Arquitectura Sparse MoE: cómo funciona Qwen 3.6

Esta es la sección donde muchos confunden “modelo más pequeño” con “modelo más lento”. Qwen 3.6 no es más pequeño que Claude, es inteligente en cuáles parámetros activa para cada consulta. Esto es lo que lo diferencia y por qué es relevante entenderlo.

Un modelo denso tradicional (como Claude Opus o GPT-5.4) usa todos los parámetros para cada token generado. Piensa en todas las puertas de una ciudad prendidas simultáneamente, a plena capacidad. Mixture of Experts funciona diferente: el modelo tiene múltiples “expertos” especializados (capas neurales que se entrenan para tareas distintas), y una red neuronal llamada “gate network” decide cuál experto usar para cada token procesado. Si tu pregunta es sobre debugging en Python, se activa el experto de Python. Si es sobre DevOps o infraestructura, se activa otro. El resto queda dormido, sin consumir ni GPU, ni memoria, ni ciclos de cómputo. Para más detalles, consultá nuestra compilador JIT de Python 3.15.

En Qwen 3.6 específicamente, la puerta (router) elige token por token cuál experto o dos expertos de los disponibles van a usarse, y solo esos parámetros se multiplican, se suman, se procesan. El resto literalmente no consume ciclos de GPU, memoria RAM de GPU, ni tiempo de cómputo. Eso es lo del “3B activos de 35B totales”.

¿Diferencia práctica? Velocidad de inferencia y eficiencia de recursos en el mundo real. Generar 100 tokens con Qwen 3.6 en una RTX 4090 toma 3-4 segundos, versus 5-6 segundos con Claude Opus por API (incluida latencia de red). Si escalás a mil consultas por día en un sistema de agentes, eso multiplica en latencia real, reducción de timeout, y cost savings en infraestructura GPU.

Comparativa detallada: Qwen 3.6 vs Claude Opus vs GPT-5.4

Los números que siguen son verificables en repositorios oficiales de Alibaba y en benchmarks públicos de abril 2026. Los datos de costo son aproximados y pueden variar según región y plan de suscripción, pero ilustran el orden de magnitud real.

El dato clave: Qwen 3.6 supera a ambos en las tareas donde importa código real. En SWE-bench Pro — que mide problemas reales de repositorios open source — Qwen saca 49.5% versus 42.8% de Claude. Eso es 16% mejor en problemas del mundo real. En HumanEval la diferencia es menor (todos andan arriba de 92%), pero en problemas reales de repositorios el delta es sustancia pura.

Velocidad: Qwen es 1.7x más rápido que Claude en promedio (28-35 tokens/segundo versus 16-20), y 2x más rápido que GPT-5.4. Si trabajás con agentes que hacen múltiples llamadas por minuto, o si necesitás respuesta en tiempo real para usuarios finales, esa diferencia no es un detalle técnico, es una diferencia de experiencia.

Requisitos de hardware: qué necesitás para ejecutar Qwen 3.6 localmente

Si querés correr Qwen 3.6 en tu máquina sin pasar por API ni depender de terceros, necesitás saber qué hardware es realista. La respuesta honesta: depende de cuánta velocidad esperés y si tienes GPU o no.

GPUs recomendadas

• NVIDIA RTX 4090 (24GB VRAM): La mejor opción. Genera 28-35 tokens/segundo con Q4. Costo ~USD 1.600-2.000.
• NVIDIA RTX 4080 (24GB VRAM): 22-28 tokens/segundo. Alternativa más económica, ~USD 1.200.
• NVIDIA H100 (80GB VRAM): Para datacenters. Genera 60+ tokens/segundo. Overkill para desarrollo local.
• NVIDIA A6000 (48GB VRAM): Estación de trabajo profesional. Genera ~30 tokens/segundo. Menos común, ~USD 4.000.
• Compute capability 8.0 mínimo: Significa RTX 30 series en adelante (RTX 3090, RTX 3080, RTX 4090, etc.). GPUs más viejas que compute capability 7.5 no funcionan bien.
• AMD RDNA2+ (RX 6700 XT en adelante): Funcionan con soporte vía HIP. Documentación menos completa que NVIDIA, pero viable.
• Intel Arc A770+ (8GB o 16GB): Soporte experimental. Funciona pero es lento (~10-12 tokens/segundo). No recomendado para producción.

Quantización: Q4 vs Q3 vs FP16

• Q4 (recomendado): Reduce modelo de ~70GB a ~14-16GB VRAM. Es el sweet spot: velocidad aceptable, sin pérdida notable en benchmarks. La mayoría de casos usan Q4.
• Q3 (si tienes poco VRAM): Modelo cae a ~10-11GB. Velocidad similar a Q4, pequeña pérdida de precisión (~2-3%). Useful si tenés tarjeta de 16GB límite.
• FP16 (máxima precisión): Sin quantización. Necesitás 32-35GB VRAM. Velocidad ~5-10% más lenta que Q4, pero precisión máxima. Solo si tienes presupuesto de VRAM.
• CPU-only (sin GPU): No recomendado. Qwen 3.6 sin GPU tarda 30+ minutos por respuesta. Impracticable para cualquier uso en tiempo real.

RAM del sistema y almacenamiento

• RAM mínimo: 16GB. Si Ollama spilla a memoria del sistema (cuando VRAM llena), el sistema se ralentiza pero funciona.
• RAM recomendado: 32GB. Evita que la memoria del sistema sea cuello de botella. Ollama puede cachear datos, el kernel puede expandir buffers, etc.
• Storage: 50GB libres. El modelo GGUF Q4 ocupa ~14-16GB, pero necesitás espacio para cache, checkpoints intermedios, logs de ejecución, modelos alternativos si experimentás.
• SSD recomendado: Si cargas el modelo desde un HDD, la primera carga tarda más (15-20 min). SSD la acelera a 3-5 minutos.

Cómo descargar Qwen 3.6: archivos GGUF y dónde encontrarlos

Antes de instalar Qwen 3.6 con Ollama o llama.cpp, necesitás saber dónde encontrar el archivo del modelo. Hay varias opciones, y cada una tiene trade-offs de velocidad de descarga y formato.

Los archivos GGUF (Quantized GUFF format) son la versión comprimida y optimizada del modelo que corre localmente. GGUF es un formato abierto que mantiene los parámetros del modelo en precisión reducida (Q4, Q3) sin perder capacidad de razonamiento de forma notable. Ollama automáticamente descarga y cachea GGUF, pero si querés hacerlo manual, necesitás saber dónde buscar.

Opción 1: Descargar desde Hugging Face (recomendado)

El repositorio oficial de Alibaba en Hugging Face es: Qwen/Qwen3.6-35B-A3B

• Buscá el archivo GGUF Q4: Generalmente nombrado algo como qwen3.6-35b-q4_k_m.gguf o qwen3.6-35b.Q4_K_M.gguf (diferentes comunidades lo llaman distinto). Tamaño: ~14-16GB.
• Descargá con navegador: Entrá a huggingface.co/Qwen/Qwen3.6-35B-A3B, buscá el archivo GGUF y clickeá el botón descargar. Toma 30-60 minutos en conexión de 10 Mbps.
• O usá la CLI de Hugging Face: huggingface-cli download Qwen/Qwen3.6-35B-A3B --local-dir ./qwen-models --local-dir-use-symlinks False (descarga solo los archivos GGUF que especifiques).
• Verificá el hash SHA256: Hugging Face muestra el hash de cada archivo. Después de descargar, corrê sha256sum archivo.gguf (Linux/macOS) o certUtil -hashfile archivo.gguf SHA256 (Windows) para verificar que no se corrompió.

Opción 2: Ollama descarga automáticamente (más simple)

• Ollama cachea automáticamente: Cuando corrés ollama pull qwen:3.6-35b, Ollama descarga el GGUF oficial desde sus servidores, lo cachea en ~/.ollama/models/, y lo reutiliza. Después de la primer descarga, cargar el modelo es instantáneo.
• Ventaja: Cero configuración manual. Ollama elige la quantización correcta (Q4 por defecto).
• Desventaja: No ves exactamente qué versión descargaste, y si quierés cambiar a Q3 o FP16, necesitás especificarlo al correr (ollama run qwen:3.6-35b-q3 si existe).

Opción 3: Descargar desde repositorios comunitarios (GGML, TheBloke)

• TheBloke en Hugging Face: Comunidad que hace GGUF de muchos modelos. Buscá TheBloke/Qwen3.6-35B-A3B-GGUF (nota: depende de disponibilidad). Múltiples versiones (Q3, Q4, Q5, etc.) subidas.
• GGML Project: Repositorio experimental. Menos estable que Ollama, pero a veces tiene optimizaciones nuevas.
• Nota: Usá solo las fuentes oficiales o TheBloke (reputado). Evitá descargar GGUF de fuentes desconocidas (pueden tener malware o versiones corrupted).

Una vez que tenés el archivo GGUF descargado (ya sea manual o vía Ollama), estás listo para cargar el modelo con Ollama, llama.cpp, o SGLang. El archivo es lo único que necesitás; los frameworks cuidan el resto de la configuración.

¿Cómo instalar Qwen 3.6 con Ollama? Guía paso a paso

Ollama es la opción más simple para correr Qwen 3.6 localmente. Maneja VRAM, quantización, caching automáticamente. Es la solución ideal si no querés configurar prácticamente nada.

Paso 1: Descargar e instalar Ollama

• Andá a ollama.ai (el sitio oficial de Ollama).
• Descargá Ollama para tu SO: Windows (.exe), macOS (.dmg), Linux (.tar.gz o distribución específica).
• Ejecutá el instalador. En Windows, se instala como servicio de sistema (corre en background automáticamente). Reinicia después de instalar.
• Verificá que está corriendo: Abrí terminal (CMD, PowerShell en Windows; Terminal en macOS/Linux) y corré ollama --version. Deberías ver un número de versión (ej. 0.2.4).

Paso 2: Descargar el modelo Qwen 3.6

Abrí terminal y corré:

ollama pull qwen:3.6-35b

Ollama descarga el modelo GGUF Q4 (~14-16GB). Toma entre 10 y 30 minutos según tu conexión (si tenés 10 Mbps tarda ~3-4 horas; si tenés 100 Mbps tarda ~30 minutos). Ollama cachea el archivo, así que la próxima corrida es instantánea, y podés pausar/reanudar si la conexión se cae.

Paso 3: Ejecutar el modelo en terminal interactiva

ollama run qwen:3.6-35b

El modelo carga en VRAM (toma 5-10 segundos la primera vez; en cargas posteriores es instantáneo), y te da un prompt para chatear. Escribís tu pregunta y presionas Enter. Ejemplo:

>> Escribí una función en Python que valide un email usando regex

Qwen devuelve la respuesta en 3-5 segundos (vs 6-8 segundos con Claude por API, dependiendo de latencia de red). Escribís más preguntas y siguen la conversación con contexto.

Paso 4: Acceder por API HTTP (para aplicaciones)

Ollama expone una API REST en localhost:11434. Si querés integrar Qwen en tu aplicación sin interfaz web, usá la API directamente:

curl http://localhost:11434/api/generate -d '{"model": "qwen:3.6-35b", "prompt": "Tu pregunta aquí", "stream": false}'

Esto devuelve JSON con la respuesta completa. Con "stream": true, devuelve respuesta token por token (útil para UI con tiempo real).

Optimizaciones de Ollama

• Reducir contexto si no lo necesitás: ollama run qwen:3.6-35b --num-ctx 32768 (en vez de 262K default). Ahorra 30-40% VRAM, aumenta velocidad. Useful si procesas textos cortos.
• Batch size para múltiples consultas: Default es 1 (latencia mínima). Si procesás 10 consultas en paralelo, aumentá a 4-8: ollama run qwen:3.6-35b --batch-size 8. Acelera throughput, aumenta latencia un poco.
• GPU offloading manual: Ollama auto-detecta GPU. Si no funciona, forzá: ollama run qwen:3.6-35b --gpu-layers 99 (carga todas las capas en GPU).
• Cambiar quantización: Si descargaste Q4 pero querés Q3 (menos VRAM), corrê ollama pull qwen:3.6-35b:q3 (si existe). Luego ollama run qwen:3.6-35b:q3.

Instalar Qwen 3.6 con llama.cpp (control avanzado)

llama.cpp es la opción para usuarios avanzados que quieren máximo control sobre inferencia, quantización, y tuning. Es más rápido que Ollama (menos overhead de runtime) y consume menos memoria, pero requiere más configuración manual.

Paso 1: Descargar llama.cpp

• Andá a github.com/ggerganov/llama.cpp (repositorio oficial).
• Opción A (simple): Descargá el binario precompilado para tu SO desde Releases (Windows, macOS, Linux). Descomprimí en C:\llama.cpp o /opt/llama.cpp.
• Opción B (avanzado): Compilá desde source si querés features nuevas o optimizaciones. Requiere CMake y CUDA toolkit (si querés soporte GPU NVIDIA). Linux/macOS es más simple que Windows.

Paso 2: Descargar el archivo GGUF

El archivo GGUF de Qwen 3.6 está disponible en Hugging Face. Usá la opción que prefieras:

• Descarga manual por navegador: Entrá a huggingface.co/Qwen/Qwen3.6-35B-A3B, buscá el archivo .gguf (Q4), descargá (~14-16GB).
• O con CLI: huggingface-cli download Qwen/Qwen3.6-35B-A3B --include "*.gguf" --local-dir ./qwen-models
• Ubicación:** Guardá el archivo en una carpeta conocida, ej. ./qwen3.6.gguf en el directorio de trabajo.

Paso 3: Ejecutar con llama.cpp

./main -m qwen3.6.gguf -ngl 99 -n 512 -p "Tu pregunta aquí"

Desglose de los flags más importantes:

• -m qwen3.6.gguf: Ruta al archivo del modelo.
• -ngl 99: Carga 99 capas en GPU (básicamente todas, si tienes VRAM). Sin GPU, omití este flag; el modelo corre en CPU puro.
• -n 512: Máximo 512 tokens en la respuesta. Aumentá a 1024 si querés respuestas más largas.
• -p “prompt”: Tu pregunta o instrucción. Luego de ejecutar, llama.cpp devuelve la respuesta en terminal.
• -t 12: Usa 12 threads de CPU para computación en paralelo. Ajustá según tu core count.
• -c 262144: Contexto de 262K tokens (default de Qwen). Bajá a 32768 si necesitás menos VRAM.

Ejemplo completo:

./main -m qwen3.6.gguf -ngl 99 -n 512 -t 12 -c 32768 -p "Escribí una función en Rust que parsee JSON desde un archivo"

Generalmente llama.cpp es más rápido que Ollama (menos intermediarios, menos abstracciones), pero menos ergonómico si necesitás interfaz web o API HTTP. Si querés API HTTP con llama.cpp, usá el flag --server (versiones recientes) o correlo detrás de un proxy como llamafile.

Instalar Qwen 3.6 con SGLang (máxima velocidad para aplicaciones)

SGLang (Structured Generation Language) es un framework optimizado para inferencia rápida y structured output (JSON schema, función calling, etc.). Si construís agentes o aplicaciones que necesiten respuestas estructuradas y máxima throughput, SGLang es la mejor opción.

Paso 1: Instalar SGLang y dependencias

pip install sglang[all]

Esto instala SGLang con soporte GPU (CUDA automático si tenés NVIDIA). Toma 5-10 minutos. Si tenés problema con CUDA, instalá por separado: pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 (para CUDA 11.8).

Paso 2: Lanzar servidor SGLang

python -m sglang.launch_server --model-path Qwen/Qwen3.6-35B-A3B --port 30000

Esto descarga el modelo (si no lo tenés) y lanza un servidor OpenAI-compatible en puerto 30000. El servidor carga el modelo en VRAM (~14-16GB con Q4) y está listo para recibir requests.

Paso 3: Usar desde tu aplicación (OpenAI SDK)

SGLang es compatible con OpenAI SDK, así que cambias el endpoint y listo:

from openai import OpenAI
client = OpenAI(base_url="http://localhost:30000/v1", api_key="anything")
response = client.chat.completions.create(
model="Qwen/Qwen3.6-35B-A3B",
messages=[{"role": "user", "content": "Escribí una función en Python"}]
)
print(response.choices[0].message.content)

Ventaja clave de SGLang: soporta structured output nativo (devolvé JSON schema, llamadas a funciones, etc., garantizado válido). Ejemplo:

import sglang as sgl

@sgl.function
def extract_json(s, text):
s += sgl.system("Extract JSON from text")
s += sgl.user(text)
s += sgl.assistant(sgl.gen("output", regex=r'\{.*\}'))
return s

state = extract_json.run(text="El usuario es John, edad 30, email [email protected]", backend="local")
print(state["output"]) # JSON válido garantizado

SGLang generalmente genera 2-3x más tokens/segundo que Ollama en casos con structured output heavy. Si tu aplicación requiere muchas llamadas con validación de schema, SGLang es mejor.

Contexto de 1 millón de tokens: qué significa y cuándo usarlo

Que Qwen 3.6 soporte 1 millón de tokens de contexto no es marketing. Significa que podés metés un documento de 300-400 páginas, un repositorio entero (hasta 500K líneas de código), o los últimos 6 meses de logs de tu servidor en una sola consulta, y el modelo mantiene coherencia del principio al final.

Comparación: Claude Opus soporta 200K tokens (40 páginas), GPT-5.4 soporta 128K tokens (25 páginas). Qwen es 5x más contexto. Para análisis de sistemas grandes, refactorización masiva, o debugging de incidentes complejos, eso es una ventaja real, no teórica.

Caso práctico: Análisis de repositorio de 100K líneas

Tenés un repositorio grande, necesitás refactorizar un componente crítico, pero el cambio impacta 10 módulos diferentes. Con Claude (200K), partís el repo en 5 chunks y haces análisis separados (riesgo de inconsistencia). Con Qwen (1M), metés el repo entero sin partirlo, y el modelo entiende dependencias de forma holística. Resultado: mejor refactorización, menos bugs.

Soporte de 201 idiomas incluido español nativo

Qwen fue entrenado en 201 idiomas incluyendo español desde el inicio, no como una traducción posterior. Eso significa:

• Voseo argentino: Entiende “vos podés”, “che boludo”, “la pucha”. Modelos entrenados en inglés no captan.
• Subjuntivo complejo: “aunque fuese”, “si no fuera porque”, verbos compuestos con se.
• Documentación técnica en español: Entiende argot técnico en español (que no es traducción literal del inglés).
• Consultas mixtas: Puedes hacer preguntas en español sobre código en inglés, o viceversa. El modelo maneja ambos idiomas en la misma consulta sin confundirse.

Modo thinking nativo y function calling

• Thinking mode: El modelo genera “pensamientos internos” (razonamiento paso a paso) antes de devolver la respuesta. Útil cuando el problema requiere análisis profundo. Opcional; podes desactivarlo si necesitas respuesta rápida.
• Function calling nativo: El modelo puede generar llamadas a funciones y APIs automáticamente. Compatible con OpenAI y Anthropic, así que integrás fácil con LangChain, LlamaIndex, llamadas directas vía JSON.

Rendimiento real en programación: casos prácticos

¿Por qué Qwen 3.6 supera a Claude en SWE-bench Pro? Porque fue entrenado agresivamente en repositorios open source reales, patterns de debugging, error handling, y revisión de código. No es un modelo de propósito general tocado ligeramente para código.

Caso 1: Refactorización de codebase grande

Tenés 10K+ líneas de código legado, necesitás refactorizar un módulo completo manteniendo backward compatibility. Le pasás el código a Qwen 3.6 con contexto de 1M tokens, pedís sugerencias ordenadas por riesgo y beneficio, y el modelo devuelve refactorización con razonamiento inline explicando cada cambio. Qwen tarda 4 segundos. Claude por API tardaría 6-7 segundos. En un día de refactorización (50-100 consultas), eso suma 150+ segundos ahorrados. Pero además, Qwen corre localmente: cero latencia de red, cero dependencia de API externa, 100% privacidad de código.

Caso 2: Agentes y automatización con function calling

Agentes que necesitan llamar funciones, escribir queries SQL, generar snippets bash, revisar PR automáticamente. Qwen 3.6 tiene thinking mode nativo que encadena razonamientos antes de generar llamadas. El modelo entiende la estructura del problema antes de devolver código, lo que reduce hallucinations (alucinaciones) de 8% a 1%.

Caso 3: Debugging de logs densos e incidentes

Tenés logs gigantes, traza de errores de 50-100KB, un repositorio completo. Pasas todo a Qwen en una sola consulta (contexto de 1M tokens). El modelo procesa el contexto entero, no pierde detalles, y devuelve soluciones accionables con mapa de root cause. En Qwen 3.6 eso corre en local: cero envío de datos a terceros, cero costos de API, cero timeout por tamaño de documento.

Problemas comunes y soluciones

Problema: VRAM insuficiente incluso con quantización Q4

Tenés 16GB VRAM pero Qwen 3.6 Q4 sigue no entrando, o se ralentiza mucho.

• Solución 1 — Reducir contexto: ollama run qwen:3.6-35b --num-ctx 16384 (en vez de 262K default). Ahorra 30-40% VRAM. Suficiente para documentos cortos, emails, snippets.
• Solución 2 — Quantización Q3: ollama pull qwen:3.6-35b:q3. Modelo cae a ~10-11GB. Velocidad similar, pequeña pérdida de precisión (2-3%).
• Solución 3 — Modelo más chico: Alibaba lanzó Qwen 3.6-9B (~3-4GB Q4). Benchmarks más bajos, pero funciona en hardware limitado. Speedup 3x versus 3.6-35B.
• Solución 4 — CPU partial offload: Si tenés 32GB RAM, Ollama puede usar sistema memory (lento, pero viable). Esperas 2-3x más latencia.
• Solución 5 — Usar API: Si local no va, Ollama vía HTTP o Bailian API de Alibaba. Costo bajo (~0.08/1M tokens).

Problema: Desbordamiento silencioso de contexto

Pasas un documento enorme, el modelo procesa, pero empieza a “olvidar” información del principio porque el contexto se saturó a 1M tokens. No tira error, simplemente responde basado en lo que cabió.

• Solución: Monitorea input_tokens en la respuesta. Si se acerca a 1M, cortá el documento o divídilo en chunks de ~800K. En Ollama/llama.cpp, podés ver tokens usados en el log.

Problema: Problemas de compatibilidad GGUF entre versiones

Bajás un GGUF de Qwen 3.6, lo loadeas con versión vieja de llama.cpp, el tokenizer no matchea, o el formato GGUF cambió. Modelo no corre o genera basura.

• Solución: Asegurate que llama.cpp está actualizado (latest commit de GitHub, o release reciente). Descargá el GGUF del repositorio oficial (Qwen de Alibaba o Hugging Face oficial), validá el hash SHA256. En Ollama no es problema: auto-actualiza el runtime y GGUF en paralelo.

Problema: Fallos en structured output

Pedís al modelo que genere JSON válido o llame una función, pero la salida no es JSON válido, o le falta información.

• Solución: Validá la respuesta con JSON schema antes de ejecutar. En SGLang, usá sgl.gen("output", regex=r'\{.*\}') para forzar valid JSON. En otros frameworks, validá post-generación y reintentar si falla. Estudios muestran que structured output reduce failures de 8% a 1%.

¿Cuándo usar Qwen 3.6 vs Claude vs GPT? Guía de decisión

Cada modelo tiene ventajas claras. Acá va la guía práctica para elegir sin arrepentimientos.

Usá Qwen 3.6 si…

• Trabajás con código todos los días: SWE-bench Pro 49.5% es superior a Claude en problemas reales de repositorios. Debugging, refactorización, revisión de PR.
• Necesitás velocidad y latencia baja: 1.7x más rápido que Claude, 2x más que GPT. Agentes que hacen múltiples llamadas por minuto se benefician.
• No tenés presupuesto de API recurrente: Apache 2.0, gratis corriendo localmente. USD 0.08 por 1M tokens en API (17x menor que Claude a USD 1.35).
• Tienes compliance o privacidad: Datos nunca salen del servidor. GDPR, HIPAA, datos sensibles. Terceros no ven nada.
• Necesitás contexto largo: 1M tokens vs 200K de Claude. Repositorios enteros, logs largos, documentación masiva en una sola consulta.
• Equipos con hardware moderno: RTX 4090, H100, A6000. Rentabilidad por inversión en hardware amortiza rápido.
• Agentes y automatización local: Function calling nativo, thinking mode, structured output. Ideales para bots sin API externa.

Usá Claude Opus si…

• Necesitás mejor reasoning general: Claude es mejor en edge cases, razonamiento complejo no-código, escritura creativa, análisis matizado.
• Querés visión (procesamiento de imágenes): Claude tiene multimodalidad nativa. Qwen no soporta imágenes.
• No querés mantener infraestructura: API gestionada, cero ops, escalabilidad infinita. Pagas por token usado, listo.
• No tenés restricciones de privacidad: Los datos pasan por Anthropic, pero confías en su política de no-retención/no-entrenar.
• Necesitás soporte 24/7: Anthropic tiene SLA garantizado, equipo de soporte. Open source no tiene eso.

Usá GPT-5.4 si…

• Necesitás el “mejor del mejor”: GPT generalmente es la opción premium en benchmarks generales. Pero en código, Qwen lo supera.
• Ecosistema OpenAI: Integraste mucho con OpenAI (plugins, fine-tuning, función calling específica), no querés migrar.
• Necesitás estabilidad y SLA: OpenAI tiene infraestructura probada, menos downtime, uptime 99.9%+.
• Casos de visión complejos: GPT tiene visión, pero Claude es mejor. Si realmente necesitás visión, evaluá Claude primero.

Estrategia híbrida (la mejor): La solución óptima no es “uno u otro” sino usar los tres según el trabajo. Usa Qwen 3.6 para código local (velocidad + costo + privacidad), Claude por API para reasoning complejo (escritura, análisis profundo), GPT-5.4 para casos premium donde realmente lo necesites. En un equipo típico: Qwen 80% del tiempo, Claude 15%, GPT 5%.

Preguntas Frecuentes

¿Qwen 3.6-35B tiene visión para procesar imágenes?

No. Qwen 3.6-35B es texto puro. Si necesitás procesamiento de imágenes, usá Claude Opus (tiene visión), o usa Qwen VL (modelo separado de Alibaba, multimodal). Para la mayoría de casos de código, texto puro basta.

¿Qwen 3.6 puede entrenar o fine-tunar en datos propios?

Técnicamente sí, pero no recomendado para usuarios finales. La arquitectura MoE requiere reentrenamiento especial que no es trivial. Lo que sí podés hacer: context injection (meter tus datos en el prompt) o LoRA (low-rank adaptation) para adaptación ligera sin reentrenamiento. Para la mayoría de casos, context injection basta.

¿Qwen 3.6 funciona sin GPU, solo con CPU?

Sí, pero muy lentamente. Sin GPU, esperás 30-60 segundos por respuesta. No es viable para producción. Si no tienes GPU dedicada, la única opción viable es usar API en la nube (Ollama por HTTP, o Bailian de Alibaba).

¿Puedo usar Qwen 3.6 en Google Colab o Kaggle?

Sí, pero con limitaciones. Colab Free tier tiene T4 GPU (16GB VRAM), insuficiente para Qwen 3.6 sin problemas. Colab Pro+ con A100 (80GB) funciona excelente. Kaggle tiene GPU limitado. La mejor opción free: usar Ollama por HTTP en tu máquina local.

¿Cómo integro Qwen 3.6 con LangChain o LlamaIndex?

LangChain y LlamaIndex soportan Ollama nativamente. En LangChain, inicializás con ChatOllama(model="qwen:3.6-35b") (requiere python-ollama). En LlamaIndex, usás from llama_index.llms.ollama import Ollama; llm = Ollama(model_name="qwen:3.6-35b"). Compatible con todas las abstracciones (chains, agents, RAG, etc).

¿Qwen 3.6 tiene soporte de español nativo o es traducción?

Nativo. Qwen fue entrenado en 201 idiomas incluyendo español desde el inicio. No usa traducción de otro idioma. Las respuestas en español respetan gramática, conjugación, voseo (si lo instruccionás). Es mejor que modelos entrenados en inglés y después “adaptados” a español.

¿Cómo monitoreo VRAM mientras Qwen corre?

En Windows: Task Manager (Ctrl+Shift+Esc) → Performance → GPU. Verás VRAM consumida. En Linux: nvidia-smi (NVIDIA) o radeontop (AMD). Ollama muestra consumo en el log también.

¿Cuál es la diferencia entre quantización Q4 y Q3?

Q4 ocupa ~14-16GB VRAM, Q3 ocupa ~10-11GB. Ambos tienen velocidad similar (25-35 tokens/segundo), pero Q3 tiene pequeña pérdida de precisión (~2-3% en benchmarks). Usá Q4 si tienes VRAM; Q3 si necesitás ahorrar VRAM y aceptas pequeña degradación.

¿Qwen 3.6 respeta privacidad si corre localmente?

Sí, 100%. Si el modelo corre en tu máquina (Ollama local, llama.cpp local), los datos nunca salen de tu hardware. Nadie ve nada. Esto es crítico para datos sensibles, compliance, secretos de negocio.

Conclusión

Qwen 3.6-35B no es hype corporativo. Es una herramienta real con casos de uso claros y verificables. Si trabajás con código todos los días, necesitás velocidad, y querés evitar vendor lock-in de API cloud, es candidata sólida. La arquitectura MoE es solución elegante: toda la potencia de un modelo masivo, pagando el costo computacional de un modelo pequeño.

El benchmark es el que habla: 49.5% en SWE-bench Pro versus 42.8% de Claude en problemas reales de código. 1.7x más velocidad. 17 veces más barato en API. Contexto de 1 millón de tokens. Apache 2.0 (código abierto). Ahora hay alternativa open source seria que compite con las propuestas propietarias. Y corre localmente, sin internet, sin costos recurrentes, sin enviar datos a terceros.

La recomendación: probá Qwen 3.6 localmente con Ollama (5 minutos de setup). Si usas código diariamente, notarás la diferencia en velocidad y precisión. Si no necesitás visión ni reasoning extremo, Qwen cierra el triángulo: speed, cost, privacy.