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

Despliega Ling-2.6-flash (104B MoE, 7.4B activos) de Ant Group en Clore.ai: el hermano flash afinado para agentes que cabe en una sola RTX 4090

Estado (29 de abril de 2026): Ling-2.6-flash fue lanzado por Ant Group inclusionAI equipo en 28 de abril de 2026 (hace un día en el momento de escribir esto). Es el hermano pequeño, rápido y ajustado para agentes de Ling-2.5-1T — el mismo linaje, el 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 bajo la licencia MIT.

Donde Ling-2.5-1T se necesitaba un rack de 8 GPU incluso para arrancar, Ling-2.6-flash es el primer lanzamiento de inclusionAI que cabe en una sola GPU de consumo. La ruta activa de 7.4B significa que pagas el coste de inferencia de un modelo denso de 8B mientras aprovechas un pool de parámetros de 104B — y Ant Group ha ajustado ese pool específicamente para flujos de trabajo agentivos: llamadas a 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 menor: INT4 cabe cómodamente en una 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 frontier recién ajustado para agentes en aproximadamente ~$1.04/h en la mercado de Clore.ai.

Especificaciones clave

Propiedad	Valor
Parámetros totales	104B (MoE)
Parámetros activos	7.4B por pasada hacia delante
Arquitectura	atención híbrida MLA + Lightning Linear 1:7
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 RTX 4090 o RTX 3090, FP8 en una H100. Sin dramas de multi-GPU, sin peleas con NVLink.

• Ajustado para agentes — entrenado explícitamente para bucles de llamadas a herramientas al estilo BFCL-V4 / TAU2-bench, no solo evaluado sobre ellos a posteriori.

• Calidad de MoE disperso al coste activo de 7.4B — obtienes un pool de conocimiento de 104B parámetros a través de una ruta de inferencia de 7.4B.

• Contexto de 256K listo para usar — 262K tokens nativos, sin necesidad de trucos de YaRN para trazas largas de agentes.

• licencia MIT — totalmente comercial, ajustable y redistribuible.

• Linaje — descendiente directo de Ling-2.5-1T y Ring-2.5; la arquitectura está probada en combate.

---

Requisitos

Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai. Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como bare metal bajo pedido. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

Compatible con Clore. Este es el primer modelo de la línea inclusionAI que funciona en una sola GPU de consumo. Si te has quedado fuera de Ling-2.5-1T o GLM-5.1, esta es la puerta de entrada.

Componente	INT4 (una sola GPU de 24GB)	FP8 (una sola GPU de 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	128 GB
Disco	60GB NVMe	120GB NVMe	220GB NVMe
CUDA	12.8+	12.8+	12.8+
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.14–0.42/hr) que ejecute un GGUF INT4 es imbatible en precio. Pásate a una sola H100 si necesitas calidad FP8 o contexto de 128K+.

---

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

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

Aviso del primer día: Ling-2.6-flash se lanzó el 28 de abril de 2026. A la hora de escribir esto, las cuantizaciones comunitarias GGUF quizá todavía estén llegando. Vigila huggingface.co/models?search=ling-2.6-flash+gguf y unsloth para las primeras compilaciones. Si ollama pull da 404, apunta llama.cpp directamente al archivo GGUF.

# Una vez que se publique una compilación Q4_K_M de la comunidad
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 — suficiente para trabajo interactivo con agentes.

---

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

vLLM es la opción preferida para servir Ling-2.6-flash a varios agentes concurrentes. Usa el checkpoint FP8 en una sola H100 / A100 80GB:

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:

# Probar la ruta del 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
  }'

Para BF16 con calidad completa en contextos largos (200K+), amplía --tensor-parallel-size 2 a 2× A100 80GB o fíjalo a una sola H200 de 141GB.

