> 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-de/sprachmodelle/qwen36-27b.md).

# Qwen3.6-27B (dicht, Single-GPU)

Deploye Qwen3.6-27B von Alibaba auf Clore.ai — ein dichtes 27B-Modell, das auf eine einzelne RTX 4090 passt und mit 262K nativer Kontextlänge geliefert wird

{% hint style="info" %}
**Status (April 2026):** Qwen3.6-27B wurde von Alibaba am **21. April 2026** unter der **Apache 2.0** Lizenz veröffentlicht. Die Gewichte liegen unter [huggingface.co/Qwen/Qwen3.6-27B](https://huggingface.co/Qwen/Qwen3.6-27B). Es ist ein **dichtes** 27B-Modell — kein MoE — mit einem **nativen Kontext von 262K Token** der sich erweitert auf **1M Token mit YaRN**, und Unterstützung ab Tag 0 für vLLM, SGLang und Ollama.
{% endhint %}

Die MoE-Riesen von 2026 — DeepSeek V4, GLM-5.1, MiMo-V2.5-Pro — sind auf Benchmarks spannend, aber in der Praxis gnadenlos: Hunderte GB an Gewichten, Multi-GPU-Racks, fragile Expert-Routing-Kernels und Inferenzrechnungen, bei denen Finanzteams zusammenzucken. Qwen3.6-27B geht den anderen Weg. Es ist **dichtes**, jeder Parameter wird bei jedem Token aktiviert, der VRAM ist bis auf das Gigabyte vorhersehbar, und es gibt keine Überraschung beim Expert-Routing, wenn man über 8K Kontext hinausgeht.

Für die meisten Teams lautet die Frage nicht „können wir ein 744B-MoE bereitstellen“ — sondern „können wir eine gute Karte in unseren Cluster stecken und darauf einen Coding-Assistenten der Frontier-Klasse betreiben?“ Qwen3.6-27B ist genau dafür gebaut. Q4 passt auf eine einzelne **RTX 4090 24GB**, Q8 passt auf eine einzelne **RTX 5090 32 GB**, BF16 passt auf eine einzelne **L40S 48GB** oder **A100 40GB**, und Alibaba veröffentlicht **77,2 % auf SWE-Bench Verified** (vom Anbieter behauptet). Eine Karte, ein Container, ein Modell.

### Wichtige Spezifikationen

| Eigenschaft            | Wert                             |
| ---------------------- | -------------------------------- |
| Parameter              | 27B (dicht)                      |
| Architektur            | Dichter Decoder-only-Transformer |
| Nativer Kontext        | 262.144 Token                    |
| Erweiterter Kontext    | 1.000.000 Token (YaRN)           |
| Lizenz                 | Apache 2.0                       |
| Veröffentlichungsdatum | 21. April 2026                   |
| Organisation           | Alibaba (Qwen-Team)              |
| Primäre Tools          | vLLM, SGLang, Ollama, llama.cpp  |

### Warum Qwen3.6-27B?

* **Wirtschaftlichkeit mit einer einzelnen GPU** — Q4 auf RTX 4090 ab **ca. 0,14–0,42 $/h** auf Clore.ai; keine Tensor-Parallel-Orchestrierung, die man debuggen muss
* **Dicht, nicht MoE** — fester VRAM, kein Hotspotting der Experten, keine Latenzspitzen bei bestimmten Prompts
* **Apache 2.0** — vollständig kommerziell, feinabstimmbar, weiterverteilbar, keine Nutzungslimits
* **262K nativer Kontext, 1M mit YaRN** — komplette Codebasen, ganze Bücher, Stunden von Transkripten in einem Durchlauf
* **Tag-0 vLLM / SGLang / Ollama** — wählen Sie Ihren Serving-Stack; Qwen lieferte bei Veröffentlichung Konfigurationen für alle drei
* **77,2 % SWE-Bench Verified** (vom Anbieter behauptet) — konkurrenzfähig mit viel größeren MoE-Modellen bei echten Coding-Aufgaben

***

## Anforderungen

{% hint style="success" %}
**Der ganze Punkt ist, dass dieses Modell nachsichtig ist.** Eine einzelne RTX 4090 aus dem Clore.ai-Marktplatz reicht aus, um Qwen3.6-27B in produktionsreifer Qualität (Q4) oder mit „gut genug für die meisten Anwendungsfälle“-Geschwindigkeit zu betreiben. Kein Multi-GPU-Kopfzerbrechen.
{% endhint %}

| Komponente       | Q4 (GGUF / AWQ)  | Q8 (GGUF / GPTQ) | BF16                           | Volles FP16                   |
| ---------------- | ---------------- | ---------------- | ------------------------------ | ----------------------------- |
| GPU              | 1× RTX 4090 24GB | 1× RTX 5090 32GB | 1× L40S 48GB oder 1× A100 40GB | 1× A100 80GB                  |
| Verwendeter VRAM | \~16–18 GB       | \~28–30 GB       | \~54 GB                        | \~54 GB + Puffer für KV-Cache |
| RAM              | 32 GB            | 32 GB            | 64 GB                          | 96GB                          |
| Festplatte       | 20 GB NVMe       | 32 GB NVMe       | 60 GB NVMe                     | 60 GB NVMe                    |
| CUDA             | 12.8+            | 12.8+            | 12.8+                          | 12.8+                         |

**Clore.ai-Wahl:** Für 90 % der Teams ist eine einzelne **RTX 4090 24GB** die Q4 ausführt (AWQ oder GGUF), die richtige Antwort. Sie erhalten Coding auf Frontier-Niveau zum Preis von ein paar Kaffees pro Tag. Steigen Sie auf RTX 5090 32GB um, wenn Sie Q8 für etwas bessere Qualität wollen, oder auf L40S / A100 40GB für vollständige BF16-Produktionsinferenz.

***

## Option A — Ollama (quantisiert, am einfachsten)

Ollama ist der schnellste Weg von „Ich habe eine Clore.ai-GPU“ zu „Ich habe einen Chat-Endpunkt“.

```bash
# Qwen3.6-27B ziehen (standardmäßig Q4_K_M, ~17 GB Download)
ollama pull qwen3.6:27b

# Interaktiv ausführen
ollama run qwen3.6:27b

# Oder die OpenAI-kompatible API bereitstellen
ollama serve &

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "qwen3.6:27b",
    "messages": [
      {"role": "system", "content": "Du bist ein Senior-Go-Ingenieur."},
      {"role": "user", "content": "Refaktoriere diesen Handler, damit er context.Context korrekt verwendet, und füge Wiederholungsversuche mit exponentiellem Backoff hinzu."}
    ],
    "temperature": 0.6
  }'
```

{% hint style="info" %}
Der Standard- `qwen3.6:27b` Tag in Ollama entspricht Q4\_K\_M. Verwenden Sie `qwen3.6:27b-q8_0` für Q8, wenn Sie eine RTX 5090 haben, oder `qwen3.6:27b-fp16` für volle Präzision (benötigt eine A100 80GB).
{% endhint %}

***

## Option B — vLLM (Produktion)

vLLM ist der empfohlene Produktionsserver. Die unten stehende Single-GPU-Konfiguration zielt auf eine RTX 4090 mit AWQ-Quantisierung ab. Der Multi-GPU-Abschnitt ist der Vollständigkeit halber da — aber bei einem 27B-Dichtmodell braucht man ihn fast nie.

```yaml
# docker-compose.yml — einzelne 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
# API testen
curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "qwen3.6:27b",
    "messages": [
      {"role": "user", "content": "Erkläre den Unterschied zwischen MoE- und dichten Modellen in 3 Stichpunkten."}
    ],
    "max_tokens": 512,
    "temperature": 0.7
  }'
```

Für volles **BF16** auf einer einzelnen L40S 48GB oder A100 40GB, entfernen Sie `--quantization awq` und verweisen Sie auf den Basis-Checkpoint (`Qwen/Qwen3.6-27B-Instruct`, `--dtype bfloat16`, `--max-model-len 131072`). Für 2× RTX 4090 mit Tensor-Parallelismus (längerer Kontext, größerer KV-Cache) fügen Sie `--tensor-parallel-size 2`.

***

## Option C — SGLang

SGLang glänzt, wenn Sie mit YaRN über das native 262K-Fenster hinausgehen. Übergeben Sie `--rope-scaling` um auf \~1M Token zu erweitern.

```bash
docker pull lmsysorg/sglang:latest

# Einzelne GPU, nativer 262K-Kontext
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

# Mit YaRN auf 1M Token erweitert (benötigt mehr VRAM-Puffer)
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" %}
**Die Kosten für 1M Kontext steigen schnell.** Selbst mit YaRN liegt der KV-Cache für 1M Token bei BF16 ungefähr bei **40–60 GB** je nach Batchgröße. Planen Sie mit einer A100 80GB oder H100, wenn Sie das Fenster tatsächlich voll ausnutzen wollen.
{% endhint %}

***

## GPU-Empfehlungen für Clore.ai

| Einrichtung          | VRAM  | Modus       | Erwartete Leistung                    | Clore.ai-Kosten                           |
| -------------------- | ----- | ----------- | ------------------------------------- | ----------------------------------------- |
| **1× RTX 4090 24GB** | 24 GB | Q4 AWQ      | 50–80 Token/s, 64K ctx                | **ca. 0,14–0,42 $/h**                     |
| 1× RTX 5090 32GB     | 32 GB | Q8 GPTQ     | 60–90 Token/s, 96K ctx                | 0,25–0,77 $/Std.                          |
| 1× L40S 48GB         | 48GB  | BF16        | 35–55 Token/s, 131K ctx               | \~0,50 $/Std.                             |
| 1× A100 40GB         | 40 GB | BF16        | 40–60 Token/s, 96K ctx                | [Bare Metal](https://clore.ai/bare-metal) |
| 1× A100 80GB         | 80 GB | FP16 + 262K | 40–60 Token/s, voller nativer Kontext | [Bare Metal](https://clore.ai/bare-metal) |
| 2× RTX 4090          | 48GB  | BF16 TP=2   | 60–80 Token/s, 262K ctx               | $0.28–0.84/Std.                           |

{% hint style="success" %}
**Mit Abstand das beste Preis-Leistungs-Verhältnis:** [1× RTX 4090 ab 0,14–0,42 $/Std.](https://clore.ai/rent-4090.html) Q4 AWQ über Ollama oder vLLM ausführen. Sie erhalten ein Coding-Modell der Frontier-Klasse auf einer einzelnen Consumer-Karte für weniger als die Kosten eines Claude-Pro-Abonnements pro Tag.
{% endhint %}

***

## Anwendungsfälle

* **Produktive Single-GPU-Deployments** — ein Container auf einer einzigen Clore.ai 4090 und Sie haben einen echten Coding-Assistenten
* **Coding-Agenten** — 77,2 % SWE-Bench Verified (vom Anbieter behauptet) ordnet es in die Kategorie „nützlich für autonome PRs“ ein
* **RAG mit langem Kontext** — 262K nativ reichen für ganze Codebasen oder wochenlange Chat-Logs
* **Analyse mit 1M Token** — mit YaRN können Sie ein ganzes Buch oder ein mehrmonatiges Git-Log in einen einzigen Prompt packen
* **On-Prem / luftgekappt** — Apache 2.0 wird mit dem Produkt ausgeliefert, keine API-Abhängigkeit
* **Feinabstimmung am Edge** — 27B dicht ist freundlich zu LoRA/QLoRA auf einer einzelnen Karte
* **Worker in Agenten-der-Agenten** — als Worker mit einem größeren MoE-Planer koppeln wie [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md)

***

## Benchmarks

{% hint style="warning" %}
**Vom Anbieter behauptet — unabhängig prüfen.** Die untenstehenden Zahlen stammen aus Alibabas Release-Post vom 21. April 2026. Unabhängige Reproduktionen (Aider-, BigCodeBench-, LiveCodeBench-Ranglisten) laufen noch ein.
{% 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%         |

Die Schlagzeilenzahl ist **SWE-Bench Verified 77,2 %** — das bringt ein dichtes Einzel-GPU-Modell in einen Bereich, der bisher Multi-GPU-MoE-Systemen vorbehalten war. Betrachten Sie das als Anbieterbehauptung, bis LMSYS-/Aider-Boards es bestätigen.

***

## Fehlerbehebung

| Problem                                | Lösung                                                                                                                    |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| OOM auf RTX 4090 (Q4)                  | Niedriger `--max-model-len` auf 32768; AWQ bei 65K Kontext liegt genau am Rand von 24 GB                                  |
| `qwen3.6:27b` nicht in Ollama gefunden | Aktualisieren Sie Ollama; das Tag kam erst Ende April 2026                                                                |
| YaRN-Konfiguration von vLLM abgelehnt  | Erfordert vLLM ≥ 0.7.x; übergeben via `--rope-scaling` JSON, nicht als separate Flags                                     |
| Tool-Calls stillschweigend verworfen   | Fügen Sie `--enable-auto-tool-choice --tool-call-parser hermes` in vLLM                                                   |
| Langsames Prefill bei langem Kontext   | Fügen Sie `--enable-chunked-prefill` und Batchgröße reduzieren                                                            |
| KV-Cache-OOM bei 262K                  | Auf Q8 heruntergehen oder zu L40S 48GB / A100 80GB wechseln                                                               |
| Schlechte Qualität nahe 1M Kontext     | YaRN erweitert die Positionen, aber die Qualität nimmt jenseits von \~600K ab; halten Sie kritische Inhalte nahe dem Ende |

***

## Nächste Schritte

* **Vorgänger:** [Qwen3.5](/guides/guides_v2-de/sprachmodelle/qwen35.md) — Qwen3.6-27B ist der dichte Nachfolger; gleiche Familie, schärferes Coding, längerer nativer Kontext
* **Multimodaler Verwandter:** [Qwen3.5-Omni](/guides/guides_v2-de/sprachmodelle/qwen35-omni.md) — Text + Audio + Bild + Video, wenn Sie mehr als Text brauchen
* **Ähnliche dichte 27B-Klasse:** [Gemma 3](/guides/guides_v2-de/sprachmodelle/gemma3.md) — Googles 27B-dichter Konkurrent, guter Basisvergleich
* **MoE-Alternative:** [Llama 4 Scout](/guides/guides_v2-de/sprachmodelle/llama4.md) — Single-GPU-MoE, wenn Sie Architekturen vergleichen möchten
* **Frontier-MoE-Aufstieg:** [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md) — wenn 27B dicht nicht ausreicht und Sie ein Multi-GPU-Budget haben

### Links

* [Qwen3.6-27B auf HuggingFace](https://huggingface.co/Qwen/Qwen3.6-27B)
* [Qwen GitHub](https://github.com/QwenLM/Qwen)
* [Qwen-Blog](https://qwenlm.github.io/)
* [vLLM-Dokumentation](https://docs.vllm.ai)
* [SGLang-Repo](https://github.com/sgl-project/sglang)
* [Ollama-Bibliothek](https://ollama.com/library/qwen3.6)
* **Eine GPU mieten:** [RTX 4090 ab 0,14–0,42 $/Std.](https://clore.ai/rent-4090.html) · [RTX 5090 32 GB](https://clore.ai/rent-5090.html) · [Marktplatz](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-de/sprachmodelle/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.
