> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/qwen36-27b.md).

# Qwen3.6-27B (denso, una sola GPU)

Despliega Qwen3.6-27B de Alibaba en Clore.ai: un modelo denso de 27B que cabe en una sola RTX 4090 y viene con contexto nativo de 262K

{% hint style="info" %}
**Estado (abril de 2026):** Qwen3.6-27B fue lanzado por Alibaba el **21 de abril de 2026** bajo la **Apache 2.0** licencia. Los pesos están en [huggingface.co/Qwen/Qwen3.6-27B](https://huggingface.co/Qwen/Qwen3.6-27B). Es un **denso** modelo de 27B — no MoE — con un **contexto nativo de 262K tokens** que se extiende hasta **1M tokens con YaRN**, y compatibilidad desde el día 0 con vLLM, SGLang y Ollama.
{% endhint %}

Los gigantes MoE de 2026 — DeepSeek V4, GLM-5.1, MiMo-V2.5-Pro — son emocionantes en los benchmarks, pero agotadores en la práctica: cientos de GB de pesos, racks multi-GPU, kernels frágiles de enrutamiento de expertos y facturas de inferencia que hacen estremecer a los equipos de finanzas. Qwen3.6-27B va en la dirección opuesta. Es **denso**, cada parámetro se activa en cada token, la VRAM es predecible al gigabyte, y no hay sorpresas de enrutamiento de expertos cuando superas el contexto de 8K.

Para la mayoría de los equipos, la pregunta no es "¿podemos servir un MoE de 744B?" — es "¿podemos poner una buena tarjeta en nuestro clúster y servir sobre ella un asistente de programación de clase frontera?" Qwen3.6-27B está hecho exactamente para eso. Q4 cabe en una sola **RTX 4090 24GB**, Q8 cabe en una sola **RTX 5090 32GB**, BF16 cabe en una sola **L40S 48GB** o **A100 40GB**, y Alibaba publica **77.2% en SWE-Bench Verified** (afirmado por el proveedor). Una tarjeta, un contenedor, un modelo.

### Especificaciones clave

| Propiedad                | Valor                                  |
| ------------------------ | -------------------------------------- |
| Parámetros               | 27B (denso)                            |
| Arquitectura             | Transformador denso solo decodificador |
| Contexto nativo          | 262,144 tokens                         |
| Contexto extendido       | 1,000,000 tokens (YaRN)                |
| Licencia                 | Apache 2.0                             |
| Fecha de lanzamiento     | 21 de abril de 2026                    |
| Organización             | Alibaba (equipo Qwen)                  |
| Herramientas principales | vLLM, SGLang, Ollama, llama.cpp        |

### ¿Por qué Qwen3.6-27B?

* **Economía de una sola GPU** — Q4 en una RTX 4090 desde **$0.14–0.42/h** en Clore.ai; sin orquestación de paralelismo tensorial que depurar
* **Denso, no MoE** — VRAM fija, sin puntos calientes de expertos, sin latencia irregular en ciertos prompts
* **Apache 2.0** — totalmente comercial, ajustable mediante fine-tuning, redistribuible, sin límites de uso
* **262K de contexto nativo, 1M con YaRN** — bases de código completas, libros enteros, horas de transcripciones en una sola pasada
* **vLLM / SGLang / Ollama desde el día 0** — elige tu stack de servicio; Qwen publicó configuraciones para los tres en el lanzamiento
* **77.2% SWE-Bench Verified** (afirmado por el proveedor) — competitivo con modelos MoE mucho más grandes en tareas reales de programación

***

## Requisitos

{% hint style="success" %}
**La idea es que este modelo es indulgente.** Una sola RTX 4090 del mercado de Clore.ai es suficiente para ejecutar Qwen3.6-27B con calidad de nivel de producción (Q4) o velocidades «suficientemente buenas para la mayoría de los casos de uso». Sin dolores de cabeza de múltiples GPU.
{% endhint %}

| Componente     | Q4 (GGUF / AWQ)  | Q8 (GGUF / GPTQ) | BF16                        | FP16 completo                    |
| -------------- | ---------------- | ---------------- | --------------------------- | -------------------------------- |
| GPU            | 1× RTX 4090 24GB | 1× RTX 5090 32GB | 1× L40S 48GB o 1× A100 40GB | 1× A100 80GB                     |
| VRAM utilizada | \~16–18GB        | \~28–30GB        | \~54GB                      | \~54GB + margen para la caché KV |
| RAM            | 32GB             | 32GB             | 64GB                        | 96GB                             |
| Disco          | 20GB NVMe        | 32GB NVMe        | 60GB NVMe                   | 60GB NVMe                        |
| CUDA           | 12.8+            | 12.8+            | 12.8+                       | 12.8+                            |

**Elección de Clore.ai:** Para el 90% de los equipos, una sola **RTX 4090 24GB** ejecutando Q4 (AWQ o GGUF) es la respuesta correcta. Obtienes programación de clase frontera por el precio de un par de cafés al día. Sube a una RTX 5090 32GB si quieres Q8 para una calidad ligeramente mejor, o a L40S / A100 40GB para inferencia de producción BF16 completa.

***

## Opción A — Ollama (cuantizado, el más fácil)

Ollama es la vía más rápida de "tengo una GPU de Clore.ai" a "tengo un endpoint de chat".

```bash
# Descargar Qwen3.6-27B (Q4_K_M por defecto, descarga de ~17GB)
ollama pull qwen3.6:27b

# Ejecutar de forma interactiva
ollama run qwen3.6:27b

# O exponer la API compatible con OpenAI
ollama serve &

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "qwen3.6:27b",
    "messages": [
      {"role": "system", "content": "Eres un ingeniero senior de Go."},
      {"role": "user", "content": "Refactoriza este controlador para usar context.Context correctamente y añade reintentos con backoff exponencial."}
    ],
    "temperature": 0.6
  }'
```

{% hint style="info" %}
El valor predeterminado `qwen3.6:27b` en Ollama corresponde a Q4\_K\_M. Usa `qwen3.6:27b-q8_0` para Q8 si tienes una RTX 5090, o `qwen3.6:27b-fp16` para precisión completa (necesita una A100 80GB).
{% endhint %}

***

## Opción B — vLLM (producción)

vLLM es el servidor de producción recomendado. La configuración de una sola GPU de abajo apunta a una RTX 4090 con cuantización AWQ. La sección multi-GPU está ahí por completitud, pero con un modelo denso de 27B, casi nunca la necesitas.

```yaml
# docker-compose.yml — una sola RTX 4090, Q4 AWQ
version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model Qwen/Qwen3.6-27B-Instruct-AWQ
      --quantization awq
      --max-model-len 65536
      --gpu-memory-utilization 0.92
      --served-model-name qwen3.6-27b
      --enable-auto-tool-choice
      --tool-call-parser hermes
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    shm_size: "8gb"

volumes:
  hf_cache:
```

```bash
# Probar la API
curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "qwen3.6-27b",
    "messages": [
      {"role": "user", "content": "Explica la diferencia entre modelos MoE y densos en 3 viñetas."}
    ],
    "max_tokens": 512,
    "temperature": 0.7
  }'
```

Para la versión completa **BF16** en una sola L40S 48GB o A100 40GB, elimina `--quantization awq` y apunta al checkpoint base (`Qwen/Qwen3.6-27B-Instruct`, `--dtype bfloat16`, `--max-model-len 131072`). Para 2× RTX 4090 con paralelismo tensorial (contexto más largo, caché KV más grande), añade `--tensor-parallel-size 2`.

***

## Opción C — SGLang

SGLang brilla cuando superas la ventana nativa de 262K con YaRN. Pasa `--rope-scaling` para extenderlo a \~1M tokens.

```bash
docker pull lmsysorg/sglang:latest

# Una sola GPU, contexto nativo de 262K
python3 -m sglang.launch_server \\
  --model-path Qwen/Qwen3.6-27B-Instruct \\
  --quantization awq \\
  --context-length 262144 \\
  --mem-fraction-static 0.90 \\
  --served-model-name qwen3.6-27b

# Extendido con YaRN a 1M tokens (necesita más margen de VRAM)
python3 -m sglang.launch_server \\
  --model-path Qwen/Qwen3.6-27B-Instruct \\
  --dtype bfloat16 \\
  --context-length 1000000 \\
  --json-model-override-args '{"rope_scaling":{"type":"yarn","factor":4.0,"original_max_position_embeddings":262144}}' \\
  --mem-fraction-static 0.85
```

{% hint style="warning" %}
**Los costes del contexto de 1M crecen rápido.** Incluso con YaRN, la caché KV para 1M tokens en BF16 es aproximadamente **40–60GB** según el tamaño del lote. Planifica una A100 80GB o H100 si realmente pretendes llenar la ventana.
{% endhint %}

***

## Recomendaciones de GPU para Clore.ai

| Configuración        | VRAM  | Modo        | Rendimiento esperado                  | Coste de Clore.ai                         |
| -------------------- | ----- | ----------- | ------------------------------------- | ----------------------------------------- |
| **1× RTX 4090 24GB** | 24GB  | Q4 AWQ      | 50–80 tok/s, 64K ctx                  | **$0.14–0.42/h**                          |
| 1× RTX 5090 32GB     | 32GB  | Q8 GPTQ     | 60–90 tok/s, 96K ctx                  | $0.25–0.77/h                              |
| 1× L40S 48GB         | 48GB  | BF16        | 35–55 tok/s, 131K ctx                 | \~$0.50/hr                                |
| 1× A100 40GB         | 40 GB | BF16        | 40–60 tok/s, 96K ctx                  | [bare metal](https://clore.ai/bare-metal) |
| 1× A100 80GB         | 80 GB | FP16 + 262K | 40–60 tok/s, contexto nativo completo | [bare metal](https://clore.ai/bare-metal) |
| 2× RTX 4090          | 48GB  | BF16 TP=2   | 60–80 tok/s, 262K ctx                 | $0.28–0.84/h                              |

{% hint style="success" %}
**La mejor relación calidad-precio, de lejos:** [1× RTX 4090 desde $0.14–0.42/h](https://clore.ai/rent-4090.html) ejecutando Q4 AWQ mediante Ollama o vLLM. Obtienes un modelo de programación de clase frontera en una sola tarjeta de consumo por menos del coste de una suscripción a Claude Pro al día.
{% endhint %}

***

## Casos de uso

* **Despliegues de producción con una sola GPU** — un contenedor en una sola 4090 de Clore.ai y tienes un asistente de programación real
* **Agentes de programación** — 77.2% SWE-Bench Verified (afirmado por el proveedor) lo coloca en la categoría de «útil para PRs autónomos»
* **RAG de contexto largo** — 262K nativos son suficientes para bases de código completas o semanas de registros de chat
* **Análisis de 1M tokens** — con YaRN, mete un libro entero o un registro de git de varios meses en un solo prompt
* **En local / aislado de red** — Apache 2.0 viene con el producto, sin dependencia de API
* **Fine-tuning en el borde** — el denso de 27B es compatible con LoRA/QLoRA en una sola tarjeta
* **Trabajador en agente-de-agentes** — empareja como trabajador con un planificador MoE más grande como [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md)

***

## Pruebas comparativas

{% hint style="warning" %}
**Afirmado por el proveedor — verifica de forma independiente.** Los números de abajo provienen de la publicación de lanzamiento de Alibaba del 21 de abril de 2026. Todavía están llegando reproducciones independientes (Aider, BigCodeBench, tablas de LiveCodeBench).
{% endhint %}

| Benchmark          | Qwen3.6-27B | Qwen3.5-35B | Gemma 3 27B | Llama 4 Scout |
| ------------------ | ----------- | ----------- | ----------- | ------------- |
| SWE-Bench Verified | **77.2%**   | \~71%       | \~58%       | \~54%         |
| HumanEval          | \~93%       | \~92%       | \~90%       | \~88%         |
| LiveCodeBench      | \~68%       | \~65%       | \~55%       | \~52%         |
| MMLU-Pro           | \~78%       | \~76%       | \~74%       | \~72%         |
| MATH               | \~87%       | \~85%       | \~78%       | \~76%         |

La cifra principal es **SWE-Bench Verified 77.2%** — eso coloca a un modelo denso de una sola GPU en un territorio antes reservado para sistemas MoE multi-GPU. Tómalo como una afirmación del proveedor hasta que los paneles de LMSYS / Aider lo confirmen.

***

## Solución de problemas

| Problema                                            | Solución                                                                                                                 |
| --------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| OOM en RTX 4090 (Q4)                                | Reduce `--max-model-len` a 32768; AWQ a 65K ctx está justo al límite de 24GB                                             |
| `qwen3.6:27b` no encontrado en Ollama               | Actualiza Ollama; la etiqueta llegó a finales de abril de 2026                                                           |
| Configuración YaRN rechazada por vLLM               | Requiere vLLM ≥ 0.7.x; pásalo mediante `--rope-scaling` JSON, no flags separados                                         |
| Llamadas a herramientas descartadas silenciosamente | Añade `--enable-auto-tool-choice --tool-call-parser hermes` en vLLM                                                      |
| Prefill lento en contexto largo                     | Añade `--enable-chunked-prefill` y reduce el tamaño del lote                                                             |
| OOM de caché KV a 262K                              | Baja a Q8 o pasa a L40S 48GB / A100 80GB                                                                                 |
| Calidad mala cerca de 1M ctx                        | YaRN extiende las posiciones, pero la calidad se degrada más allá de \~600K; mantén el contenido crítico cerca del final |

***

## Siguientes pasos

* **Predecesor:** [Qwen3.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen35.md) — Qwen3.6-27B es el sucesor denso; misma familia, programación más precisa, contexto nativo más largo
* **Hermano multimodal:** [Qwen3.5-Omni](/guides/guides_v2-es/modelos-de-lenguaje/qwen35-omni.md) — texto + audio + imagen + vídeo si necesitas más que texto
* **Clase densa de 27B similar:** [Gemma 3](/guides/guides_v2-es/modelos-de-lenguaje/gemma3.md) — competidor denso de 27B de Google, buena comparación de referencia
* **Alternativa MoE:** [Llama 4 Scout](/guides/guides_v2-es/modelos-de-lenguaje/llama4.md) — MoE de una sola GPU si quieres comparar arquitecturas
* **Salto a MoE de vanguardia:** [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) — cuando el denso de 27B no es suficiente y tienes presupuesto para varias GPU

### Enlaces

* [Qwen3.6-27B en HuggingFace](https://huggingface.co/Qwen/Qwen3.6-27B)
* [GitHub de Qwen](https://github.com/QwenLM/Qwen)
* [Blog de Qwen](https://qwenlm.github.io/)
* [documentación de vLLM](https://docs.vllm.ai)
* [repositorio SGLang](https://github.com/sgl-project/sglang)
* [Biblioteca de Ollama](https://ollama.com/library/qwen3.6)
* **Alquila una GPU:** [RTX 4090 desde $0.14–0.42/h](https://clore.ai/rent-4090.html) · [RTX 5090 32GB](https://clore.ai/rent-5090.html) · [Marketplace](https://clore.ai/marketplace)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/qwen36-27b.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
