# GLM-5.1 (744B MoE, #1 SWE-Bench Pro)

{% hint style="info" %}
**Estado (abril de 2026):** GLM-5.1 se lanzó el **7 de abril de 2026** por Z.ai (antes Zhipu AI) como una mejora incremental pero seria de [GLM-5](/guides/guides_v2-es/modelos-de-lenguaje/glm5.md). Es el primer modelo de pesos abiertos en encabezar **SWE-Bench Pro (58,4%)**, superando por poco a GPT-5.4 (57,7) y Claude Opus 4.6 (57,3), según cifras publicadas por el proveedor. Los pesos están en [huggingface.co/zai-org/GLM-5.1](https://huggingface.co/zai-org/GLM-5.1) bajo la **licencia MIT**.
{% endhint %}

GLM-5.1 es un **Mixture-of-Experts de 744 mil millones de parámetros** modelo de lenguaje que activa solo **\~40 mil millones de parámetros por token**. En comparación con su predecesor [GLM-5](/guides/guides_v2-es/modelos-de-lenguaje/glm5.md), la versión 5.1 mantiene el mismo esqueleto MoE, pero incorpora un enrutamiento de expertos refinado, una **ventana de contexto de 200K tokens**, una **salida máxima de 131K tokens**, y un entrenamiento centrado en **codificación agéntica de largo horizonte** — el modelo está afinado explícitamente para sostener miles de llamadas a herramientas y cientos de rondas de refactorización sin desviarse.

Para los usuarios de Clore.ai, la parte interesante es el **40B activo** : no necesitas un rack completo 8×H200 para ejecutarlo. Una configuración de paralelismo tensorial sobre **2×H100 80GB** (FP8) o **4×A100 80GB** (BF16 con fragmentación) es suficiente para un rendimiento práctico — poniendo la codificación de clase frontera al alcance por \~$12–24/día en el mercado.

### Especificaciones clave

| Propiedad                | Valor                                               |
| ------------------------ | --------------------------------------------------- |
| Parámetros totales       | 744B (MoE)                                          |
| Parámetros activos       | \~40B por pasada hacia adelante                     |
| Ventana de contexto      | 200.000 tokens                                      |
| Salida máxima            | 131.072 tokens                                      |
| Licencia                 | MIT                                                 |
| Fecha de lanzamiento     | 7 de abril de 2026                                  |
| Organización             | Z.ai (zai-org en HuggingFace)                       |
| Herramientas principales | vLLM, SGLang, llama.cpp (GGUF), xLLM, KTransformers |

### ¿Por qué GLM-5.1?

* **#1 en SWE-Bench Pro** — 58,4% según el proveedor, por delante de GPT-5.4 y Claude Opus 4.6
* **Agentes de largo horizonte** — mantiene la optimización a lo largo de cientos de rondas y miles de llamadas a herramientas
* **contexto de 200K** — suficiente para una base de código mediana completa más el conjunto de pruebas
* **MoE activo de 40B** — pagas el costo de inferencia de un modelo denso de 40B, no de uno de 744B
* **licencia MIT** — pesos totalmente abiertos, sin restricciones para uso comercial ni ajuste fino
* **Pila de entrenamiento abierta** — Z.ai publicó el modelo, supuestamente entrenado sin GPUs de centro de datos de Nvidia

***

## Requisitos

{% hint style="warning" %}
**Sigue siendo un modelo grande.** Aunque "40B activo" suena amigable, los pesos completos de 744B deben cargarse en VRAM (o descargarse). Los pesos FP8 ocupan \~860GB; BF16, \~1,5TB. Planifica en consecuencia.
{% endhint %}

| Componente  | Mínimo (Q4 GGUF, descarga a RAM) | Recomendado (FP8)                 | BF16 completo |
| ----------- | -------------------------------- | --------------------------------- | ------------- |
| VRAM de GPU | \~80GB (Q4 + descarga a RAM)     | 2× H100 80GB activos, 8× en total | 8× H200 141GB |
| RAM         | 256GB                            | 256GB                             | 512GB         |
| Disco       | 500GB NVMe                       | 1TB NVMe                          | 2TB NVMe      |
| CUDA        | 12.4+                            | 12.4+                             | 12.6+         |

**Elección de Clore.ai:** Para la mayoría de los equipos, 2× H100 80GB ejecutando el punto de control FP8 con descarga agresiva es el punto ideal (\~$12–16/día). Si necesitas rendimiento completo BF16, salta a 8× H200 o usa la API de Z.ai para llamadas ocasionales.

***

## Opción A — Ollama / GGUF (cuantizado, compilaciones de la comunidad)

{% hint style="warning" %}
**Aviso:** Las cuantizaciones GGUF de la comunidad suelen aparecer 1–2 semanas después de un lanzamiento de Z.ai. Si `ollama pull` falla, revisa [huggingface.co/models?search=glm-5.1+gguf](https://huggingface.co/models?search=glm-5.1+gguf) y apunta llama.cpp al archivo directamente.
{% endhint %}

```bash
# Una vez que haya disponible una compilación Q4_K_M
docker exec ollama ollama pull glm-5.1:q4_K_M
docker exec ollama ollama run glm-5.1:q4_K_M

# O con llama.cpp directamente sobre un archivo GGUF
docker run --gpus all -it --rm -p 8080:8080 \
  -v $(pwd)/models:/models \
  ghcr.io/ggerganov/llama.cpp:server-cuda \
  -m /models/glm-5.1-q4_k_m.gguf \
  --n-gpu-layers 80 --ctx-size 32768 \
  --port 8080 --host 0.0.0.0
```

***

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

vLLM es el objetivo de servicio de primera clase de Z.ai. El punto de control FP8 (`zai-org/GLM-5.1-FP8`) es el que quieres — misma calidad que BF16, aproximadamente la mitad de memoria.

```yaml
version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model zai-org/GLM-5.1-FP8
      --tensor-parallel-size 8
      --max-model-len 65536
      --gpu-memory-utilization 0.88
      --tool-call-parser glm47
      --reasoning-parser glm45
      --enable-auto-tool-choice
      --served-model-name glm-5.1
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    shm_size: "16gb"

volumes:
  hf_cache:
```

```bash
# Probar la API
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.1",
    "messages": [
      {"role": "system", "content": "Eres un ingeniero de software senior."},
      {"role": "user", "content": "Refactoriza este controlador de Go para usar context.Context correctamente y añade reintentos."}
    ],
    "max_tokens": 4096,
    "temperature": 1.0
  }'
```

{% hint style="info" %}
Usa `--tensor-parallel-size 2` en 2× H100 si te quedas justo de GPUs, pero prepárate para un prefill más lento en contextos de 200K. `--enable-chunked-prefill` ayuda mucho.
{% endhint %}

***

## Opción C — SGLang (alternativa, a menudo más rápida en Hopper)

```bash
docker pull lmsysorg/sglang:latest

python3 -m sglang.launch_server \
  --model-path zai-org/GLM-5.1-FP8 \
  --tp-size 8 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --mem-fraction-static 0.88 \
  --context-length 65536 \
  --served-model-name glm-5.1
```

La decodificación especulativa EAGLE de SGLang suele ofrecer un aumento de rendimiento de 1,5–2× en completaciones largas de código.

***

## Recomendaciones de GPU para Clore.ai

| Configuración | VRAM    | Rendimiento esperado              | Costo en Clore.ai |
| ------------- | ------- | --------------------------------- | ----------------- |
| 2× H100 80GB  | 160GB   | FP8 con descarga, \~15–25 tok/s   | \~$12–16/día      |
| 4× A100 80GB  | 320GB   | BF16 fragmentado, \~20–30 tok/s   | \~$15–22/día      |
| 8× H100 80GB  | 640GB   | FP8 completo, \~60+ tok/s         | \~$40–55/día      |
| 8× H200 141GB | 1.128GB | BF16 completo, rendimiento máximo | \~$70+/día        |

{% hint style="success" %}
**Mejor relación calidad-precio:** 2× H100 80GB con el punto de control FP8. Obtienes rendimiento de codificación de clase frontera por aproximadamente el precio de una suscripción a Claude Opus — y los pesos se quedan en tu máquina.
{% endhint %}

***

## Casos de uso

* **Agentes SWE autónomos** — GLM-5.1 está entrenado explícitamente para bucles largos de llamadas a herramientas; combínalo con algo como SWE-agent u OpenHands
* **Comprensión de bases de código** — mete 100K+ tokens de Go/Rust/Python en contexto y pide revisiones arquitectónicas
* **RAG de contexto largo** — 200K de contexto manejan docs completas del producto + tickets de soporte de una sola vez
* **Canalizaciones de refactorización** — corrección sostenida a lo largo de cientos de ediciones de archivos
* **Orquestación de agente de agentes** — usa GLM-5.1 como planificador y modelos más pequeños (Qwen3.5-35B, GLM-4.7) como trabajadores

***

## Benchmarks

{% hint style="warning" %}
**Afirmado por el proveedor — verifica de forma independiente.** Los números a continuación provienen del anuncio de Z.ai del 7 de abril de 2026. Las reproducciones independientes en SWE-Bench Pro aún están llegando.
{% endhint %}

| Benchmark          | GLM-5.1   | GPT-5.4 | Claude Opus 4.6 | GLM-5 |
| ------------------ | --------- | ------- | --------------- | ----- |
| SWE-Bench Pro      | **58.4%** | 57.7%   | 57.3%           | \~52% |
| SWE-Bench Verified | \~79%     | \~78%   | \~80%           | 77.8% |
| HumanEval          | \~94%     | \~95%   | \~94%           | \~93% |
| LiveCodeBench      | \~72%     | \~73%   | \~70%           | \~68% |

***

## Solución de problemas

| Problema                                              | Solución                                                                                                                    |
| ----------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` al cargar                          | El punto de control FP8 necesita \~860GB de VRAM total. Usa 8× H100/H200 o baja a GGUF Q4 con descarga a RAM.               |
| Descarga lenta de HuggingFace                         | Usa `huggingface-cli download zai-org/GLM-5.1-FP8 --local-dir ./weights --resume-download`. Espera 800GB+.                  |
| Las llamadas a herramientas se omiten silenciosamente | Asegúrate de `--tool-call-parser glm47` y `--enable-auto-tool-choice` estén ambos configurados en vLLM.                     |
| Modo de pensamiento vacío                             | Requiere `temperature=1.0` — el muestreo con temperatura cero rompe el rastro de razonamiento.                              |
| vLLM rechaza la configuración                         | GLM-5.1 necesita vLLM ≥ 0.7.x (versión de abril de 2026). Usa `pip install -U vllm --pre` si estás en versiones anteriores. |
| OOM con contexto de 200K                              | Empieza con `--max-model-len 65536` y añade `--enable-chunked-prefill`; súbelo una vez que sea estable.                     |

***

## Próximos pasos

* **Predecesor:** [GLM-5](/guides/guides_v2-es/modelos-de-lenguaje/glm5.md) — misma forma MoE, ligeramente menos centrado en la codificación
* **Alternativa más barata:** [Qwen3.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen35.md) — 35B denso cabe en una sola RTX 4090
* **Alternativa de contexto masivo:** [DeepSeek V4](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v4.md) — 1M de contexto, multimodal, \~1T de parámetros
* **Mercado de Clore.ai:** [clore.ai/marketplace](https://clore.ai/marketplace) — alquila H100/H200/A100 desde $0,50/día

### Enlaces

* [GLM-5.1 en HuggingFace](https://huggingface.co/zai-org/GLM-5.1)
* [Blog de Z.ai — anuncio de GLM-5.1](https://z.ai/blog/glm-5.1)
* [Plataforma Z.ai (API alojada)](https://chat.z.ai)
* [Documentación de vLLM](https://docs.vllm.ai)
* [Repositorio de SGLang](https://github.com/sgl-project/sglang)


---

# 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/glm-5-1.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.