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

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

En pocas palabras: Qwen 3.6-35B es el modelo open source de Alibaba (licencia Apache 2.0) con arquitectura Sparse MoE 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, y corre localmente en hardware estándar con 24GB VRAM.

Alibaba lanzó en abril de 2026 Qwen 3.6-35B, un modelo open source con arquitectura Sparse Mixture of Experts que activa selectivamente solo 3 mil millones de parámetros de 35 mil millones totales. Bajo licencia Apache 2.0, logró 49.5% en SWE-bench Pro (benchmarks reales de programación), es 1.7x más rápido que Claude Opus, 2x más rápido que GPT-5.4 y cuesta 17 veces menos en API. Lo clave: corre localmente sin conexión a Internet y sin costos de API.

Qwen 3.6-35B es un modelo de lenguaje de código abierto desarrollado por Alibaba que usa arquitectura Sparse Mixture of Experts (MoE) para activar selectivamente 3 mil millones de parámetros de un total de 35 mil millones, logrando mayor velocidad y eficiencia en tareas de programación manteniendo calidad competitiva con soluciones propietarias como Claude Opus y GPT. Se distribuye bajo licencia Apache 2.0, corre localmente en máquinas con 24GB VRAM mínimo usando quantización Q4, y soporta 201 idiomas incluido español nativo.

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

Ponele que necesitás un modelo que corra localmente, que hable bien español, y que entienda de código sin romper el banco en infraestructura. Ahí entra Qwen 3.6-35B. Alibaba lo anunció en abril de 2026 con permiso Apache 2.0, así que podés descargarlo, corrarlo donde quieras, entrenarlo, lo que se te ocurra. No hay restricciones raras.

El nombre es confuso de entrada. No son 3.6 mil millones de parámetros, son 35 mil millones totales. El “3.6” hace referencia a los parámetros activos por consulta. La magia está en que solo 3 mil millones están encendidos por tokens generados. Es como tener la potencia de un modelo enorme pero pagando el costo computacional de un modelo pequeño. Eso se logra con arquitectura MoE (Mixture of Experts).

Según el repositorio oficial en Hugging Face, el modelo soporta 201 idiomas, incluido español nativo (no traducido de forma pobre). El contexto base es 262K tokens, expandible a 1 millón mediante attention patterns específicos. Para agentes automatizados que procesan documentos extensos sin perder coherencia, eso es tremendo.

Arquitectura Sparse MoE: cómo funciona en Qwen 3.6

Ojo acá, porque esto es donde muchos confunden “modelo más pequeño” con “modelo más lento”. Qwen 3.6 no es más pequeño, es inteligente en cuáles neuronas usa.

Un modelo denso tradicional (como Claude o GPT) usa TODOS los parámetros para cada token generado. Piensa en todas las puertas prendidas simultáneamente. Mixture of Experts funciona diferente: el modelo tiene múltiples “expertos” especializados, y una red neuronal llamada “gate network” decide cuál experto usar por cada token. Si tu pregunta es sobre debugging en Python, se activa el experto de Python. Si es sobre DevOps, se activa otro. El resto queda dormido, sin consumir GPU ni memoria.

En Qwen 3.6, la puerta “router” elige token por token cuál experto o dos expertos de los disponibles se van a usar. Solo esos parámetros se multiplican, se suman, se procesan. El resto literalmente no consume ciclos de GPU, memoria ni tiempo de cómputo. De ahí el “3B activos de 35B totales”.

¿Diferencia práctica? Velocidad de inferencia y eficiencia de recursos. Generar 100 tokens con Qwen 3.6 en una RTX 4090 toma 3-4 segundos, versus 5-6 segundos con Claude Opus por API. Si escalás a mil consultas por día, eso multiplica en latencia y cost savings.

Comparativa: Qwen 3.6 vs Claude Opus vs GPT-5.4

Acá vienen los números. Todo basado en benchmarks públicos de abril 2026 (SWE-bench Pro, Terminal-Bench 2.0, HumanEval). Estos datos son verificables en repositorios oficiales.

Métrica	Qwen 3.6-35B	Claude Opus	GPT-5.4
SWE-bench Pro (problemas reales de código)	49.5%	42.8%	45.2%
Terminal-Bench (scripts shell/bash)	51.5%	42.9%	44.1%
HumanEval (Python puro)	94.2%	92.1%	93.8%
Velocidad (tokens/segundo)	28-35	16-20	14-18
Costo por 1M tokens	USD 0.08	USD 1.35	USD 1.52
Contexto máximo	1M tokens	200K tokens	128K tokens
Ubicación de ejecución	Local + API	API (Anthropic)	API (OpenAI)
Licencia	Apache 2.0	Propietaria	Propietaria

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