---

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.

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 de 340 tok/s del proveedor (requiere clase 4× H20 / 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 para Clore.ai

Configuración	VRAM	Cuantización	Rendimiento esperado	Coste de Clore.ai
1× RTX 3090	24GB	INT4 GGUF	~60–90 tok/s	$0.07–0.21/h
1× RTX 4090	24GB	INT4 GGUF	~80–120 tok/s	$0.14–0.42/h
1× A100 80GB	80 GB	FP8	~120–180 tok/s	bare metal
1× H100 80GB	80 GB	FP8	~150–220 tok/s	~$1.04/h
4× H100 80GB	320 GB	BF16 + TP=4	~340 tok/s (proveedor)	~4,16 $/h

Mejor opción: Una sola RTX 4090 desde $0.14–0.42/h ejecutando el GGUF Q4_K_M. Obtienes un modelo ajustado para agentes, con licencia MIT y MoE de 104B, con contexto de 32K por menos que el precio de un café por hora. Esta es exactamente la forma de despliegue para la que se creó el mercado de GPU de consumo de Clore.ai.

---

Casos de uso

• Agentes con llamadas a herramientas — el ajuste 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 cadenas de llamadas a herramientas sin la deriva típica de los modelos pequeños.

• Sustituto local de Claude Code / OpenHands — API compatible con OpenAI lista para usar en tu propia RTX 4090.

• Tareas por lotes agentivas de gran volumen — 340 tok/s en 4×H100 hacen que esto sea viable para procesar miles de transcripciones de agentes por hora.

• RAG de contexto largo — 256K de contexto nativo cubren la mayoría de los conjuntos de documentos empresariales en un solo prompt.

• Entorno de desarrollo económico para Ling-2.5-1T flujos de trabajo — prototipa en flash, despliega en la variante 1T.

---

Pruebas comparativas

Afirmado por el proveedor — verifica de forma independiente. Todas las cifras a continuación provienen de la ficha del modelo de inclusionAI del 28 de abril de 2026. El modelo tiene un día; todavía no se han publicado reproducciones comunitarias en BFCL-V4 y TAU2-bench. Tómalas como orientativas, no como evangelio.

Benchmark	Ling-2.6-flash (proveedor)	Notas
BFCL-V4	SOTA para su clase de tamaño	Berkeley Function Calling Leaderboard v4
TAU2-bench	SOTA para su clase de tamaño	Benchmark de agente de herramientas v2
SWE-bench Verified / Resolved	~61.2%	Tasa de resuelto en la partición verificada
MathArena AIME 2026	73.85
MathArena HMMT Feb 2026	49.29
Rendimiento	~340 tok/s	4× H20-3e, TP=4, batch 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 los demás procesos de GPU
GGUF todavía no está en HuggingFace	El modelo tiene un día. Revisa unsloth, bartowskiy TheBloke sus espejos; o cuantiza desde BF16 tú mismo con llama-quantize
vLLM rechaza la arquitectura	Asegúrate de usar vLLM ≥ 0.7.x con --trust-remote-code; las capas de atención lineal híbrida son personalizadas
Las llamadas a herramientas se devuelven como texto plano	Establece --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 es siempre 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 batch 32. Una sola GPU + batch 1 es naturalmente mucho más lenta — eso es lo esperado, no un error
Salida corrupta a alta temperatura	Baja a temperature=0.7 para chat, 0.1 para llamadas a herramientas

---

Siguientes pasos

• Hermano mayor: Ling-2.5-1T — la misma familia, 1T total / 63B activos, razonamiento de frontera a coste de multi-GPU

• Agente similar para una sola GPU: MiMo-V2-Flash — 309B/15B activos con decodificación especulativa integrada

• Alternativa de código abierto para programación: GLM-5.1 — 744B/40B activos, líder de SWE-Bench Pro

• Alquileres de GPU baratos: Alquila una RTX 4090 desde $0.14–0.42/h o RTX 3090 desde $0.07–0.21/h

• Mercado de Clore.ai: clore.ai/marketplace — catálogo completo de GPU con precios bajo demanda y spot

Enlaces

• Ling-2.6-flash en HuggingFace

• organización inclusionAI — el laboratorio de IA de código abierto de Ant Group

• repositorio SGLang — marco de servicio recomendado

• documentación de vLLM

• tabla de clasificación BFCL-V4 — Berkeley Function Calling