GLM-5 è il modello di fondazione di nuova generazione di Z.AI costruito per l'ingegneria agentica, mirato all'ingegneria di sistemi complessi e ai compiti di agent a lungo orizzonte.
- Input
- testo $1/M
- Output
- testo $3.2/M
- Lettura cache
- $0.2/M
- Contesto
- 200K
- vs GPT-4o
- ~80% più economico
Benchmark
Dati pubblicati dai fornitori: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Il prezzo nel contesto
Posizione del prezzo tra 60 modelli comparabili
La barra mostra dove si colloca il prezzo di questo modello tra tutti i modelli dello stesso tipo su Synthorai. Alle due estremità sono indicati il più economico e il più caro. Sono tariffe base; gli sconti per batch, regione e scrittura in cache sono nella pagina dei prezzi.
Specifiche e limiti
Token
| Finestra di contesto (specifica del fornitore) | 200.000 |
|---|---|
| Output massimo (specifica del vendor) | 131.072 |
Caching prompt
| Modalità | automatico |
|---|
Ragionamento
| Parametro del fornitore | thinking.type |
|---|---|
| Valori accettati | enabled · disabled |
| Valore predefinito | enabled, e su GLM-5 è il modello a determinare automaticamente se pensare applicato se la richiesta non specifica nulla |
| Disattivabile | Sì |
| Comportamento del ragionamento | La traccia viene restituita in reasoning_content; le tracce dei turni precedenti vengono cancellate di default (clear_thinking true), e i blocchi di interleaved thinking vanno conservati e restituiti insieme ai risultati degli strumenti. |
| Parametro | reasoning_effort |
| Valori | minimal · low · medium · high la superficie parametri del gateway - vale la mappatura del fornitore sopra |
Modello
| Modalità | testo → testo |
|---|---|
| Parametri | 744B totali · 40B attivi MoE |
| Licenza | MIT |
- Flagship per l'ingegneria agentica: MoE da 744B parametri (40B attivi), pre-addestrato su 28,5T token con DeepSeek Sparse Attention
- 200K di contesto / 128K di output massimo
Un solo prompt, misurato attraverso il gateway
GLM-5 superato · 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.
out 1393 tok (+1308 ragionamento) latenza 36.0 s
Rispetto dell'istruzione (esattamente tre frasi - contabili), adattamento al pubblico (registro da CFO), e il divario di fatturazione del pensiero nascosto che i contatori di token qui sotto rivelano.
GLM-5 superato · 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.
out 2907 tok (+2694 ragionamento) latenza 73.7 s
Se la correzione è davvero giusta (eseguibile), la densità della spiegazione, e l'efficienza in token su un compito delimitato.
GLM-5 superato · 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" } ```
out 3620 tok (+3561 ragionamento) latenza 91.8 s
Aderenza allo schema (nessun campo inventato), pressione di allucinazione (guidance è esplicitamente sospesa), e differenze nel percorso di output strutturato.
GLM-5 superato · 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.
out 715 tok (+571 ragionamento) latenza 18.9 s
Rispetto dei vincoli (budget di parole, elenco di parole vietate, l'unica domanda), impronta stilistica, e controllo della lunghezza.
Usa GLM-5 in 30 secondi
Compatibile OpenAI: cambia la base_url, tieni il tuo 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(""));Informazioni su GLM-5
- Rispetto al predecessore, Z.AI ha scalato i parametri da 355B (32B attivati) a 744B (40B attivati) e i dati di pre-addestramento da 23T a 28,5T token, aggiungendo sparse attention e il framework di reinforcement learning asincrono Slime.
- Offre una finestra di contesto da 200K, fino a 128K token di output, modalità thinking, function calling, caching del contesto e pesi aperti, con Z.AI che descrive prestazioni di coding e agent allo stato dell'arte nell'open-source.
- Oltre al codice, la pagina del modello nomina il lavoro documentale a cui punta il suo stesso team: l'estrazione di dati strutturati da contratti e documenti finanziari, la traduzione professionale, il controllo qualità del servizio clienti e la scrittura di ruolo o di storyboard che deve restare in personaggio.
- Il thinking si imposta tramite un oggetto thinking il cui valore predefinito enabled, per questa generazione, significa che è il modello a decidere da sé se ragionare prima di rispondere anziché esservi costretto; la traccia torna in un campo reasoning_content separato, trasmesso in streaming prima della risposta, e le tracce dei turni precedenti vengono rimosse per impostazione predefinita.
- Il tool calling accetta fino a 128 funzioni con streaming incrementale degli argomenti degli strumenti, gli strumenti MCP esterni si collegano direttamente, l'output JSON object è supportato e il caching dei prefissi ripetuti è automatico.
- I pesi sono pubblicati sotto la licenza MIT.
- Synthorai serve GLM-5 tramite il suo endpoint compatibile OpenAI, così gli SDK esistenti funzionano senza modifiche.
FAQ
L'API di GLM-5 si può provare gratis?
Sì: i nuovi account ricevono 10 chiamate di prova e fino a $1 di credito gratuito, senza carta richiesta. A $1/M token in input, quel credito da solo copre circa 125 richieste da ~8K token verso GLM-5.
In cosa eccelle GLM-5?
Scalato a 744B di parametri, 40B attivati; sparse attention più reinforcement learning asincrono; pesi aperti con finestra di contesto da 200K. Il quadro completo è nella sezione «Informazioni», tratto dalle note di rilascio ufficiali del vendor.
Quanto costa GLM-5?
Su Synthorai, GLM-5 costa $1 per milione di token in input e $3.2 per milione di token in output: il prezzo di listino del provider, senza ricarico della piattaforma. I token di input in cache si fatturano a $0.2/M.
GLM-5 supporta il caching dei prompt?
Sì, in automatico: i prompt serviti da Z.ai vanno in cache senza modifiche al codice. I token di input in cache si fatturano a $0.2/M contro $1/M senza cache. Guida al caching dei prompt →
Come ottengo l'accesso a GLM-5?
Punta il tuo SDK OpenAI esistente a base_url="https://synthorai.io/v1", imposta model="glm-5" e hai finito: una sola chiave API copre tutti i modelli del gateway.
GLM-5 è open source?
Sì: i pesi sono pubblicati sotto MIT License. Oppure salta le GPU: la versione hosted qui è con pagamento a consumo, senza infrastruttura da gestire. Eseguire modelli open-weight →
Modelli correlati
Confronta
Ogni valore di questa pagina è trascritto dalla documentazione del fornitore, collegata sopra, e riporta la data in cui è stato verificato. I prezzi sono confrontati sull'intero catalogo; i valori di specifica che i fornitori definiscono in modo diverso sono mostrati indicando la differenza anziché messi a grafico. Nulla qui è misurato da noi e nulla è valutato con un punteggio.