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 perspective
Position du prix parmi 68 modèles comparables
La barre 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 liées au batch, à la région et aux écritures de 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 |
|---|
Réflexion
| 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 de la réflexion | 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 paramètres exposés par la passerelle ; la correspondance avec ceux du 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
Le respect de la consigne (exactement trois phrases, ça se compte), l'adaptation au public visé (le registre d'un directeur financier) et l'écart de facturation dû à la réflexion masquée, que révèlent les compteurs de tokens ci-dessous.
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
La justesse réelle du correctif (il s'exécute), la densité de l'explication et l'économie de tokens sur une tâche bien délimité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
Le respect du schéma (aucun champ inventé), la tentation d'halluciner (le texte indique que la guidance n'est pas communiquée) et les différences entre les mécanismes de 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
Le respect des contraintes (nombre de mots, liste de mots interdits, une seule question), l'empreinte stylistique et la maîtrise 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. La section À propos en donne un aperçu complet, tiré des notes de version 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 tarif public du fournisseur, sans majoration de plateforme. Les tokens d'entrée en cache sont facturés $0.2/M.
Quelle est la fenêtre de contexte de GLM-5 ?
GLM-5 dispose d'une fenêtre de contexte de 200K tokens sur Synthorai. Une réponse peut compter jusqu'à 131,072 tokens.
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 ?
Dans votre SDK OpenAI actuel, indiquez base_url="https://synthorai.io/v1" et model="glm-5", et c'est tout. Une seule clé API donne accès à tous les modèles de la passerelle.
GLM-5 est-il open source ?
Oui : les poids sont publiés sous licence MIT. Vous pouvez aussi vous passer de GPU : la version hébergée ici est facturée à l'usage, sans infrastructure à gérer. Exécuter des modèles à poids ouverts →
Modèles associés
Comparer
Chaque valeur de cette page est reprise de la documentation du fournisseur (lien ci-dessus) et porte la date de sa vérification. Les prix sont comparés à l'échelle du catalogue. Quand les fournisseurs ne définissent pas une spécification de la même façon, la différence est signalée et la valeur n'est pas mise en graphique. Nous ne mesurons rien ici et nous n'attribuons aucune note.