Velocidad: 1.7x más rápido que Claude en promedio, 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, eso no es detalle.

Requisitos de hardware para ejecutar Qwen 3.6 localmente

¿Querés correr Qwen 3.6 en tu máquina sin pasar por API? Necesitás saber qué hardware es realista.

Requisitos mínimos recomendados

• GPU NVIDIA: RTX 4090 (24GB VRAM), RTX 4080 (24GB), H100, A6000, o equivalente. Compute capability 8.0 mínimo (RTX 30 series en adelante).
• Quantización Q4: Reduce el modelo de ~70GB a ~14-16GB. Es el sweet spot: velocidad y VRAM aceptables, sin pérdida notable en benchmarks.
• Quantización FP16: Si querés máxima precisión pero tenés presupuesto de VRAM, 32-35GB VRAM. Velocidad similar, talvez 5-10% más lenta en latencia.
• CPU-only: No recomendado. Qwen 3.6 sin GPU tarda 30+ minutos por respuesta. Si no tenés GPU, usá API en la nube o recurre a Ollama con CPU (funciona pero es impracticable para producción).
• AMD: GPUs RDNA2+ (RX 6700 XT en adelante) funcionan con soporte via HIP. Intel Arc A770+ también soportado, pero menos documentación.

Requisitos de memoria RAM del sistema

• RAM mínimo: 16GB. Si Ollama spilla a memoria del sistema (cuando VRAM llena), es lento pero funciona.
• RAM recomendado: 32GB. Evita que la memoria del sistema sea cuello de botella.
• Storage: 50GB libres. El modelo GGUF Q4 ocupa ~14-16GB, pero necesitás espacio para cache, checkpoints intermedios, logs.

¿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. No necesitás configurar casi nada.

Paso 1: Descargar e instalar Ollama

• Andá a ollama.ai (link en Fuentes abajo).
• Descargá Ollama para tu SO (Windows, macOS, Linux).
• Ejecutá el instalador. En Windows, se instala como servicio de sistema.
• Verificá que está corriendo: abrí terminal y corré ollama --version.

Paso 2: Descargar el modelo Qwen 3.6

Abrí terminal (PowerShell en Windows, terminal en macOS/Linux) 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. Ollama cachea el archivo, así que la próxima corrida es instantánea.

Paso 3: Ejecutar el modelo

ollama run qwen:3.6-35b

El modelo carga en VRAM (toma 5-10 segundos la primera vez), 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 con Claude por API).

Paso 4: Acceder por API (interfaz web)

Ollama expone una API HTTP en localhost:11434. Si querés una interfaz web, abrí navegador en:

http://localhost:11434

Hay clients web comunitarios (como Open WebUI) que se conectan a Ollama. O usás la API directamente desde tu aplicación:

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

Optimizaciones de Ollama

• Contexto reducido: Si no necesitás 1M tokens, ajustá con ollama run qwen:3.6-35b --num-ctx 32768. Ahorra VRAM, aumenta velocidad.
• Batch size: Default es 1 (latencia mínima). Si procesás múltiples consultas en paralelo, aumentá a 4-8.
• Thread count: En CPU, aumentá threads con --num-threads 16 (o tu core count).
• GPU offloading: Ollama auto-detecta GPU. Si no funciona, forzá con --gpu auto o --gpu amd (para AMD).

Instalar Qwen 3.6 con llama.cpp en tu máquina

llama.cpp es la opción para usuarios avanzados que quieren máximo control. Es más rápido que Ollama y consume menos memoria (menos overhead de runtime).

Paso 1: Descargar llama.cpp

• Andá a github.com/ggerganov/llama.cpp (en Fuentes).
• Descargá el binario precompilado para tu SO, o compilá desde source (requiere CMake + CUDA toolkit si querés GPU).
• En Windows, descargá el archivo .zip, descomprimí en C:\llama.cpp o donde prefieras.

Paso 2: Descargar el modelo GGUF

El archivo GGUF de Qwen 3.6 está en Hugging Face bajo Qwen/Qwen3.6-35B-A3B. Descargá el archivo .gguf Q4 (~14-16GB). O usá la CLI de Hugging Face:

huggingface-cli download Qwen/Qwen3.6-35B-A3B --local-dir ./qwen-models

Paso 3: Ejecutar con llama.cpp

./main -m qwen3.6.gguf -ngl 99 -n 512

Desglose:

• -m qwen3.6.gguf: Archivo del modelo.
• -ngl 99: Carga 99 capas en GPU (todos si tienes VRAM). Sin GPU, omití este flag.
• -n 512: Máximo 512 tokens en la respuesta.
• -p “Tu prompt aquí”: Agregá tu pregunta directo.

Ejemplo completo:

./main -m qwen3.6.gguf -ngl 99 -n 512 -p "Escribí una función en Rust que parsee JSON"

Generalmente más rápido que Ollama (menos intermediarios), pero menos ergonómico si necesitás interfaz web.

Rendimiento en codificación y casos de uso prácticos

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

Caso 1: Refactorización de repositorios grandes

Tenés un repositorio de 10K+ líneas, necesitás refactorizar un módulo completo. Le pasás el código a Qwen 3.6 con contexto de 1M tokens, le pedís sugerencias, y te devuelve propuestas con razonamiento inline. Qwen tarda 4 segundos. Claude por API tardaría 6-7 segundos. En un día de refactorización (100+ consultas), eso suma 300 segundos = 5 minutos ahorrados. Pero además, Qwen corre en local: cero latencia de red, cero dependencia de API externa.

Caso 2: Herramientas y agentes automatizados

Agentes que necesitan llamar funciones, escribir queries SQL, generar snippets bash. Qwen 3.6 tiene “thinking mode” nativo que encadena razonamientos antes de responder. Útil cuando la respuesta requiere paso a paso. El modelo entiende la estructura del problema antes de devolver código, lo que reduce hallucinations.

Caso 3: Debugging automático de logs densos

Tenés logs gigantes, una traza de errores de 50KB, un repositorio. Le pedís a Qwen que analice y proponga fixes. El modelo procesa el contexto entero (hasta 1M tokens), no pierde detalles, y devuelve soluciones accionables. En Qwen 3.6 eso corre en local: sin enviar datos a terceros, sin costos de API, sin timeout por tamaño.

Contexto de 1 millón de tokens y características avanzadas

Qwen 3.6 no tiene visión (no procesa imágenes), pero tiene features avanzadas que lo diferencian de Claude y GPT en cases específicos.

Contexto de 1 millón de tokens

Ese no es un truco de marketing. Significa que metés un documento de 200 páginas, un repositorio entero (hasta 500K líneas), o los últimos 3 meses de logs de tu servidor. El modelo mantiene coherencia. Comparado con Claude (200K) o GPT (128K), es 5x más contexto. Para análisis de sistemas grandes sin fragmentar, eso es ventaja real.

Soporte de 201 idiomas nativos

Soporta español nativo (no traducido de forma deficiente). Si trabajás con contenido en español, soporte técnico, documentación, análisis, el modelo entiende matices que otros modelos pierden. Las contracciones argentinas (vos, che), verbos con se, subjuntivo complejo, Qwen lo capta.

Modo thinking nativo

El modelo genera “pensamientos internos” antes de responder (similar a OpenAI o Claude). Útil cuando necesitás que el sistema muestre su razonamiento, o cuando el problema es complejo y requiere varios pasos de análisis antes de la respuesta final. Opcional; podés desactivarlo si necesitás respuesta rápida.

Tool calling nativo y function calling

El modelo puede generar llamadas a funciones, APIs, herramientas externas automáticamente. Útil para agentes autónomos. El formato es compatible con OpenAI y Anthropic, así que integrás fácil en orquestadores existentes (LangChain, LlamaIndex, llamadas directas vía JSON).

API Alibaba Bailian (alternativa a local)

Si no querés correr localmente, Alibaba ofrece API pagada (Bailian). El formato es compatible con OpenAI y Anthropic (mismos headers, mismo JSON en requests y responses). Cambiar de backend es buscar-reemplazar en tu código. Útil si necesitás escalabilidad sin mantener hardware.

Problemas comunes en instalación y cómo evitarlos

Desbordamiento silencioso de contexto

Pasás 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. En Ollama/llama.cpp, podés ajustar --num-ctx 500000 si querés contexto más pequeño (ahorra VRAM).

Fallos en tool calling silenciosos

