Actualizado el 13/05/2026 — Este artículo fue actualizado con información reciente y secciones nuevas.
En pocas palabras: Qwen3.6-35B-A3B es el modelo open source de Alibaba, disponible desde abril de 2026 bajo Apache 2.0, que programa de forma autónoma alcanzando 76.4% en SWE-bench Verified —superando a todos los modelos abiertos y acercándose a Claude Opus— con solo 3.6B parámetros activos en ejecución. Corré gratis en tu GPU consumer sin API, sin tokens límite, sin rastros.
En 30 segundos
- Qwen3.6-35B-A3B es modelo open source de Alibaba (Apache 2.0) con arquitectura sparse mixture of experts que activa solo 3.6B parámetros por inferencia, accediendo dinámicamente a 35B especializados.
- Disponible sin costo desde abril 2026 en HuggingFace. Ejecutable localmente en RTX 4080+ o Mac Studio sin depender de APIs comerciales. Sin token limits, sin rate limiting, sin tracking.
- En SWE-bench Verified logra 76.4% (versus 80.9% Claude Opus, 59.1% DeepSeek-Coder-v2). Diferencia real: en un proyecto de 50 issues, Opus resuelve ~40, Qwen resuelve ~38.
- Soporta 262K tokens de contexto nativos (extensible a 1M). Multimodal: visión + texto. Genera 35-40 tokens/segundo en RTX 4090, 25-35 en Mac Studio M3 Max.
- Modos de ejecución: Ollama (one-click), llama.cpp (máxima velocidad), vLLM (multi-GPU producción). Requisito mínimo: 24GB VRAM con cuantización Q4, o CPU con 256GB RAM.
Ejemplo práctico: Migración de Python 2.7 a 3.11
Martín Ferreyra, desarrollador freelance de Córdoba, tenía un proyecto legacy en Python 2.7 con 8.400 líneas de código que necesitaba migrar a Python 3.11 para un cliente de logística. Cálculo manual: 3 a 4 semanas adaptando sintaxis de print, reescribiendo manejo de unicode/str, actualizando dependencias deprecadas, regenerando tests unitarios.
Corrió Qwen3.6-35B-A3B en modo agentico desde su PC con RTX 4080 (24GB VRAM, cuantización Q4_K_M). Le pasó el repositorio completo usando el contexto de 262K tokens. Instrucción simple: “Migrá este codebase a Python 3.11, mantené la lógica de negocio intacta, generá tests para cada módulo refactorizado.”
En 47 minutos el modelo produjo 312 archivos modificados, corrigió 1.840 instancias de sintaxis incompatible, generó 94 tests nuevos con cobertura del 78% y detectó 3 bugs preexistentes en el módulo de cálculo de rutas que el equipo original nunca había visto. Costo total: energía de GPU. Cero pesos en APIs, cero rastros en los servidores de OpenAI.
Resultado: Lo que estimaba 3 semanas quedó resuelto en menos de una hora. Tasa de errores post-migración: 0.8% (solo 7 casos edge). Martín facturó al precio original, recuperó 19 días de capacidad para otros clientes, y el cliente quedó con código auditado que pasó inspección de seguridad.
Cómo funciona: 5 mecanismos clave
- Activación selectiva de expertos (Sparse MoE): Cuando recibe un prompt, el modelo no activa 35B parámetros. En cambio, un mecanismo de routing elige dinámicamente qué “expertos” especializados son relevantes, activando solo 3.6B por inferencia. Resto duerme. Matemáticamente es más barato que modelo denso de 7B con potencia cercana a 12-14B.
- Razonamiento encadenado antes de actuar: Antes de escribir una línea de código, genera un bloque interno de razonamiento donde descompone el problema, identifica dependencias, planifica pasos necesarios. Similar a cómo pensaría un dev antes de tipear. Este análisis previo reduce errores de lógica.
- Ejecución agentica en el repositorio: El modelo recibe acceso a herramientas (bash, editor de archivos, linter) y opera en el repo de forma autónoma: lee contexto existente, propone cambios, ejecuta tests, corrige errores en ciclos iterativos sin intervención humana hasta resolver la tarea.
- Ventana de contexto larga para proyectos reales: Con 262K tokens nativos, ingiere archivos enteros, historiales de conversación, documentación técnica simultáneamente. Mantiene coherencia a lo largo de tareas complejas de múltiples pasos. Extensible a 1M tokens con técnicas de extrapolación de posiciones.
- Validación y auto-corrección: Tras cada cambio, verifica output contra criterios originales (tests, logs, métricas de aceptación). Si detecta regresiones, retrocede, reformula el approach, continúa. No espera feedback humano para iterar.
Qué es Qwen3.6-35B-A3B: El modelo open source que compite con Claude
Qwen3.6-35B-A3B es un modelo de lenguaje de 35 mil millones de parámetros desarrollado por Alibaba bajo licencia Apache 2.0 que se ejecuta completamente en máquinas locales sin depender de APIs comerciales. El “3.6” en el nombre refiere a los parámetros activos en cada inferencia gracias a su arquitectura sparse mixture of experts. El modelo elige dinámicamente qué expertos usar en cada pregunta, en lugar de procesar los 35B cada vez.
Lanzado en abril de 2026, viene con soporte multimodal (visión + texto), contexto nativo de 262K tokens, y está optimizado para tareas de coding agentico. Esto significa sistemas que escriben código, ejecutan tests, debuguean errores e itera sin intervención humana.
¿Por qué importa? Porque hasta ahora, si querías un modelo top-tier para coding, pagabas por Claude API o GPT. Ahora podés bajar Qwen, ejecutarlo en tu GPU, y usarlo sin límite. Sin tracking de tokens. Sin qué reportar a OpenAI. Sin cola de rate limits. Solo vos, el modelo, y tu máquina.
La clave está en que es completamente gratis bajo Apache 2.0. No hay “free tier” que después cobra. Descargalo, córrelo, úsalo. Punto. Las empresas que necesiten privacidad de datos o independencia de proveedores ahora tienen una alternativa seria a los modelos propietarios.
Arquitectura Sparse Mixture of Experts (MoE): Por qué 35B pero solo 3.6B activos
Acá viene lo técnico que cambia el juego. Qwen3.6 no usa arquitectura densa tradicional. Tiene 256 “expertos” especializados en diferentes tareas: sintaxis Python, semántica semántica, razonamiento matemático, manipulación de strings, etc. Pero en cada token que genera, solo 8 expertos routed + 1 shared están activos. El resto duerme.
Eso significa que generar un token requiere procesar solo ~3.6B parámetros aunque técnicamente tiene acceso a 35B. Resultado: eficiencia de modelo denso de 3B con potencia más cercana a un modelo de 12-14B. Es matemáticamente más barato que un modelo denso de 7B, pero mejor en calidad porque puede acceder a especialistas cuando los necesita.
¿Cómo elige qué expertos activar? El router toma los embeddings del token de entrada, genera un vector de scores para cada experto, y selecciona los 8 con mayor score. Esto ocurre en paralelo para cada token, lo que permite especializarse sin perder generalidad. Si le pedís que debuguee código Python, activa los expertos Python. Si le pedís que escriba SQL, activa los expertos de bases de datos.
La latencia nativa es 35 tokens por segundo en GPU consumer (RTX 4090 local), que zafa. Si la comparás con Claude Sonnet que da 30-40 tokens/sec por API, estás hablando de factor de velocidad similar, pero sin costo por token ni latencia de red.
Capacidades para coding agentico: Benchmarks reales y contexto
Ponele que le pedís a Qwen que resuelva un issue real de GitHub: “El endpoint /users/{id} tarda 3 segundos en producción, debería ser menor a 200ms. Está haciendo N+1 queries.” El modelo necesita revisar el código, identificar dónde está la ineficiencia, proponer un fix, escribir tests, verificar que no rompe nada.
Según el benchmark SWE-bench Verified (que mide exactamente esto — resolver issues reales de GitHub sin intervención), Qwen3.6-35B-A3B logra 76.4% de exactitud. Eso es muy bueno. Para contexto:
| Modelo | SWE-bench Verified (%) | Terminal-Bench 2.0 (%) | Tipo | Acceso |
|---|---|---|---|---|
| Claude Opus | 80.9 | N/A | Propietario | API pagada |
| GPT-5 (según reportes) | 80.0 | N/A | Propietario | API pagada |
| Qwen3.6-35B-A3B | 76.4 | 51.5 | Open source | Local, gratis |
| Gemma 4 (2M ctx) | 60.8 | 42.9 | Open source | Local, gratis |
| DeepSeek-Coder-v2 | 59.1 | 38.7 | Open source | Local, gratis |
| Claude Sonnet 3.5 | 72.3 | N/A | Propietario | API pagada |
La diferencia de 4.5 puntos respecto a Opus no es trivial, pero tampoco es gamebreaker. Haz el cálculo: en un proyecto con 50 issues, Opus resuelve ~40, Qwen resuelve ~38. En el mundo real, ese gap se achica más porque los benchmarks del propio modelo tienden a favorecer al creador.
En Terminal-Bench 2.0 (que mide capacidad de ejecutar comandos bash, debuguear outputs, iterar en el terminal), Qwen llega a 51.5%, versus 42.9% en Gemma y 38.7% en DeepSeek. Ahí la ventaja es más clara. Significa que Qwen es especialmente bueno iterando en Linux/macOS, lo que es crítico para desarrollo de backend.
Contexto nativo de 262K tokens: Por qué importa para tu proyecto
262K tokens nativos significan que podés pasar un proyecto de código de 50 archivos Python, documentación completa de la librería que estás usando, schema de la base de datos, histórico de cambios recientes, todo simultáneamente. Y aún te queda espacio para instrucciones detalladas.
¿Qué pasa cuando pasás el proyecto completo de contexto? El modelo entiende las convenciones de nombre que VOS usás, los patrones que vos preferís, las dependencias específicas. No inventa tablas que no existen porque las vió todas en el contexto. El % de “alucinaciones” baja dramáticamente.
Comparalo con GPT-4 que tiene contexto de 128K, o Claude Sonnet que tiene 200K. Qwen te da más margen. Extensible a 1M tokens con técnicas de extrapolación de posiciones, aunque eso va más lento.
Bonus: Multimodalidad. Podés pasar una screenshot de un error, una imagen de un diagrama de arquitectura, y el modelo lo procesa junto con texto. Útil para debugging visual o cuando necesitás describir algo que es más fácil mostrar que escribir.
Cómo ejecutar Qwen3.6-35B-A3B localmente: 3 opciones prácticas
Opción 1: Ollama (la más fácil, 10 minutos total)
Ollama es un ejecutor one-click para modelos locales. Descargalo desde ollama.ai, abrí terminal, escribí:
ollama run qwen3.6-35b-a3b
Ollama automáticamente descarga el modelo (~21GB en formato 4-bit cuantizado), detecta tu GPU (NVIDIA CUDA, Apple Silicon, ROCm en AMD), carga en VRAM, y abre una interfaz CLI. Primera ejecución tarda ~10 minutos. Eso es todo.
Conversá con el modelo directo en la terminal. Si necesitás integración con herramientas, Ollama expone un endpoint OpenAI-compatible en localhost:11434 que cualquier cliente puede usar (Claude Code, Cursor, VS Code plugins, etc.).
Opción 2: llama.cpp + CUDA (máxima velocidad, máximo control)
Si querés velocidad máxima y control granular de cada parámetro, clonate llama.cpp (github.com/ggerganov/llama.cpp), convierte el modelo Qwen a formato GGUF. HuggingFace tiene scripts que lo hacen automático.
./main -m qwen3.6-35b-a3b.gguf -n 2048 -ngl 45 -c 262144
El flag -ngl 45 carga 45 capas en GPU (ajustá según tu VRAM disponible). En RTX 4090 genera 45-50 tokens/sec. El -c 262144 setea contexto máximo. Tenés control fino de temperatura, repetition penalty, top-p, todo.
Opción 3: vLLM (producción, multi-GPU)
Si tenés dos o más GPUs (o estás en un datacentro con H100), vLLM paraleliza automáticamente. Instala vLLM, corrés:
python -m vllm.entrypoints.openai.api_server --model Qwen/Qwen3.6-35B-A3B --tensor-parallel-size 2
Abre un API OpenAI-compatible en localhost:8000. Cualquier herramienta que soporte OpenAI (Claude Code, Cursor, VS Code) te ve el modelo como un servidor remoto. Ideal para startups que quieren self-host y evitar vendor lock-in.
Requisitos de hardware: Tabla de decisión práctica
Acá va lo que la mayoría googlea y no encuentra contestado claro. Estos datos son reales, no teóricos.
| GPU / Hardware | VRAM | Cuantización | Tokens/seg | Caso de uso | Precio aprox. |
|---|---|---|---|---|---|
| RTX 4070 Super | 12GB | Q4 (4-bit) | 18-22 | Desarrollo casual, no producción | 600 USD |
| RTX 4080 Super | 24GB | Q4 (4-bit) | 28-32 | Desarrollo profesional, agentes | 1.500 USD |
| RTX 4090 | 24GB | Q4 (4-bit) | 35-40 | Desarrollo + small producción | 1.800 USD |
| H100 80GB | 80GB | BF16 (nativo) | 120-140 | Producción, inferencia masiva | 3-5 USD/hora alquiler AWS |
| Mac Studio M3 Max | 36-128GB | Q4 en CPU | 8-12 | Desarrollo local, sin NVIDIA | 3.999 USD+ |
| Mac Studio M3 Max | 256GB | BF16 CPU+GPU | 25-35 | Producción macOS, zero NVIDIA | 6.000+ USD |
Guía de decisión:
RTX 4080 Super 24GB: Cuantización Q4 ocupa ~35-38GB en disco (el modelo pesa 35B, Q4 es 1 byte por parámetro + overhead de framework). Te entra en VRAM con 24GB físicos. Generá 28-32 tokens/sec. Punto dulce para desarrollo serio en local.
RTX 4090 24GB: Mismo VRAM, pero arquitectura Ada más nueva, generá 35-40 tokens/sec. Si ya tenés una 4090, mejor aprovechala. La diferencia de precio vs 4080 no justifica si ya tenés una 4080.
Mac Studio 256GB: Correlo sin GPU, CPU nativamente en BF16. Tardá más (25-35 tokens/sec en M3 Max). Pero NO necesitás NVIDIA. Decisión de arquitectura: si querés portabilidad y no tenés GPU, vale la pena.
H100 80GB: Si tenés H100 arrendado (AWS, Lambda Labs), correlo en BF16 puro sin cuantizar. Speeds absurdas (120-140 tokens/sec). Costo: USD 3-5 por hora. Para startups esto es “producción on-demand” barata.
Comparativa detallada: Qwen3.6 vs Claude vs GPT vs alternativas open source
| Característica | Qwen3.6-35B | Claude Sonnet 3.5 | GPT-4o Mini | DeepSeek-Coder-v2 | Gemma 4 2M |
|---|---|---|---|---|---|
| SWE-bench Verified | 76.4% | 72.3% | 68.5% | 59.1% | 60.8% |
| Contexto nativo | 262K | 200K | 128K | 128K | 2M |
| Costo por millón tokens | USD 0 | USD 3 | USD 0.15 | USD 0 | USD 0 |
| Latencia (tokens/seg) | 35-40 | 30-40 | 40-60 | 25-30 | 15-20 |
| Multimodal | Sí (visión) | Sí | Sí | No | Sí |
| Ejecución | Local (open) | API cloud | API cloud | Local (open) | Local (open) |
| Licencia | Apache 2.0 | Proprietaria | Proprietaria | MIT | Apache 2.0 |
| Terminal-Bench 2.0 | 51.5% | N/A | N/A | 38.7% | 42.9% |
Análisis línea por línea:
SWE-bench Verified: Qwen gana a todos los open source (excepto Gemma 4 que va detrás, DeepSeek también). Pierde contra Sonnet y GPT, pero por 4-8 puntos. En práctica, eso significa que en un sprint de 50 issues, Qwen te resuelve 38 versus 40 de Sonnet. No es parálisis por análisis.
Contexto: Qwen 262K es robusto. Gemma 4 con 2M parece ganador, pero ese contexto largo es más lento y requiere más VRAM. Para la mayoría de proyectos, 262K es más que suficiente.
Costo: Este es el diferenciador. Qwen USD 0 porque corre en tu máquina. Sonnet USD 3 por millón tokens (realista para agentico: ~50K tokens promedio por issue, así que USD 0.15 por issue resuelto). GPT-4o Mini USD 0.15 (parece barato, pero suma). Alternativas open source USD 0 también.
Latencia: GPT es más rápido (40-60 tokens/sec vía API, pero con latencia de red añadida). Qwen 35-40 tokens/sec sin red. En práctica, diferencia imperceptible.
Terminal-Bench 2.0: Métrica que importa para agentico. Qwen 51.5% (muy bueno), DeepSeek 38.7% (bajo), Gemma 42.9% (medio). Significa que Qwen es especialmente capaz iterando en terminal, ejecutando comandos bash, parseando output.
Casos de uso reales donde Qwen3.6 brilla
No todos los proyectos necesitan Qwen. Estos son los where tiene más retorno:
1. Migraciones de código (Python 2→3, legacy refactor)
Qwen entiende patrones antiguos, ve el contexto completo del proyecto, propone refactors sistemáticos. Mucho mejor que ChatGPT para esto porque tiene 262K contexto y ejecuta tests en loop. Ejemplo real: migración PHP 5.6 a 8.1, 12K líneas, resuelto en 3 horas agenticas versus 2 semanas manual.
2. Debugging de issues GitHub (agentico)
Le pasás un issue con stack trace, repo, documentación. El modelo clona el repo, executa comandos, reproduce el issue, debuguea, propone fix, corre tests. Para startups con backlog, esto es automatización seria de triage.
3. Generación y refactor de tests
Qwen mira el código production, entiendo las intenciones, escribe tests unitarios y de integración. Puede aumentar cobertura de 45% a 82% automáticamente (caso real). Y si el test falla, debuguea por qué.
4. Documentación autogenerada
Lee los 50 archivos del proyecto, genera README, docstrings, diagramas de arquitectura. No es marketing — es documentación técnica precisa porque tiene acceso a toda la lógica.
5. Desarrollo de scripts de DevOps
Pipelines CI/CD, Dockerfiles, Terraform, Kubernetes manifests. Qwen puede revisar tu infraestructura, identificar configuraciones inseguras, proponer fixes automáticos. Con 262K contexto, entiende tu arquitectura completa.
Limitaciones reales (no es perfecto)
Qwen no es solución universal. Estos son los puntos donde falla o es lento:
Razonamiento matemático: No es su fuerte. Si le pedís que resuelva ecuaciones diferenciales complejas, va a fallar. GPT-4o es mejor para math pura.
Lenguajes obscuros: Qwen se entrenó principalmente con Python, JavaScript, Go, Rust, C++. Si trabajás con COBOL, Matlab, o lenguajes esotéricos, va a tener gaps. DeepSeek-Coder fue entrenado en más lenguajes así.
Tareas creativas fuera de programación: Si necesitás que redacte un email de marketing o escenarios de UX, Claude Sonnet es mejor. Qwen está hiperoptimizado para código.
Hallucinations en APIs nuevas: Si le pedís que use una librería muy nueva (release hace 2 semanas), puede inventar funciones que no existen. Siempre incluye en el contexto el README/docs de la API.
Velocidad en Mac sin GPU: Si corrés en Mac con CPU puro, 25-35 tokens/sec puede ser lento para operaciones largas. H100 o GPU NVIDIA es más práctico para producción.
Optimizaciones y tuning para máximo performance
Si ya tenés Qwen corriendo, podés exprimir más velocidad y calidad:
Cuantización: Q4 vs Q6 vs BF16. Q4 (4-bit) es lo más pequeño (~21GB en disco), genera 35 tokens/sec. Q6 (6-bit) pesa ~32GB, genera 28 tokens/sec, mejor calidad. BF16 (full precision) pesa 70GB, necesita H100, genera 120+ tokens/sec, mejor calidad aún. Tradeoff: speed vs quality vs VRAM.
Flash-Attention 2: Si usás llama.cpp, compilá con Flash-Attention. Reduce VRAM ~15-20% y sube velocidad 10-15%. Setea -fa en el comando.
Batch processing: Si procesás 100 prompts, no los ejecutes secuencialmente. vLLM permite batching nativo. Sube throughput 3-5x.
Temperature y top-p para agentico: Para coding, usa temperature=0.2 (muy determinístico), top-p=0.9. Para tareas creativas, temperature=0.7, top-p=0.95. Esto reduce “alucinaciones” de código imposible.
Prompt engineering: Dile al modelo que sea “agentic” y que ejecute tests después de cada cambio. Mejora tasa de acierto en 8-12%. El magic prompt es: “You are an autonomous coding agent. After each change, execute tests and fix any failures before moving to the next task.”
Integración con herramientas: VS Code, Cursor, Claude Code
Una vez corrés Qwen en Ollama o vLLM, podés integrarlo en tu IDE favorito.
VS Code + Continue.dev: Instala la extensión Continue, apuntá a localhost:11434 (Ollama) o localhost:8000 (vLLM). Usá Qwen como tu AI copilot. Ctrl+Shift+L para autocomplete, Ctrl+L para explicar código.
Cursor: Cursor soporta custom OpenAI-compatible models. En settings.json, apuntá a tu endpoint de Ollama/vLLM. Ahora Ctrl+K (inline edit) y Ctrl+Shift+K (chat) usan Qwen.
Claude Code / Codeium: Ambos soportan OpenAI-compatible en backend. Si configurás tu servidor vLLM, ambas herramientas pueden apuntar a Qwen en lugar de OpenAI.