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

{% hint style="info" %}
**Estado (29 de abril de 2026):** Ling-2.6-flash fue lanzado por el grupo Ant **inclusionAI** equipo el **28 de abril de 2026** (hace un día al momento de escribir esto). Es el hermano pequeño, rápido y ajustado para agentes de [Ling-2.5-1T](/guides/guides_v2-es/modelos-de-lenguaje/ling25.md) — misma línea, mismo ADN de atención lineal híbrida, pero con solo **7,4B parámetros activos** de un MoE disperso de 104B. Los pesos están en [huggingface.co/inclusionAI/Ling-2.6-flash](https://huggingface.co/inclusionAI/Ling-2.6-flash) bajo la **licencia MIT**.
{% endhint %}

Donde [Ling-2.5-1T](/guides/guides_v2-es/modelos-de-lenguaje/ling25.md) necesitaba un rack de 8 GPU solo para arrancar, Ling-2.6-flash es la **primera versión de inclusionAI que cabe en una sola GPU de consumo**. La ruta activa de 7,4B significa que pagas el costo de inferencia de un modelo denso de 8B mientras aprovechas un conjunto de 104B parámetros — y Ant Group ha ajustado ese conjunto específicamente para **flujos de trabajo agenticos**: llamada de herramientas, planificación de varios pasos y despacho estructurado de funciones.

Las cifras publicadas por el proveedor sitúan a Ling-2.6-flash en SOTA en **BFCL-V4** y **TAU2-bench** para su clase de tamaño, con un rendimiento de aproximadamente **340 tok/s en 4× H20** en la configuración oficial del benchmark. Para los usuarios de Clore.ai, la línea más interesante es mucho más pequeña: **INT4 cabe cómodamente en una sola RTX 4090 (24GB)** con margen para un contexto de 32K+, y **FP8 cabe en una sola H100 de 80GB**. Eso sitúa a un modelo pequeño de clase frontera, recién ajustado para agentes, en aproximadamente $0.70–2.50/h en el [mercado de Clore.ai](https://clore.ai/marketplace).

### Especificaciones clave

| Propiedad                | Valor                                                               |
| ------------------------ | ------------------------------------------------------------------- |
| Parámetros totales       | 104B (MoE)                                                          |
| Parámetros activos       | 7,4B por pasada hacia adelante                                      |
| Arquitectura             | atención híbrida 1:7 MLA + Lightning Linear                         |
| Ventana de contexto      | 262.144 tokens                                                      |
| Cuantizaciones           | BF16, FP8, INT4                                                     |
| Licencia                 | MIT                                                                 |
| Fecha de lanzamiento     | 28 de abril de 2026                                                 |
| Organización             | Ant Group — inclusionAI                                             |
| Herramientas principales | SGLang (recomendado), vLLM, llama.cpp/Ollama (GGUF de la comunidad) |

### ¿Por qué Ling-2.6-flash?

* **Desplegable en una sola GPU** — INT4 en una sola [RTX 4090](https://clore.ai/rent-4090.html) o [RTX 3090](https://clore.ai/rent-3090.html), FP8 en una sola H100. Sin drama de múltiples GPUs, sin lidiar con NVLink.
* **Ajustado para agentes** — entrenado explícitamente para bucles de llamada de herramientas al estilo BFCL-V4 / TAU2-bench, no solo evaluado sobre ellos a posteriori.
* **Calidad MoE dispersa con costo activo de 7,4B** — obtienes un conjunto de conocimiento de 104B parámetros mediante una ruta de inferencia de 7,4B.
* **Contexto de 256K desde el primer momento** — 262K tokens nativos, sin necesidad de trucos YaRN para trazas largas de agente.
* **licencia MIT** — totalmente comercial, afinable y redistribuible.
* **Linaje** — descendiente directo de [Ling-2.5-1T](/guides/guides_v2-es/modelos-de-lenguaje/ling25.md) y Ring-2.5; la arquitectura está probada en combate.

***

## Requisitos

{% hint style="success" %}
**Compatible con Clore.** Este es el primer modelo de la línea inclusionAI que funciona en una sola GPU de consumo. Si has quedado fuera del alcance de [Ling-2.5-1T](/guides/guides_v2-es/modelos-de-lenguaje/ling25.md) o [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md), este es el punto de entrada.
{% endhint %}

| Componente        | INT4 (una sola 24GB)      | FP8 (una sola 80GB) | BF16 (calidad completa)      |
| ----------------- | ------------------------- | ------------------- | ---------------------------- |
| VRAM de GPU       | 1× RTX 4090 / 3090 (24GB) | 1× H100 / A100 80GB | 2× A100 80GB o 1× H200 141GB |
| RAM               | 32GB                      | 64GB                | 128GB                        |
| Disco             | 60 GB NVMe                | 120GB NVMe          | 220GB NVMe                   |
| CUDA              | 12.0+                     | 12.4+               | 12.4+                        |
| Contexto práctico | 32K–64K                   | 128K                | 256K                         |

**Elección de Clore.ai:** Para la mayoría de las cargas de trabajo de agentes, una sola [RTX 4090 (\~$0.70–2.50/h)](https://clore.ai/rent-4090.html) ejecutando un GGUF INT4 es insuperable en precio. Sube a una sola H100 si necesitas calidad FP8 o un contexto de 128K+.

***

## Opción A — Ollama / GGUF (cuantizado, una sola GPU)

Esta es la ruta que querrán la mayoría de los usuarios de Clore.ai. Los GGUF de la comunidad suelen aparecer en HuggingFace pocos días después de una versión de inclusionAI.

{% hint style="warning" %}
**Aviso del primer día:** Ling-2.6-flash salió el 28 de abril de 2026. Al momento de escribir esto, las cuantizaciones comunitarias GGUF pueden seguir llegando. Vigila [huggingface.co/models?search=ling-2.6-flash+gguf](https://huggingface.co/models?search=ling-2.6-flash+gguf) y [unsloth](https://huggingface.co/unsloth) para las primeras compilaciones. Si `ollama pull` devuelve 404, apunta llama.cpp directamente al archivo GGUF.
{% endhint %}

```bash
# Una vez que se publique una compilación comunitaria Q4_K_M
docker exec ollama ollama pull ling-2.6-flash:q4_K_M
docker exec ollama ollama run ling-2.6-flash:q4_K_M

# O con llama.cpp directamente sobre un GGUF descargado
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
```

Una sola RTX 4090 debería alcanzar **\~80–120 tok/s** en Q4\_K\_M con un contexto de 32K — más que suficiente para trabajo interactivo de agente.

***

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

vLLM es lo ideal para servir Ling-2.6-flash a varios agentes concurrentes. Usa el checkpoint FP8 en una sola H100 / A100 de 80GB:

```yaml
version: "3.8"
servicios:
  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
# Probar la ruta de agente
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ling-2.6-flash",
    "messages": [
      {"role": "system", "content": "Eres un agente con acceso a herramientas. Planifica, llama a herramientas y luego responde."},
      {"role": "user", "content": "Encuéntrame ahora mismo la RTX 4090 más barata en 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" %}
Para calidad completa BF16 en contextos largos (200K+), escala `--tensor-parallel-size 2` a través de 2× A100 80GB o fija en una sola H200 de 141GB.
{% endhint %}

***

## Opción C — SGLang (recomendado para máximo rendimiento)

SGLang es lo que usa Ant Group para el benchmark oficial de 340 tok/s — la ruta de atención lineal híbrida es la más rápida bajo el runtime de SGLang.

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

# Para reproducir la cifra del proveedor de 340 tok/s (requiere 4x H20 / clase H100)
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
```

***

## Recomendaciones de GPU de Clore.ai

| Configuración                                        | VRAM  | Cuant       | Rendimiento esperado    | Coste en Clore.ai   |
| ---------------------------------------------------- | ----- | ----------- | ----------------------- | ------------------- |
| 1× [RTX 3090](https://clore.ai/rent-3090.html)       | 24GB  | GGUF INT4   | \~60–90 tok/s           | **\~$0.33–1.24/h**  |
| 1× [RTX 4090](https://clore.ai/rent-4090.html)       | 24GB  | GGUF INT4   | \~80–120 tok/s          | **\~0,70–2,50 $/h** |
| 1× [A100 80GB](https://clore.ai/rent-a100-80gb.html) | 80GB  | FP8         | \~120–180 tok/s         | \~$2–4/h            |
| 1× H100 80GB                                         | 80GB  | FP8         | \~150–220 tok/s         | \~$6–8/h            |
| 4× H100 80GB                                         | 320GB | BF16 + TP=4 | \~340 tok/s (proveedor) | \~$24–32/h          |

{% hint style="success" %}
**Mejor valor:** Una sola RTX 4090 desde $0.70/h ejecutando el GGUF Q4\_K\_M. Obtienes un modelo MoE de 104B, con licencia MIT y ajustado para agentes, con contexto de 32K por menos que el precio de un café por hora. Esta es exactamente la forma de despliegue para la que fue creado el mercado de GPUs de consumo de Clore.ai.
{% endhint %}

***

## Casos de uso

* **Agentes de llamada de herramientas** — el ajuste de BFCL-V4 y TAU2-bench significa que el despacho estructurado de funciones es una fortaleza, no una ocurrencia tardía.
* **Bucles de planificación de varios pasos** — trazas sostenidas de cadena de llamadas a herramientas sin la deriva típica de los modelos pequeños.
* **Reemplazo local de Claude Code / OpenHands** — API compatible con OpenAI lista para usar en tu propia RTX 4090.
* **Trabajos por lotes agenticos de gran volumen** — 340 tok/s en 4×H100 hace que esto sea viable para procesar miles de transcripciones de agentes por hora.
* **RAG de contexto largo** — 256K de contexto nativo cubre la mayoría de los conjuntos de documentos empresariales en un solo prompt.
* **Entorno de pruebas barato para desarrollo de** [**Ling-2.5-1T**](/guides/guides_v2-es/modelos-de-lenguaje/ling25.md) **flujos de trabajo** — prototipa en flash, despliega en la variante 1T.

***

## Benchmarks

{% hint style="warning" %}
**Afirmado por el proveedor — verificar de forma independiente.** Todas las cifras siguientes provienen de la ficha del modelo de inclusionAI del 28 de abril de 2026. El modelo tiene un día; aún no se han publicado reproducciones comunitarias en BFCL-V4 ni TAU2-bench. Tómalas como orientativas, no como verdad absoluta.
{% endhint %}

| Benchmark                     | Ling-2.6-flash (proveedor)   | Notas                                       |
| ----------------------------- | ---------------------------- | ------------------------------------------- |
| BFCL-V4                       | SOTA para la clase de tamaño | Berkeley Function Calling Leaderboard v4    |
| TAU2-bench                    | SOTA para la clase de tamaño | Benchmark de agente de herramientas v2      |
| SWE-bench Verified / Resolved | \~61.2%                      | Tasa de resueltas en el conjunto verificado |
| MathArena AIME 2026           | 73.85                        |                                             |
| MathArena HMMT Feb 2026       | 49.29                        |                                             |
| Rendimiento                   | \~340 tok/s                  | 4× H20-3e, TP=4, lote 32                    |

***

## Solución de problemas

| Problema                                                    | Solución                                                                                                                                                                                                                            |
| ----------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` en RTX 4090                              | Baja a Q4\_K\_S o Q3\_K\_M; reduce `--ctx-size` a 16384; cierra otros procesos de GPU                                                                                                                                               |
| GGUF aún no en HuggingFace                                  | El modelo tiene un día. Revisa [unsloth](https://huggingface.co/unsloth), [bartowski](https://huggingface.co/bartowski), y [TheBloke](https://huggingface.co/TheBloke) espejos; o cuantiza desde BF16 tú mismo con `llama-quantize` |
| vLLM rechaza la arquitectura                                | Asegúrate de tener vLLM ≥ 0.7.x con `--trust-remote-code`; las capas de atención lineal híbrida son personalizadas                                                                                                                  |
| Las llamadas a herramientas se devolvieron como texto plano | Configura `--enable-auto-tool-choice --tool-call-parser hermes` en vLLM; SGLang lo maneja automáticamente                                                                                                                           |
| Prefill lento en contextos largos                           | La atención lineal tiene sobrecarga de calentamiento; la primera solicitud siempre es la más lenta. Usa `--enable-chunked-prefill` en vLLM                                                                                          |
| Rendimiento muy por debajo de 340 tok/s                     | La cifra del proveedor es 4× H20 con TP=4 y lote 32. Una sola GPU + lote 1 es naturalmente mucho más lenta — eso es lo esperado, no un error                                                                                        |
| Salida corrupta a temperatura alta                          | Reduce a `temperature=0.7` para chat, `0.1` para llamada de herramientas                                                                                                                                                            |

***

## Siguientes pasos

* **Hermano mayor:** [Ling-2.5-1T](/guides/guides_v2-es/modelos-de-lenguaje/ling25.md) — misma familia, 1T total / 63B activos, razonamiento de frontera con costo de múltiples GPUs
* **Agente similar de una sola GPU:** [MiMo-V2-Flash](/guides/guides_v2-es/modelos-de-lenguaje/mimo-v2-flash.md) — 309B/15B activos con decodificación especulativa integrada
* **Alternativa de código de pesos abiertos:** [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) — 744B/40B activos, líder de SWE-Bench Pro
* **Alquileres de GPU baratos:** [Alquila RTX 4090 desde $0.70/h](https://clore.ai/rent-4090.html) o [RTX 3090 desde $0.33/h](https://clore.ai/rent-3090.html)
* **Mercado de Clore.ai:** [clore.ai/marketplace](https://clore.ai/marketplace) — catálogo completo de GPUs con precios bajo demanda y spot

### Enlaces

* [Ling-2.6-flash en HuggingFace](https://huggingface.co/inclusionAI/Ling-2.6-flash)
* [organización inclusionAI](https://huggingface.co/inclusionAI) — laboratorio de IA de código abierto de Ant Group
* [repositorio de SGLang](https://github.com/sgl-project/sglang) — framework de servicio recomendado
* [documentación de vLLM](https://docs.vllm.ai)
* [tabla de clasificación BFCL-V4](https://gorilla.cs.berkeley.edu/leaderboard.html) — Berkeley Function Calling


---

# Agent Instructions: 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-es/modelos-de-lenguaje/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.