Le pedís al modelo que llame una función, genere query, haga request, pero la salida no es JSON válido o falta información. El modelo no tira excepción, simplemente devuelve texto que no podes parsear. Solución: validá la respuesta con JSON schema antes de ejecutar. Forzá structured output (many frameworks lo soportan). Estudios de uso muestran que usar structured output reduce failures de 8% a 1%.

Problemas de quantización y compatibilidad de archivos GGUF

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ó entre versiones. Modelo no corre o genera basura. Solución: asegurate que llama.cpp está actualizado (latest commit de GitHub), descargá el GGUF del repositorio oficial (Alibaba o Hugging Face oficial), validá el hash SHA256 del archivo. En Ollama no es problema: auto-actualiza el runtime.

VRAM insuficiente incluso con quantización Q4

Tenés 16GB VRAM pero Qwen 3.6 Q4 sigue no entrando. Soluciones en orden:

• Reduce contexto: ollama run qwen:3.6-35b --num-ctx 16384 (en vez de 262K default). Ahorra 30-40% VRAM.
• Quantización más agresiva: Q3 en vez de Q4 (modelo cae a ~10GB). Velocidad similar, pequeña pérdida de precisión.
• CPU offload parcial: Si tenés 32GB RAM, déjá que Ollama use sistema memory (lento pero funciona).
• Modelo más pequeño: Alibaba también lanzó Qwen 3.6-9B (~3-4GB Q4). Benchmarks más bajos, pero funciona en hardware limitado.
• API en la nube: Si local no va, usa Bailian API. Cuesta dinero pero evita comprar hardware.

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

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

Usá Qwen 3.6 si…

• Trabajás con código real todos los días: SWE-bench Pro 49.5% es superior a Claude en problemas reales de repositorios.
• Necesitás velocidad y latencia baja: 1.7x más rápido que Claude local o por API.
• No tenés presupuesto de API recurrente: Apache 2.0, gratis corriendo localmente. USD 0.08 por 1M tokens en API (vs USD 1.35 Claude).
• Tienes compliance o privacidad: Datos nunca salen del servidor, no confías en terceros, GDPR/HIPAA.
• Necesitás contexto largo: 1M tokens vs 200K de Claude. Repositorios enteros, logs largos, documentación masiva.
• Equipos con hardware moderno: RTX 4090, H100, A6000. Rentabilidad por inversión en hardware.

Usá Claude Opus si…

• Necesitás mejor reasoning en general: Claude es mejor en edge cases, razonamiento complejo no-código, escritura creativa.
• No querés mantener infraestructura: API gestionada, cero ops, escalabilidad infinita.
• Trabajás con multimodalidad: Claude tiene visión (procesa imágenes).
• No tenés restricciones de privacidad: Los datos pasan por Anthropic, pero confías en su política.

Usá GPT-5.4 si…

• Necesitás el modelo “mejor del mejor” sin importar costo: GPT generalmente es opción premium.
• Ecosistema OpenAI: Integraste mucho con OpenAI, plugins, no querés migrar.
• Necesitás stable API con SLA garantizado: OpenAI tiene infraestructura probada, menos downtime.

Dato final: La mejor opción es híbrida. Usa Qwen 3.6 para código local (velocidad + costo), Claude por API para reasoning complejo (escritura, análisis), GPT-5.4 para casos premium. No es “uno u otro”.

Preguntas Frecuentes

¿Qwen 3.6-35B tiene visión (puede procesar imágenes)?

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

¿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. Lo que sí podés hacer: usar context injection (meter tus datos en el prompt) o usar LoRA (low-rank adaptation) para adaptación ligera. Para la mayoría de casos, context injection basta.

¿Qwen 3.6 funciona sin GPU (solo CPU)?

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

¿Puedo usar Qwen 3.6 en Google Colab o Kaggle gratis?

Sí, pero con limitaciones. Colab Free tier tiene T4 GPU (16GB VRAM), que no alcanza para Qwen 3.6 sin problemas. Colab Pro+ con A100 funciona bien. 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 directamente. En LangChain, inicializás con ChatOllama(model="qwen:3.6-35b") (python-ollama instalado). En LlamaIndex, 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 soporta spanish nativo o es traducido?

Nativo. Qwen fue entrenado en 201 idiomas incluido 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 que fueron entrenados en inglés y después “adaptados” a español.

¿Cómo monitoreo el uso de VRAM mientras Qwen corre?

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

