> 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)

Deploye Ling-2.6-flash (104B MoE, 7,4B aktiv) von Ant Group auf Clore.ai — das auf Agenten abgestimmte Flash-Geschwistermodell, das auf eine einzelne RTX 4090 passt

{% hint style="info" %}
**Status (29. April 2026):** Ling-2.6-flash wurde von Ant Group veröffentlicht **inclusionAI** Team am **28. April 2026** (zum Zeitpunkt des Schreibens vor einem Tag). Es ist das kleine, schnelle, auf Agenten feinabgestimmte Geschwistermodell von [Ling-2.5-1T](/guides/guides_v2-de/sprachmodelle/ling25.md) — gleiche Abstammung, gleiche hybride lineare Attention-DNA, aber nur mit **7,4B aktiven Parametern** von einem sparsamen 104B-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 %}

Wo [Ling-2.5-1T](/guides/guides_v2-de/sprachmodelle/ling25.md) ein 8-GPU-Rack brauchte, nur um überhaupt zu starten, ist Ling-2.6-flash das **erste inclusionAI-Release, das auf eine einzelne Consumer-GPU passt**. Der aktive Pfad mit 7,4B bedeutet, dass Sie die Inferenzkosten eines 8B-Dichtmodells zahlen, während Sie auf einen 104B-Parameter-Pool zugreifen — und Ant Group hat diesen Pool speziell für **agentische Workflows**: Tool-Aufrufe, mehrstufige Planung und strukturierte Funktionsaufrufe.

