O GLM-5.1 é o modelo de base carro-chefe da Z.AI projetado para tarefas de longo horizonte, descrito oficialmente como capaz de trabalhar de forma contínua e autônoma em uma única tarefa por até 8 horas, cobrindo planejamento, execução, teste, correção e entrega.
- Entrada
- texto $1.4/M
- Saída
- texto $4.4/M
- Leitura de cache
- $0.26/M
- Contexto
- 203K
- vs GPT-4o
- ~72% mais barato
O preço em contexto
Posição do preço entre 68 modelos comparáveis
A barra mostra onde fica o preço deste modelo entre todos os modelos do mesmo tipo na Synthorai. Nas extremidades aparecem o mais barato e o mais caro. São as tarifas base; os descontos de batch, região e escrita de cache estão na página de preços.
Especificações e limites
Tokens
| Janela de contexto (especificação do provedor) | 200.000 |
|---|---|
| Saída máxima (especificação do provedor) | 131.072 |
Cache de prompts
| Modo | automático |
|---|
Raciocínio
| Parâmetro do provedor | thinking.type |
|---|---|
| Valores aceitos | enabled · disabled |
| Valor padrão | enabled, e o modelo determina automaticamente se deve raciocinar usado quando a requisição não define nada |
| Pode ser desativado | Sim |
| Comportamento do raciocínio | O trace retorna em reasoning_content; os traces dos turnos anteriores são limpos por padrão (clear_thinking true), e os blocos de raciocínio intercalado devem ser preservados e devolvidos junto com os resultados das ferramentas. Sem controle de reasoning_effort: isso está documentado apenas para o GLM-5.2. |
| Parâmetro | reasoning_effort |
| Valores | minimal · low · medium · high parâmetros expostos pelo gateway; vale o mapeamento do provedor indicado acima |
Modelo
| Modalidades | texto → texto |
|---|---|
| Parâmetros | 744B no total · 40B ativos MoE |
| Licença | MIT |
- Carro-chefe de engenharia agêntica de nova geração (744B-A40B): trabalha de forma autônoma por até 8 horas em uma única execução, ao longo de milhares de chamadas de ferramentas
- contexto de 200K / saída máxima de 128K
conforme documentação oficial da Z.ai ↗
Um prompt, medido pelo gateway
GLM-5.1 passou · 3 sentences
Enabling reasoning shifts the LLM from generating quick answers to producing hidden "chain-of-thought" tokens that systematically explore multiple solution paths before responding. Because billing is based on total tokens processed, these invisible reasoning tokens drastically increase input and output volume per query, often adding thousands of compute-intensive tokens to a single prompt. Consequently, our bill doubled not from higher per-token rates or increased user volume, but from the exponentially deeper computational work required to deliver higher-quality, more reliable outputs.
saída 98 tok latência 7.8 s
Se a instrução é seguida (exatamente três frases, dá para contar), a adequação ao público (tom para um CFO) e a diferença de cobrança causada pelo raciocínio oculto, que os medidores de tokens abaixo deixam à mostra.
GLM-5.1 passou · 8/8 cases
```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 original function initialized `cur` and `best` to `0` and only incremented `cur` when a duplicate was found. This counts the number of *extra* equal items in a run rather than the total run length, so every run is reported as one shorter than it actually is—returning `0` for single-element lists and `L-1` for a run of length `L` (including those ending at the last index). The fix initializes `cur` and `best` to `1` (when the list is non‑empty) and resets `cur` to `1` on a mismatch, so `cur` tracks the full length of the current run and `best` records the true maximum.
saída 3823 tok (+3585 raciocínio) latência 49.7 s
Se a correção está mesmo certa (dá para executar), a densidade da explicação e a eficiência em tokens em uma tarefa bem delimitada.
GLM-5.1 passou · 5/5 fields, guidance "withheld pending the Q4 close"
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": "eleven and change", "guidance": "withheld pending the Q4 close" } ```
saída 1091 tok (+1028 raciocínio) latência 15.2 s
Aderência ao schema (sem campos inventados), pressão para alucinar (o texto diz explicitamente que o guidance não foi divulgado) e diferenças no caminho de saída estruturada.
GLM-5.1 passou · 120 words, 0 banned, 1 question
We are excited to introduce Prompt Cache for our API Gateway. This new feature stores responses for identical prompts, routing subsequent requests directly to the cache instead of calling the underlying AI provider. Are you tired of paying multiple times for the exact same query? Prompt Cache solves this by recognizing duplicate inputs across all supported providers, drastically reducing latency and operational costs. When a user submits a request that matches a previously cached prompt, the gateway returns the stored answer instantly. You can configure cache expiration and scope rules via your dashboard to maintain data freshness. Stop wasting budget on redundant computational work. Upgrade to the latest gateway tier today to start saving time and money on every call.
saída 3935 tok (+3802 raciocínio) latência 41.1 s
Respeito às restrições (limite de palavras, lista de palavras proibidas, uma única pergunta), a marca de estilo de cada modelo e o controle do tamanho.
Use o GLM-5.1 em 30 segundos
Compatível com OpenAI: troque a base_url, mantenha seu 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.1",
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.1",
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.1",
"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.1",
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.1")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));Sobre o GLM-5.1
- Construído sobre o GLM-5, ele enfatiza um loop de experimentar-analisar-otimizar em vez de geração em uma única passagem, permitindo exploração autônoma, melhoria contínua e entrega estável em ambientes de engenharia complexos.
- O enquadramento que a Z.AI dá à atualização é de resistência, e não de capacidade de pico: onde o lançamento anterior estaciona cedo em um loop agêntico, o GLM-5.1 é documentado como capaz de sustentar a otimização por centenas de rodadas e milhares de chamadas de ferramentas, com melhor julgamento em problemas ambíguos.
- O modelo oferece uma janela de contexto de 200K com até 128K tokens de saída, além de modos de raciocínio (thinking) e function calling.
- As cargas de trabalho nomeadas vão além de código, alcançando diálogo geral, escrita criativa, geração de frontend e de artefatos, e produtividade de escritório.
- O raciocínio é acionado pelo mesmo objeto thinking do resto da linha e, por padrão, deixa o modelo decidir, com o trace retornado em um campo reasoning_content separado; note que o controle de esforço de raciocínio que a Z.AI adicionou depois é documentado como exclusivo do GLM-5.2, então este modelo não tem esse ajuste.
- Ferramentas MCP, streaming, saída JSON e cache de prefixo automático são todos suportados, e os pesos são publicados sob a licença MIT.
- A Synthorai expõe o GLM-5.1 atrás do seu endpoint compatível com OpenAI para integração drop-in.
Perguntas frequentes
A API do GLM-5.1 é gratuita para testar?
Sim. Contas novas recebem 10 chamadas de teste e até $1 em créditos gratuitos, sem precisar de cartão. A $1.4/M de tokens de entrada, só esse crédito já cobre cerca de 89 requisições de ~8K tokens ao GLM-5.1.
Em que o GLM-5.1 é melhor?
Trabalha de forma autônoma por até 8 horas; loop de experimentar-analisar-otimizar em vez de geração em uma passagem; cobre do planejamento aos testes e à entrega. Veja na seção Sobre o quadro completo, tirado das notas de lançamento do próprio provedor.
Quanto custa o GLM-5.1?
Na Synthorai, o GLM-5.1 custa $1.4 por milhão de tokens de entrada e $4.4 por milhão de tokens de saída. É o preço de tabela do provedor, sem markup da plataforma. Tokens de entrada em cache são cobrados a $0.26/M.
Qual é a janela de contexto do GLM-5.1?
O GLM-5.1 tem uma janela de contexto de 203K tokens na Synthorai. Uma única resposta pode ter até 131,072 tokens.
O GLM-5.1 suporta cache de prompts?
Sim, automaticamente: prompts servidos pela Z.ai entram em cache sem nenhuma mudança no código. Tokens de entrada em cache são cobrados a $0.26/M, contra $1.4/M sem cache. Guia de cache de prompts →
Como obtenho acesso ao GLM-5.1?
Aponte o SDK da OpenAI que você já usa para base_url="https://synthorai.io/v1", defina model="glm-5.1" e pronto. Uma única chave de API cobre todos os modelos do gateway.
O GLM-5.1 é open source?
Sim, os pesos são publicados sob a licença MIT. Se preferir dispensar as GPUs, a versão hospedada aqui tem pagamento por uso e nenhuma infraestrutura para operar. Como rodar modelos de pesos abertos →
Modelos relacionados
Comparar
Cada valor desta página foi transcrito da documentação do provedor, com link acima, e traz a data em que foi verificado. Os preços são comparados em todo o catálogo; já as especificações que cada provedor define de um jeito aparecem com a diferença indicada, em vez de irem para um gráfico. Nada aqui foi medido por nós, e nada recebe nota.