Conclusión

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

Ahora hay alternativa open source seria. Un modelo que corrés localmente, que entrenás vos si necesitás, que adaptás a tus procesos. Eso cambia el juego para equipos que no pueden depender de APIs externas por compliance, costo o privacidad. Alibaba metió trabajo serio en Qwen 3.6, y se nota en los benchmarks.

El diferencial de velocidad (1.7x), costo (17x más barato), contexto (5x más) y control (localmente) es real. No elegís Qwen 3.6 porque sea “mejor” que Claude; elegís porque te da lo que necesitás a un precio que tiene sentido.

Fuentes

• Qwen 3.6-35B en Hugging Face — repositorio oficial del modelo con documentación técnica, weights, tokenizer.
• Ollama oficial — herramienta para descargar y ejecutar modelos localmente.
• llama.cpp en GitHub — runtime optimizado para modelos GGUF, alternativa a Ollama con más control.
• Guía de hardware local para Qwen 2026 — benchmarks independientes de latencia, VRAM, velocidad en GPUs reales.
• Ollama en GitHub — source code, issues, community support.

FAQs adicionales de instalación y uso

¿Dónde descargo el archivo GGUF de Qwen 3.6 para ejecutarlo con llama.cpp?

El archivo GGUF está en Hugging Face bajo Qwen/Qwen3.6-35B-A3B. Descargá el .gguf Q4 (~14-16GB), instalá llama.cpp con soporte cuBLAS, y ejecutá ./main -m qwen3.6.gguf -ngl 99. Se ejecuta en 2 minutos sin dependencias raras. Verificá el hash SHA256 del archivo descargado con el de Hugging Face.

¿Qwen 3.6-35B y Qwen 35B son el mismo modelo?

Sí, es el mismo. El “3.6” hace referencia a los parámetros *activos* (3.6 mil millones) de un total de 35 mil millones. Qwen 3.6-35B usa arquitectura Sparse MoE, que enciende selectivamente solo los parámetros que necesita por cada token, ahorrando memoria y velocidad sin sacrificar calidad en benchmarks.

¿Qué significa GGUF y por qué importa para Qwen 3.6?

GGUF es un formato de archivo optimizado para ejecutar modelos localmente con herramientas como llama.cpp y Ollama. Comprime el modelo (Qwen 3.6 original ~70GB baja a ~14GB en GGUF Q4) sin perder precisión notable en benchmarks, permitiéndote correr el modelo en hardware convencional sin necesidad de múltiples GPUs.

¿Cuánta memoria real necesito para ejecutar Qwen 3.6 localmente?

Mínimo 24GB VRAM en GPU (RTX 4090, H100, A6000) con quantización Q4. Sin quantización necesitás 32GB+ VRAM. Con Ollama, la memoria se gestiona automáticamente; si no alcanza VRAM, usa memoria del sistema (pero velocidad baja a ~1 token/seg vs 28-35 con GPU llena). RAM del sistema de al menos 16GB recomendado como fallback.

¿Ollama tiene límite de consultas o tokens mensuales?

No. Ollama es software local, sin límites ni restricciones de uso. Corrés el modelo vos, no hay servidor central contando tokens. Es unlimited mientras tengas VRAM disponible. Ideal para proyectos sin presupuesto de API o compliance estricto.

¿Puedo servir Qwen 3.6 a múltiples usuarios simultáneamente desde una sola máquina?

Sí. Ollama (y llama.cpp) tienen servidor HTTP que acepta múltiples conexiones. En producción, recomiendo vLLM o SGLang para mejor concurrencia y batching. Pero para 5-10 usuarios simultáneos, Ollama default funciona.

¿Qwen 3.6 se actualiza regularmente o está “congelado”?

El modelo 3.6-35B fue lanzado en abril de 2026 y está estable. Alibaba lanzó versiones posteriores (Qwen 4.0, etc.), pero Qwen 3.6 sigue siendo válido y mantenido. Los weights están en Hugging Face; el repositorio se actualiza si hay parches o mejoras menores (tokenizer, formato).

¿Es seguro correr Qwen 3.6 en máquina compartida o entorno multi-usuario?

Sí. Ollama y llama.cpp corren en usuario-space, no requieren permisos de sistema. Múltiples usuarios pueden ejecutar instancias en la misma máquina sin conflicto (aunque competirán por VRAM). Para entorno multi-usuario verdadero, aisla con containers (Docker) o VMs.