> 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-es/modelos-de-lenguaje/glm-5-1.md).

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

Despliega GLM-5.1 (744B MoE, 40B activos) de Z.ai en Clore.ai: el modelo de pesos abiertos que encabezó SWE-Bench Pro en abril de 2026

{% 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 actualización 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 las 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 **modelo 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 la misma estructura MoE, pero incluye un enrutamiento de expertos más refinado, una **ventana de contexto de 200K tokens**, un **salida máxima de 131K tokens**, y un entrenamiento centrado en **programación agéntica de largo horizonte** — el modelo está ajustado explícitamente para sostener miles de llamadas a herramientas y cientos de rondas de refactorización sin desviarse.

Para los usuarios de Clore.ai, lo interesante es el **40B activos** número: no necesitas un rack completo de 8×H200 para servirlo. Una configuración de paralelismo tensorial entre **2×H100 80GB** (FP8) o **4×A100 80GB** (BF16 con sharding) es suficiente para un rendimiento práctico — poniendo la programación de vanguardia al alcance en [bare metal](https://clore.ai/bare-metal) 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 completa de tamaño mediano más su suite 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 o ajuste fino
* **Pila de entrenamiento abierta** — Z.ai publicó el modelo, al parecer entrenado sin GPUs de centro de datos de Nvidia

***

## Requisitos

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

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

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

**Elección de Clore.ai:** Para la mayoría de los equipos, 2× H100 de 80 GB ejecutando el checkpoint FP8 con descarga agresiva es el punto ideal (\~$2.08/h). Si necesitas el rendimiento completo de BF16, pasa 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 directamente al archivo.
{% endhint %}

```bash
# Una vez que haya una compilación Q4_K_M disponible
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 checkpoint 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 sénior."},
      {"role": "user", "content": "Refactoriza este controlador Go para usar context.Context correctamente y añadir reintentos."}
    ],
    "max_tokens": 4096,
    "temperature": 1.0
  }'
```

{% hint style="info" %}
Usa `--tensor-parallel-size 2` en 2× H100 si andas justo de cantidad de GPU, 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 dar 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              | Coste de Clore.ai                         |
| ------------- | ------- | --------------------------------- | ----------------------------------------- |
| 2× H100 80GB  | 160 GB  | FP8 con descarga, \~15–25 tok/s   | \~$2.08/hr                                |
| 4× A100 80GB  | 320 GB  | BF16 fragmentado, \~20–30 tok/s   | [bare metal](https://clore.ai/bare-metal) |
| 8× H100 80GB  | 640 GB  | FP8 completo, \~60+ tok/s         | \~$8.32/hr                                |
| 8× H200 141GB | 1,128GB | BF16 completo, rendimiento máximo | [bare metal](https://clore.ai/bare-metal) |

{% hint style="success" %}
**Mejor opción:** 2× H100 de 80 GB con el checkpoint FP8. Obtienes un rendimiento de programación de vanguardia 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 el contexto y pide revisiones arquitectónicas
* **RAG de contexto largo** — 200K de contexto maneja documentación completa del producto + tickets de soporte de una sola vez
* **Pipelines de refactorización** — corrección sostenida a lo largo de cientos de ediciones de archivos
* **Orquestación agente-de-agentes** — usa GLM-5.1 como planificador y modelos más pequeños (Qwen3.5-35B, GLM-4.7) como trabajadores

***

## Pruebas comparativas

{% hint style="warning" %}
**Afirmado por el proveedor — verifica de forma independiente.** Las cifras siguientes provienen del anuncio de Z.ai del 7 de abril de 2026. Las reproducciones independientes en SWE-Bench Pro siguen 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 checkpoint FP8 necesita \~860 GB 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 800 GB+.                 |
| Llamadas a herramientas descartadas 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 a temperatura cero rompe la traza 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. |
| OOMs de contexto de 200K                            | Empieza con `--max-model-len 65536` y añade `--enable-chunked-prefill`; súbelo una vez que sea estable.                     |

***

## Siguientes pasos

* **Predecesor:** [GLM-5](/guides/guides_v2-es/modelos-de-lenguaje/glm5.md) — misma estructura MoE, algo menos centrado en programación
* **Alternativa más barata:** [Qwen3.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen35.md) — un modelo denso de 35B 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 en [bare metal](https://clore.ai/bare-metal)

### 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 SGLang](https://github.com/sgl-project/sglang)


---

# 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-es/modelos-de-lenguaje/glm-5-1.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.