GLM-5 est le modèle de fondation de nouvelle génération de Z.AI, conçu pour l'ingénierie agentique et visant l'ingénierie de systèmes complexes et les tâches d'agent à long horizon.
- Entrée
- texte $1/M
- Sortie
- texte $3.2/M
- Lecture de cache
- $0.2/M
- Contexte
- 200K
- vs GPT-4o
- ~80% moins cher
Benchmarks
Chiffres publiés par les fournisseurs : Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Le prix en contexte
Position du prix parmi 60 modèles comparables
La barre montre où se situe le prix de ce modèle parmi tous les modèles du même type sur Synthorai. Le moins cher et le plus cher sont nommés à chaque extrémité. Ce sont des tarifs de base ; les remises lot, région et écriture en cache figurent sur la page des tarifs.
Spécifications et limites
Tokens
| Fenêtre de contexte (spécification du fournisseur) | 200 000 |
|---|---|
| Sortie max (spéc. fournisseur) | 131 072 |
Mise en cache
| Mode | automatique |
|---|
Raisonnement
| Paramètre du fournisseur | thinking.type |
|---|---|
| Valeurs acceptées | enabled · disabled |
| Valeur par défaut | enabled, et sur GLM-5 le modèle détermine automatiquement s'il doit réfléchir appliquée si la requête ne précise rien |
| Désactivable | Oui |
| Comportement du raisonnement | La trace revient dans reasoning_content ; les traces des tours précédents sont effacées par défaut (clear_thinking true), et les blocs de réflexion entrelacés doivent être conservés et renvoyés avec les résultats d'outils. |
| Paramètre | reasoning_effort |
| Valeurs | minimal · low · medium · high la surface de paramètres de la passerelle - le mappage fournisseur ci-dessus s'applique |
Modèle
| Modalités | texte → texte |
|---|---|
| Paramètres | 744B au total · 40B actifs MoE |
| Licence | MIT |
- Fleuron pour l'ingénierie agentique: MoE de 744B de paramètres (40B actifs), pré-entraîné sur 28,5T tokens avec DeepSeek Sparse Attention
- contexte de 200K / 128K de sortie maximale
selon docs officielles Z.ai ↗
Un prompt, mesuré via la passerelle
GLM-5 réussi · 3 sentences
Enabling reasoning forces the model to perform multiple hidden steps to "think" through a problem, drastically increasing the volume of data processed per query compared to a standard response. Because our billing is directly tied to this processing volume, the additional computational work required for higher accuracy has proportionally doubled our consumption. Essentially, the spike reflects a trade-off where we are paying a higher variable cost to secure significantly better analytical outcomes.
sortie 1393 tok (+1308 réflexion) latence 36.0 s
Suivi de l'instruction (exactement trois phrases - comptables), adaptation à l'audience (registre CFO), et l'écart de facturation lié à la réflexion cachée que les compteurs de tokens ci-dessous révèlent.
GLM-5 réussi · 8/8 cases
Here is the fixed code: ```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` **Explanation:** The bug stems from initializing `best` and `cur` to zero, which causes the function to count the number of *transitions* between adjacent elements rather than the total number of items in the run, resulting in a return value that is always one less than the actual length (reporting 0 for a single element and 1 for a pair). By initializing the counters to 1 and resetting `cur` to 1 when a streak breaks, the logic correctly counts the items themselves; adding an explicit check for an empty list ensures the function handles the zero-element edge case correctly.
sortie 2907 tok (+2694 réflexion) latence 73.7 s
Si le correctif est réellement juste (exécutable), la densité de l'explication, et l'efficacité en tokens sur une tâche bornée.
GLM-5 réussi · 5/5 fields, guidance "withheld pending the Q4 close"
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "withheld pending the Q4 close" } ```
sortie 3620 tok (+3561 réflexion) latence 91.8 s
Respect du schéma (aucun champ inventé), pression d'hallucination (guidance est explicitement retenue), et différences de chemin pour la sortie structurée.
GLM-5 réussi · 119 words, 0 banned, 1 question
We are thrilled to introduce Global Prompt Caching, a powerful new capability within our API gateway designed to optimize your AI operations. By intelligently storing prompt responses across every supported provider, this feature drastically reduces latency and cuts operational costs. Instead of processing identical requests repeatedly, our system serves cached results instantly, ensuring consistent performance even during high-traffic periods. Why pay full price for repeated inference on the same inputs? This update gives developers fine-grained control over cache lifetimes and hit rates, allowing for predictable budgeting and faster application response times. You can activate this functionality directly in your dashboard settings today. Start maximizing your efficiency now and deliver a snappier experience to your end-users without unnecessary API expenditure.
sortie 715 tok (+571 réflexion) latence 18.9 s
Respect des contraintes (budget de mots, liste de mots interdits, l'unique question), empreinte stylistique, et contrôle de la longueur.
Utilisez GLM-5 en 30 secondes
Compatible OpenAI : changez la base_url, gardez votre SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="glm-5",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "glm-5",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "glm-5",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "glm-5",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("glm-5")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));À propos de GLM-5
- Par rapport à son prédécesseur, Z.AI a fait passer les paramètres de 355B (32B activés) à 744B (40B activés) et les données de pré-entraînement de 23T à 28,5T tokens, en ajoutant l'attention creuse et le framework d'apprentissage par renforcement asynchrone Slime.
- Il offre une fenêtre de contexte de 200K, jusqu'à 128K tokens de sortie, des modes de réflexion, l'appel de fonctions, la mise en cache du contexte et des poids ouverts, Z.AI évoquant des performances de codage et d'agent à l'état de l'art de l'open source.
- Au-delà du code, la page du modèle nomme le travail documentaire que sa propre équipe vise : extraction de données structurées à partir de contrats et de documents financiers, traduction professionnelle, contrôle qualité du service client, et jeu de rôle ou écriture de storyboards qui doit rester dans le personnage.
- La réflexion se règle via un objet thinking dont la valeur par défaut enabled signifie, pour cette génération, que le modèle décide lui-même s'il doit raisonner avant de répondre plutôt que d'y être contraint ; la trace revient dans un champ reasoning_content distinct, diffusé en streaming avant la réponse, et les traces des tours précédents sont supprimées par défaut.
- L'appel d'outils accepte jusqu'à 128 fonctions avec streaming incrémental des arguments d'outil, les outils MCP externes se branchent directement, la sortie en objet JSON est prise en charge et la mise en cache des préfixes répétés est automatique.
- Les poids sont publiés sous licence MIT.
- Synthorai sert GLM-5 via son endpoint compatible OpenAI, si bien que les SDK existants fonctionnent sans changement.
FAQ
Peut-on essayer l'API GLM-5 gratuitement ?
Oui : les nouveaux comptes reçoivent 10 appels d'essai et jusqu'à $1 de crédit gratuit, sans carte bancaire. À $1/M de tokens en entrée, ce crédit couvre à lui seul environ 125 requêtes de ~8K tokens sur GLM-5.
Quels sont les points forts de GLM-5 ?
Mis à l'échelle à 744B de paramètres, 40B activés ; attention creuse plus apprentissage par renforcement asynchrone ; poids ouverts avec fenêtre de contexte de 200K. Voir la section À propos pour le tableau complet, tiré des notes de version officielles du fournisseur.
Combien coûte GLM-5 ?
Sur Synthorai, GLM-5 coûte $1 par million de tokens en entrée et $3.2 par million de tokens en sortie, soit le prix catalogue du fournisseur, sans majoration de plateforme. Les tokens d'entrée en cache sont facturés $0.2/M.
GLM-5 prend-il en charge la mise en cache des prompts ?
Oui, automatiquement : les prompts servis par Z.ai sont mis en cache sans modification de code. Les tokens d'entrée en cache sont facturés $0.2/M contre $1/M hors cache. Guide de mise en cache des prompts →
Comment obtenir l'accès à GLM-5 ?
Pointez votre SDK OpenAI existant vers base_url="https://synthorai.io/v1", définissez model="glm-5", et c'est tout. Une seule clé API couvre tous les modèles de la passerelle.
GLM-5 est-il open source ?
Oui : les poids sont publiés sous MIT (licence). Ou passez-vous des GPU : la version hébergée ici est au paiement à l'usage, sans infrastructure à exploiter. Exécuter des modèles à poids ouverts →
Modèles associés
Comparer
Chaque valeur de cette page est transcrite de la documentation du fournisseur, liée ci-dessus, et porte la date de sa vérification. Les prix sont comparés à l'échelle du catalogue ; les valeurs de spécification que les fournisseurs définissent différemment sont présentées avec la différence indiquée plutôt que mises en graphique. Rien ici n'est mesuré par nous, et rien n'est noté.