Vom Anbieter veröffentlichte Zahlen setzen Ling-2.6-flash für seine Größenklasse bei **BFCL-V4** und **TAU2-bench** an die Spitze, mit einem Durchsatz von etwa **340 tok/s auf 4× H20** in der offiziellen Benchmark-Konfiguration. Für Clore.ai-Nutzer ist die interessantere Zahl viel kleiner: **INT4 passt bequem auf eine einzelne RTX 4090 (24GB)** mit Spielraum für einen 32K+-Kontext, und **FP8 passt auf eine einzelne H100 80GB**. Das setzt ein frisch agentisch feinabgestimmtes Small Model der Frontier-Klasse zu rund \~1,04 $/h auf dem [Clore.ai-Marktplatz](https://clore.ai/marketplace).

### Wichtige Spezifikationen

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

### Warum Ling-2.6-flash?

* **Auf einer einzelnen 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 einzelnen H100. Kein Multi-GPU-Drama, kein NVLink-Gefrickel.
* **Auf Agenten feinabgestimmt** — ausdrücklich für BFCL-V4-/TAU2-bench-ähnliche Tool-Calling-Schleifen trainiert, nicht nur im Nachhinein darauf benchmarked.
* **Sparse-MoE-Qualität bei 7,4B aktiven Kosten** — Sie erhalten einen Wissenspool mit 104B Parametern über einen Inferenzpfad von 7,4B.
* **256K Kontext von Haus aus** — 262K native Tokens, keine YaRN-Tricks für lange Agenten-Traces nötig.
* **MIT-Lizenz** — vollständig kommerziell nutzbar, feinabstimmbar, weiterverteilbar.
* **Abstammung** — direkter Nachfahre von [Ling-2.5-1T](/guides/guides_v2-de/sprachmodelle/ling25.md) und Ring-2.5; die Architektur ist kampferprobt.

***

## Anforderungen

{% hint style="warning" %}
**Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet.** Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als [Bare Metal](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst.
{% endhint %}

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

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

**Clore.ai-Wahl:** Für die meisten Agenten-Workloads ist ein einzelnes [RTX 4090 ($0.14–0.42/Std.)](https://clore.ai/rent-4090.html) Das Betreiben eines INT4-GGUF ist preislich unschlagbar. Steigen Sie auf eine einzelne H100 um, wenn Sie FP8-Qualität oder 128K+-Kontext benötigen.

***

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

Dies ist der Pfad, den die meisten Clore.ai-Nutzer wollen. Community-GGUFs erscheinen auf HuggingFace typischerweise innerhalb weniger Tage nach einem inclusionAI-Release.

{% 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-Build Q4_K_M 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 mit llama.cpp direkt 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 einem 32K-Kontext erreichen — mehr als genug für interaktive Agentenarbeit.

***

## Option B — vLLM (Produktions-API)

vLLM ist die erste Wahl, um Ling-2.6-flash mehreren gleichzeitig laufenden Agenten bereitzustellen. Verwenden Sie den FP8-Checkpoint auf einer einzelnen H100 / A100 80GB:

```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
# Den Agentenpfad testen
curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "ling-2.6-flash",
    "messages": [
      {"role": "system", "content": "Du bist ein Agent mit Zugriff auf Tools. Plane, rufe Tools auf, antworte dann."},
      {"role": "user", "content": "Finde mir jetzt die günstigste RTX 4090 auf Clore.ai."}
    ],
    "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-volle Qualität bei langen Kontexten (200K+), skalieren Sie `--tensor-parallel-size 2` über 2× A100 80GB oder binden Sie es an eine einzelne H200 141GB.
{% 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 der Laufzeitumgebung von SGLang 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 vom Anbieter gemeldeten 340 tok/s zu reproduzieren (erfordert 4x 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
```

***

## GPU-Empfehlungen für Clore.ai

| Einrichtung                                          | VRAM   | Quant       | Erwarteter Durchsatz   | Clore.ai-Kosten                           |
| ---------------------------------------------------- | ------ | ----------- | ---------------------- | ----------------------------------------- |
| 1× [RTX 3090](https://clore.ai/rent-3090.html)       | 24 GB  | INT4 GGUF   | \~60–90 tok/s          | **ca. 0,07–0,21 $/h**                     |
| 1× [RTX 4090](https://clore.ai/rent-4090.html)       | 24 GB  | INT4 GGUF   | \~80–120 tok/s         | **ca. 0,14–0,42 $/h**                     |
| 1× [A100 80GB](https://clore.ai/rent-a100-80gb.html) | 80 GB  | FP8         | \~120–180 tok/s        | [Bare Metal](https://clore.ai/bare-metal) |
| 1× H100 80GB                                         | 80 GB  | FP8         | \~150–220 tok/s        | \~$1.04/hr                                |
| 4× H100 80 GB                                        | 320 GB | BF16 + TP=4 | \~340 tok/s (Anbieter) | \~$4,16/h                                 |

{% hint style="success" %}
**Bestes Preis-Leistungs-Verhältnis:** Eine einzelne RTX 4090 für 0,14–0,42 $/h, die den Q4\_K\_M-GGUF ausführt. Sie erhalten ein auf Agenten feinabgestimmtes, 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

* **Agenten mit Tool-Aufrufen** — das Tuning für BFCL-V4 und TAU2-bench bedeutet, dass strukturierte Funktionsaufrufe eine Stärke sind, kein Nebengedanke.
* **Mehrstufige Planungs-Schleifen** — anhaltende Chain-of-Tool-Call-Traces ohne das für kleine Modelle typische Abdriften.
* **Lokaler Ersatz für Claude Code / OpenHands** — direkt einsetzbare OpenAI-kompatible API auf Ihrer eigenen RTX 4090.
* **Agentische Batch-Jobs mit hohem Volumen** — 340 tok/s auf 4×H100 machen dies praktikabel, um Tausende von Agenten-Transkripten pro Stunde zu verarbeiten.
* **RAG mit langem Kontext** — 256K nativer Kontext deckt die meisten Unternehmensdokument-Sets in einer einzigen Eingabe ab.
* **Günstige Dev-Sandbox für** [**Ling-2.5-1T**](/guides/guides_v2-de/sprachmodelle/ling25.md) **Workflows** — prototypisieren Sie auf Flash, deployen Sie auf der 1T-Variante.

***

## Benchmarks

{% hint style="warning" %}
**Vom Anbieter behauptet — unabhängig prüfen.** Alle untenstehenden Zahlen stammen aus der Modellkarte 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 Werte als Richtwerte, nicht als absolute Wahrheit.
{% endhint %}

| Benchmark                     | Ling-2.6-flash (Anbieter)     | Hinweise                                 |
| ----------------------------- | ----------------------------- | ---------------------------------------- |
| BFCL-V4                       | Spitze in seiner Größenklasse | Berkeley Function Calling Leaderboard v4 |
| TAU2-bench                    | Spitze in seiner 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 einer RTX 4090                  | Auf Q4\_K\_S oder Q3\_K\_M heruntergehen; reduzieren `--ctx-size` auf 16384; andere GPU-Prozesse schließen                                                                                                                                       |
| GGUF noch nicht auf HuggingFace                        | 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 quantisieren Sie aus BF16 selbst mit `llama-quantize` |
| vLLM lehnt die Architektur ab                          | Stellen Sie sicher, dass vLLM ≥ 0.7.x mit `--trust-remote-code`; die hybriden linearen Attention-Layer sind benutzerdefiniert                                                                                                                    |
| Tool-Aufrufe werden in vLLM als Klartext zurückgegeben | Setze `--enable-auto-tool-choice --tool-call-parser hermes` ; SGLang handhabt das 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 Anbieterzahl basiert auf 4× H20 mit TP=4 und Batch 32. Single-GPU + Batch 1 ist naturgemäß viel langsamer — das ist zu erwarten, kein Fehler                                                                                                 |
| Verwürfelte Ausgabe bei hoher Temperatur               | Reduziere auf `temperature=0.7` für Chat, `0.1` für Tool-Aufrufe                                                                                                                                                                                 |

***

## Nächste Schritte

* **Größeres Geschwistermodell:** [Ling-2.5-1T](/guides/guides_v2-de/sprachmodelle/ling25.md) — gleiche Familie, insgesamt 1T / 63B aktiv, Frontier-Reasoning zu Multi-GPU-Kosten
* **Ähnlicher Agent mit nur einer GPU:** [MiMo-V2-Flash](/guides/guides_v2-de/sprachmodelle/mimo-v2-flash.md) — 309B/15B aktiv mit integriertem spekulativem Decoding
* **Open-Weight-Coding-Alternative:** [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md) — 744B/40B aktiv, Spitzenreiter auf SWE-Bench Pro
* **Günstige GPU-Mieten:** [RTX 4090 mieten ab 0,14–0,42 $/h](https://clore.ai/rent-4090.html) oder [RTX 3090 ab 0,07–0,21 $/h](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) — das 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-Rangliste](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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ling-26-flash.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.
