> 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/ling-26-flash.md).

# Ling-2.6-flash (Ant Group 104B MoE)

{% hint style="info" %}
**Status (29. April 2026):** Ling-2.6-flash wurde von Ant Groups **inclusionAI** Team am **28. April 2026** veröffentlicht (zum Zeitpunkt des Schreibens vor einem Tag). Es ist das kleine, schnelle, für Agenten optimierte Geschwistermodell von [Ling-2.5-1T](/guides/guides_v2-de/sprachmodelle/ling25.md) — gleiche Abstammung, gleiche hybride lineare Attention-DNA, aber mit nur **7,4 Mrd. aktiven Parametern** von einem 104 Mrd. sparsamen MoE. Die Gewichte liegen unter [huggingface.co/inclusionAI/Ling-2.6-flash](https://huggingface.co/inclusionAI/Ling-2.6-flash) unter der **MIT-Lizenz**.
{% endhint %}

Während [Ling-2.5-1T](/guides/guides_v2-de/sprachmodelle/ling25.md) zum Booten noch ein Rack mit 8 GPUs benötigte, ist Ling-2.6-flash die **erste inclusionAI-Veröffentlichung, die auf eine einzige Consumer-GPU passt**. Der aktive Pfad mit 7,4 Mrd. bedeutet, dass Sie die Inferenzkosten eines dichten 8-Mrd.-Modells zahlen, während Sie auf einen Pool von 104 Mrd. Parametern zugreifen — und Ant Group hat diesen Pool speziell für **agentische Workflows**optimiert: Tool-Aufrufe, mehrstufige Planung und strukturierte Funktionsausführung.

Vom Anbieter veröffentlichte Zahlen setzen Ling-2.6-flash bei SOTA auf **BFCL-V4** und **TAU2-bench** für seine Größenklasse, mit einem Durchsatz von ungefähr **340 tok/s auf 4× H20** in der offiziellen Benchmark-Konfiguration. Für Clore.ai-Nutzer ist die interessantere Zahl deutlich kleiner: **INT4 passt bequem auf eine einzelne RTX 4090 (24 GB)** mit Reserve für einen 32K+-Kontext, und **FP8 passt auf eine einzelne H100 80 GB**. Damit steht ein frisch optimiertes Small-Model der Frontier-Klasse mit Agenten-Tuning bei etwa 0,70–2,50 $/Std. auf dem [Clore.ai-Marktplatz](https://clore.ai/marketplace).

### Wichtige Spezifikationen

| Eigenschaft            | Wert                                                        |
| ---------------------- | ----------------------------------------------------------- |
| Gesamtparameter        | 104 Mrd. (MoE)                                              |
| Aktive Parameter       | 7,4 Mrd. pro Forward-Pass                                   |
| Architektur            | 1:7 MLA + Lightning Linear Hybrid Attention                 |
| Kontextfenster         | 262.144 Tokens                                              |
| Quantisierungen        | BF16, FP8, INT4                                             |
| Lizenz                 | MIT                                                         |
| Veröffentlichungsdatum | 28. April 2026                                              |
| Organisation           | Ant Group — inclusionAI                                     |
| Primäres Tooling       | SGLang (empfohlen), vLLM, llama.cpp/Ollama (Community GGUF) |

### Warum Ling-2.6-flash?

* **Auf einer einzigen GPU einsetzbar** — INT4 auf einer einzelnen [RTX 4090](https://clore.ai/rent-4090.html) oder [RTX 3090](https://clore.ai/rent-3090.html), FP8 auf einer H100. Kein Multi-GPU-Drama, kein NVLink-Gefummel.
* **Für Agenten optimiert** — explizit für BFCL-V4 / TAU2-bench-artige Tool-Calling-Schleifen trainiert, nicht nur im Nachhinein darauf gebenchmarkt.
* **Sparse-MoE-Qualität bei 7,4 Mrd. aktivem Kostenaufwand** — Sie erhalten einen Wissenspool mit 104 Mrd. Parametern über einen Inferenzpfad mit 7,4 Mrd. Parametern.
* **256K Kontext direkt einsatzbereit** — 262K native Tokens, keine YaRN-Tricks für lange Agenten-Traces nötig.
* **MIT-Lizenz** — vollständig kommerziell, feinabstimmbar, weiterverteilbar.
* **Abstammung** — direkter Nachfolger von [Ling-2.5-1T](/guides/guides_v2-de/sprachmodelle/ling25.md) und Ring-2.5; die Architektur ist praxiserprobt.

***

## Anforderungen

{% hint style="success" %}
**Clore-freundlich.** Dies ist das erste Modell in der inclusionAI-Reihe, das auf einer einzelnen Consumer-GPU läuft. Wenn Sie sich [Ling-2.5-1T](/guides/guides_v2-de/sprachmodelle/ling25.md) oder [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md)nicht leisten konnten, ist dies der Einstiegspunkt.
{% endhint %}

| Komponente          | INT4 (eine einzelne 24 GB) | FP8 (eine einzelne 80 GB) | BF16 (volle Qualität)             |
| ------------------- | -------------------------- | ------------------------- | --------------------------------- |
| GPU-VRAM            | 1× RTX 4090 / 3090 (24 GB) | 1× H100 / A100 80 GB      | 2× A100 80 GB oder 1× H200 141 GB |
| RAM                 | 32GB                       | 64GB                      | 128GB                             |
| Datenträger         | 60GB NVMe                  | 120 GB NVMe               | 220 GB NVMe                       |
| CUDA                | 12.0+                      | 12.4+                     | 12.4+                             |
| Praktischer Kontext | 32K–64K                    | 128K                      | 256K                              |

**Clore.ai-Auswahl:** Für die meisten Agenten-Workloads ist eine einzelne [RTX 4090 (\~0,70–2,50 $/Std.)](https://clore.ai/rent-4090.html) mit einem INT4 GGUF unschlagbar im Preis. Steigen Sie auf eine einzelne H100 um, wenn Sie FP8-Qualität oder 128K+-Kontext benötigen.

***

## Option A — Ollama / GGUF (quantisiert, eine GPU)

Dies ist der Weg, den die meisten Clore.ai-Nutzer wählen werden. Community-GGUFs erscheinen in der Regel wenige Tage nach einer inclusionAI-Veröffentlichung auf HuggingFace.

{% hint style="warning" %}
**Hinweis zum ersten Tag:** Ling-2.6-flash erschien am 28. April 2026. Zum Zeitpunkt dieses Schreibens könnten die Community-Quantisierungen als GGUF noch unterwegs sein. Beobachten Sie [huggingface.co/models?search=ling-2.6-flash+gguf](https://huggingface.co/models?search=ling-2.6-flash+gguf) und [unsloth](https://huggingface.co/unsloth) für erste Builds. Wenn `ollama pull` 404 zurückgibt, verweisen Sie llama.cpp direkt auf die GGUF-Datei.
{% endhint %}

```bash
# Sobald ein Community-Q4_K_M-Build veröffentlicht wurde
docker exec ollama ollama pull ling-2.6-flash:q4_K_M
docker exec ollama ollama run ling-2.6-flash:q4_K_M

# Oder direkt mit llama.cpp auf einem heruntergeladenen GGUF
docker run --gpus all -it --rm -p 8080:8080 \
  -v $(pwd)/models:/models \
  ghcr.io/ggerganov/llama.cpp:server-cuda \
  -m /models/ling-2.6-flash-q4_k_m.gguf \
  --n-gpu-layers 99 --ctx-size 32768 \
  --port 8080 --host 0.0.0.0
```

Eine einzelne RTX 4090 sollte **\~80–120 tok/s** bei Q4\_K\_M mit 32K Kontext erreichen — mehr als genug für interaktive Agentenarbeit.

***

## Option B — vLLM (Produktions-API)

vLLM ist die bevorzugte Lösung, um Ling-2.6-flash für mehrere gleichzeitige Agenten bereitzustellen. Verwenden Sie den FP8-Checkpoint auf einer einzelnen H100 / A100 80 GB:

```yaml
version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model inclusionAI/Ling-2.6-flash-FP8
      --tensor-parallel-size 1
      --max-model-len 65536
      --gpu-memory-utilization 0.90
      --enable-auto-tool-choice
      --tool-call-parser hermes
      --served-model-name ling-2.6-flash
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    shm_size: "16gb"

volumes:
  hf_cache:
```

```bash
# Testen Sie den Agentenpfad
curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "ling-2.6-flash",
    "messages": [
      {"role": "system", "content": "You are an agent with access to tools. Plan, call tools, then answer."},
      {"role": "user", "content": "Find me the cheapest RTX 4090 on Clore.ai right now."}
    ],
    "tools": [{"type": "function", "function": {"name": "search_marketplace", "parameters": {"type":"object","properties":{"gpu":{"type":"string"}}}}}],
    "tool_choice": "auto",
    "max_tokens": 2048
  }'
```

{% hint style="info" %}
Für BF16 in voller Qualität bei langen Kontexten (200K+) erhöhen Sie `--tensor-parallel-size 2` auf 2× A100 80 GB oder legen Sie es auf eine einzelne H200 141 GB fest.
{% endhint %}

***

## Option C — SGLang (empfohlen für maximalen Durchsatz)

SGLang ist das, was Ant Group für den offiziellen 340 tok/s-Benchmark verwendet — der hybride lineare Attention-Pfad ist unter SGLangs Laufzeit am schnellsten.

```bash
docker pull lmsysorg/sglang:latest

python3 -m sglang.launch_server \
  --model-path inclusionAI/Ling-2.6-flash-FP8 \
  --tp-size 1 \
  --tool-call-parser hermes \
  --mem-fraction-static 0.90 \
  --context-length 65536 \
  --served-model-name ling-2.6-flash \
  --host 0.0.0.0 --port 30000

# Um die Herstellerzahl von 340 tok/s zu reproduzieren (erfordert 4× H20 / H100-Klasse)
python3 -m sglang.launch_server \
  --model-path inclusionAI/Ling-2.6-flash \
  --tp-size 4 \
  --mem-fraction-static 0.92 \
  --context-length 32768 \
  --served-model-name ling-2.6-flash
```

***

## Clore.ai GPU-Empfehlungen

| Setup                                                | VRAM  | Quant       | Erwarteter Durchsatz     | Clore.ai-Kosten        |
| ---------------------------------------------------- | ----- | ----------- | ------------------------ | ---------------------- |
| 1× [RTX 3090](https://clore.ai/rent-3090.html)       | 24GB  | INT4 GGUF   | \~60–90 tok/s            | **\~0,33–1,24 $/Std.** |
| 1× [RTX 4090](https://clore.ai/rent-4090.html)       | 24GB  | INT4 GGUF   | \~80–120 tok/s           | **\~0,70–2,50 $/Std.** |
| 1× [A100 80GB](https://clore.ai/rent-a100-80gb.html) | 80GB  | FP8         | \~120–180 tok/s          | \~2–4 $/Std.           |
| 1× H100 80 GB                                        | 80GB  | FP8         | \~150–220 tok/s          | \~6–8 $/Std.           |
| 4× H100 80GB                                         | 320GB | BF16 + TP=4 | \~340 tok/s (Hersteller) | \~24–32 $/Std.         |

{% hint style="success" %}
**Bestes Preis-Leistungs-Verhältnis:** Eine einzelne RTX 4090 ab 0,70 $/Std., die das Q4\_K\_M GGUF ausführt. Sie erhalten ein für Agenten optimiertes, MIT-lizenziertes 104B-MoE-Modell mit 32K Kontext für weniger als den Preis eines Kaffees pro Stunde. Genau für diese Bereitstellungsform wurde der Consumer-GPU-Marktplatz von Clore.ai gebaut.
{% endhint %}

***

## Anwendungsfälle

* **Tool-Calling-Agenten** — Das Tuning für BFCL-V4 und TAU2-bench bedeutet, dass strukturierte Funktionsaufrufe eine Stärke sind, kein nachträglicher Gedanke.
* **Mehrstufige Planungszyklen** — anhaltende Ketten von Tool-Call-Traces ohne das typische Abdriften kleiner Modelle.
* **Lokaler Ersatz für Claude Code / OpenHands** — drop-in OpenAI-kompatible API auf Ihrer eigenen RTX 4090.
* **Agentische Batch-Jobs mit hohem Volumen** — 340 tok/s auf 4× H100 machen dies praktikabel für die Verarbeitung von Tausenden Agenten-Transkripten pro Stunde.
* **RAG mit langem Kontext** — 256K nativer Kontext deckt die meisten Unternehmensdokumente in einer einzigen Eingabe ab.
* **Günstige Dev-Sandbox für** [**Ling-2.5-1T**](/guides/guides_v2-de/sprachmodelle/ling25.md) **Workflows** — Prototyping auf flash, Deployment auf der 1T-Variante.

***

## Benchmarks

{% hint style="warning" %}
**Vom Anbieter behauptet — unabhängig verifizieren.** Alle untenstehenden Zahlen stammen aus der Model Card von inclusionAI vom 28. April 2026. Das Modell ist einen Tag alt; Community-Reproduktionen auf BFCL-V4 und TAU2-bench wurden noch nicht veröffentlicht. Betrachten Sie diese Angaben als Richtwerte, nicht als Evangelium.
{% endhint %}

| Benchmark                     | Ling-2.6-flash (Hersteller) | Hinweise                                 |
| ----------------------------- | --------------------------- | ---------------------------------------- |
| BFCL-V4                       | SOTA für die Größenklasse   | Berkeley Function Calling Leaderboard v4 |
| TAU2-bench                    | SOTA für die Größenklasse   | Tool-Agent-Benchmark v2                  |
| SWE-bench Verified / Resolved | \~61.2%                     | Lösungsrate auf dem verifizierten Split  |
| MathArena AIME 2026           | 73.85                       |                                          |
| MathArena HMMT Feb 2026       | 49.29                       |                                          |
| Durchsatz                     | \~340 tok/s                 | 4× H20-3e, TP=4, Batch 32                |

***

## Fehlerbehebung

| Problem                                                | Lösung                                                                                                                                                                                                                                |
| ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` auf RTX 4090                        | Auf Q4\_K\_S oder Q3\_K\_M heruntergehen; `--ctx-size` auf 16384 reduzieren; andere GPU-Prozesse schließen                                                                                                                            |
| GGUF noch nicht auf HuggingFace                        | Das Modell ist einen Tag alt. Prüfen Sie [unsloth](https://huggingface.co/unsloth), [bartowski](https://huggingface.co/bartowski), und [TheBloke](https://huggingface.co/TheBloke) Mirrors; oder selbst von BF16 mit `llama-quantize` |
| vLLM lehnt die Architektur ab                          | Stellen Sie sicher, dass vLLM ≥ 0.7.x mit `--trust-remote-code`verwendet wird; die Schichten der hybriden linearen Attention sind benutzerdefiniert                                                                                   |
| Tool-Aufrufe werden in vLLM als Klartext zurückgegeben | Setze `--enable-auto-tool-choice --tool-call-parser hermes` SGLang handhabt dies automatisch                                                                                                                                          |
| Langsames Prefill bei langen Kontexten                 | Lineare Attention hat Warm-up-Overhead; die erste Anfrage ist immer die langsamste. Verwenden Sie `--enable-chunked-prefill` in vLLM                                                                                                  |
| Durchsatz deutlich unter 340 tok/s                     | Die Herstellerzahl basiert auf 4× H20 mit TP=4 und Batch 32. Single-GPU + Batch 1 ist naturgemäß deutlich langsamer — das ist zu erwarten, kein Fehler                                                                                |
| Verstümmelte Ausgabe bei hoher Temperatur              | Gehe runter auf `temperature=0.7` für Chat, `0.1` für Tool-Calling                                                                                                                                                                    |

***

## Nächste Schritte

* **Größeres Geschwistermodell:** [Ling-2.5-1T](/guides/guides_v2-de/sprachmodelle/ling25.md) — gleiche Familie, 1T gesamt / 63B aktiv, Frontier-Reasoning bei Multi-GPU-Kosten
* **Ähnlicher Single-GPU-Agent:** [MiMo-V2-Flash](/guides/guides_v2-de/sprachmodelle/mimo-v2-flash.md) — 309B/15B aktiv mit eingebautem spekulativem Decoding
* **Open-Weight-Coding-Alternative:** [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md) — 744B/40B aktiv, SWE-Bench-Pro-Führender
* **Günstige GPU-Mieten:** [RTX 4090 mieten ab 0,70 $/Std.](https://clore.ai/rent-4090.html) oder [RTX 3090 ab 0,33 $/Std.](https://clore.ai/rent-3090.html)
* **Clore.ai-Marktplatz:** [clore.ai/marketplace](https://clore.ai/marketplace) — vollständiger GPU-Katalog mit On-Demand- und Spot-Preisen

### Links

* [Ling-2.6-flash auf HuggingFace](https://huggingface.co/inclusionAI/Ling-2.6-flash)
* [inclusionAI-Organisation](https://huggingface.co/inclusionAI) — Open-Source-KI-Labor von Ant Group
* [SGLang-Repo](https://github.com/sgl-project/sglang) — empfohlenes Serving-Framework
* [vLLM-Dokumentation](https://docs.vllm.ai)
* [BFCL-V4-Leaderboard](https://gorilla.cs.berkeley.edu/leaderboard.html) — Berkeley Function Calling


---

# 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:

```
GET https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ling-26-flash.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.
