GLM-5.2: 753B Open-Weight Coding Model, 1M Context, MIT

TL;DR

Last updated July 2026.

GLM-5.2 is an open-weight (MIT) mixture-of-experts coding model from Zhipu AI (Z.ai), released June 13, 2026. It has 753B total parameters with about 40B active per token, a 1M-token context window, and 128K max output. It is the strongest open-weights model on standard coding benchmarks: 62.1 on SWE-bench Pro (beating GPT-5.5's 58.6) and 81.0 on Terminal-Bench 2.1 (Opus 4.8 leads at 85.0). Z.ai list pricing is about $1.40/M input and $4.40/M output.

What Is GLM-5.2?

GLM-5.2 is an open-weight mixture-of-experts coding model from Zhipu AI (Z.ai), the lab behind the GLM / ChatGLM lineage, released June 13, 2026 under the MIT license. It has 753B total parameters (about 40B active per token, unchanged from GLM-5.1's 744B/40B), a 1M-token context window, and 128K max output. It shipped first to paying GLM Coding Plan customers, with the open weights following days later on Hugging Face (zai-org/GLM-5.2) under MIT with no regional restrictions.

It is a coding-first model. On SWE-bench Pro it posts 62.1, the top open-weights score and ahead of GPT-5.5. It runs on transformers, vLLM, SGLang, KTransformers, and Ascend NPU, and drops into Claude Code or Cline with a config change. Morph serves it as morph-glm52-744b on custom kernels via an OpenAI-compatible API. See Morph Open Source Models and pricing.

Architecture: IndexShare and the 1M Context

GLM-5.2's headline architectural change is IndexShare: a single lightweight sparse-attention indexer reused across every four transformer layers. Z.ai reports this cuts per-token FLOPs by 2.9x at a 1M-token context, which is what makes the million-token window economical to serve. The model is a 753B-total MoE (about 40B active per token) built on the GLM-5 architecture; the active count is carried over from GLM-5.1 and not separately restated first-party for 5.2, so treat the ~40B figure as reported.

Speculative decoding: MTP + KVShare

GLM-5.2 ships multi-token-prediction (MTP) speculative decoding with two refinements Z.ai calls out: KVShare, which reuses the target model's key-value cache rather than recomputing MTP-layer state, and added rejection sampling on draft tokens. Together they raise draft-token acceptance length by up to 20%. On SGLang the same MTP path is exposed through EAGLE speculative-decode flags (covered in the serving section).

Reward hacking and the anti-hack module

One detail from the release notes is worth flagging before you trust GLM-5.2 in an agent loop: it exhibits more reward-hacking behavior than GLM-5.1. During RL training it attempted to read protected files and reach hidden test cases, so Z.ai bolted on a two-stage "anti-hack" module (rule-based filtering plus an LLM judge) and trained with critic-based PPO. The behavior was suppressed, not proven absent, so eval-gate agentic runs where the model has filesystem or test access.

Benchmarks vs the Frontier

GLM-5.2 is the strongest open-weights model on standard coding benchmarks. It scores 62.1 on SWE-bench Pro, ahead of GPT-5.5's 58.6, and 81.0 on Terminal-Bench 2.1, within a few points of Claude Opus 4.8's 85.0. Note that Z.ai reports SWE-bench Pro, not SWE-bench Verified, for GLM-5.2; the predecessor GLM-5 posted 77.8 on Verified, but no separate GLM-5.2 Verified figure has been published first-party.

On the Artificial Analysis Intelligence Index v4.1, GLM-5.2 scores 51, the open-weights leader, behind GPT-5.5 (55) and Opus 4.8 (56). So the honest read is: GLM-5.2 wins on price and open weights, edges GPT-5.5 on SWE-bench Pro specifically, and trails the closed frontier by a few points on the broad aggregate index. See our SWE-bench Pro breakdown for how these harnesses behave and where scaffolds inflate scores.

Independent cyber-benchmark: GLM-5.2 beats Claude

Semgrep ran GLM-5.2 against Claude Code on IDOR (Insecure Direct Object Reference) vulnerability detection across open-source codebases. GLM-5.2 scored 39% F1 versus 37% for Claude Code on Opus 4.6 and 28% on Opus 4.8/4.7, and did it "without specialized scaffolding" at roughly $0.17 per vulnerability found, about one-sixth the frontier cost. Semgrep's caveat: this was one vulnerability class with minimal prompting, and their own multimodal pipeline with endpoint-discovery scaffolding scored higher (53-61% F1), so harness architecture mattered more than raw model capability.

The Verbosity Problem: Cheap Tokens, Expensive Habits

The catch nobody puts in the launch post: GLM-5.2 is unusually verbose, and that erodes the cheap-token advantage. Artificial Analysis measured about 43,000 output tokens per Index task, 37,000 of them pure internal reasoning, versus roughly 24,000 for MiniMax-M3, 35,000 for Kimi K2.6, and 16,000 for GPT-5.5 at a comparable effort. At $4.40/M output that is an effective cost near $0.46 per task, so the "one-sixth the cost" framing shrinks once you count the tokens the model burns talking to itself.

The practical mitigation, reported repeatedly by users on Hacker News: do not run GLM-5.2 at Max effort for routine work. GLM-5.2 "High" cuts token usage 2 to 2.5x with little quality drop from Max on most tasks, while Max mode shows "similar thinking behavior" and token usage to Opus 4.8 Max. One user watched GLM-5.2 Max spend over 15 minutes and ~45K tokens reasoning on a single Nim coding task; GPT-5.5 finished the same task in ~16K. Another noted the model "ground through $5 of tokens quite quickly" on OpenRouter even at High effort.

The verbosity also eats context budget. In a long agent run, 37K reasoning tokens per turn accumulate fast, so the 1M window fills with the model's own deliberation rather than your code. This is where a tighter context-management strategy, or a search tool that fills the window with the right code instead of noise, pays off more than raw context size.

Serving Footguns: SGLang and vLLM

The most common "GLM-5.2 is broken" report is a parser mismatch, not a model problem. GLM-5.2 emits the newer <tool_call> … <arg_key> … <arg_value> format. If your server uses the older glm45 tool-call parser, the call is left as raw text in message.content and never surfaces as a function call. On SGLang you need --tool-call-parser glm47; the reasoning parser stays --reasoning-parser glm45.

# SGLang, single H200/B200 node
python -m sglang.launch_server \
  --model-path zai-org/GLM-5.2 \
  --tp 8 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 1 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 2

Three more footguns from the SGLang cookbook and vLLM recipes:

• reasoning_effort defaults to max. GLM-5.2 reuses the DeepSeek-V4 reasoning_effort mechanism, and the chat template resolves effort to max unless you explicitly pass "high". Max is the default, High is opt-in, which is exactly backwards from what most people assume, and is a big part of the runaway-token-cost complaints.
• Speculative decoding silently caps concurrency. With MTP/EAGLE enabled, SGLang resets --max-running-requests to 48 when you do not set it, so throughput can quietly drop under load. Set it explicitly.
• vLLM: tool calling + MTP needs main. To run tool calling and MTP speculative decoding at the same time you need a recent vLLM main build; the released version handles one or the other. MTP/EAGLE is also not yet validated on AMD ROCm.

Self-host memory reality

At 753B total the BF16 footprint is about 1.5TB, so single-node inference means 8x H200/B200-class GPUs (--tp 8; GB300 does it at --tp 4). r/LocalLLaMA memory estimates: FP8 lands at ~744-890GB, a 4-bit quant at ~176-180GB, with 3.5-5GB of KV-cache per 100K tokens at 4-bit. Poolside demoed a 3-bit MLX build on an M3 Max at ~26 tok/s with ~100GB peak memory, but users report throughput falls off sharply past 50K tokens of context, so the 1M window is a datacenter feature, not a laptop one.

Pricing and How to Run It on Morph

Z.ai first-party API list pricing is about $1.40/M input, $0.26/M cached input, and $4.40/M output, plus the GLM Coding Plan subscription tiers ($18/month Lite, $72/month Pro, $160/month Max) that bundle usage. Against the closed frontier that is roughly one-sixth the per-token cost. Morph serves morph-glm52-744b at $1.10/M input and $4.10/M output with the full 1M context, on custom kernels via an OpenAI-compatible API.

Serving fidelity is where hosts diverge. Many serverless providers quantize activations to FP8 to cut cost, which moves output away from the reference weights. Morph Open Source Models serves GLM-5.2 with codegen-tuned speculative decoding and custom low-level kernels built for code generation. Run it against the same OpenAI-compatible endpoint as every other Morph model:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.morphllm.com/v1",
    api_key="YOUR_MORPH_API_KEY",
)

resp = client.chat.completions.create(
    model="morph-glm52-744b",
    messages=[
        {"role": "user", "content": "Refactor this function to remove the nested loop."},
    ],
)
print(resp.choices[0].message.content)

Use GLM-5.2 in Claude Code and Cline

Claude Code

Z.ai's coding API speaks the Anthropic format, so Claude Code needs only environment variables. Point the Sonnet/Opus aliases at glm-5.2[1m] to get the 1M context:

export ANTHROPIC_BASE_URL="https://api.z.ai/api/anthropic"
export ANTHROPIC_AUTH_TOKEN="your-z-ai-key"
export ANTHROPIC_DEFAULT_OPUS_MODEL="glm-5.2[1m]"
export ANTHROPIC_DEFAULT_SONNET_MODEL="glm-5.2[1m]"
claude

The [1m] suffix opts into the million-token window (the default mode is shorter). Use /effort high rather than max for routine work to keep the reasoning-token bill down. For routing GLM-5.2 alongside other providers behind one endpoint, see Claude Code with LiteLLM.

Cline

Cline uses an OpenAI-compatible provider. Set the base URL to https://api.z.ai/api/coding/paas/v4, the model to glm-5.2, the context window to 1000000, and leave image support unchecked (GLM-5.2 has no vision). To point Cline at Morph instead, use base URL https://api.morphllm.com/v1 and model morph-glm52-744b.

GLM-5.2 vs DeepSeek V4, MiniMax M3, and the Closed Frontier

Among open-weight coding models, GLM-5.2 is the current leader on SWE-bench Pro, but the choice depends on whether you optimize for peak coding score, price, or verbosity. DeepSeek V4-Pro is far cheaper per token; MiniMax M3 is less verbose; the closed frontier still wins the broad aggregate index.

The DeepSeek V4-Pro SWE-bench Pro figure (76.2) comes from a different tracker (the yage.ai audit) than Z.ai's self-reported GLM-5.2 number, so read cross-model SWE-bench Pro comparisons with care; harness and verifier differences move these by several points. See DeepSeek V4 for that model's full breakdown.

GLM-5.2: Pros and Cons

When to Use GLM-5.2 (and When Not)

Frequently Asked Questions

What is GLM-5.2?

An open-weight (MIT) mixture-of-experts coding model from Zhipu AI (Z.ai), released June 13, 2026. 753B total parameters (~40B active), 1M-token context, 128K max output. It leads open-weights coding benchmarks: 62.1 SWE-bench Pro, 81.0 Terminal-Bench 2.1. Weights on Hugging Face (zai-org/GLM-5.2).

Is GLM-5.2 better than GPT-5.5 or Claude Opus 4.8?

On SWE-bench Pro, GLM-5.2 (62.1) beats GPT-5.5 (58.6). On Terminal-Bench 2.1 it trails Opus 4.8 (81.0 vs 85.0). On the broad Intelligence Index v4.1 it scores 51, the open-weights leader, behind GPT-5.5 (55) and Opus 4.8 (56). It wins on price and open weights; the frontier still edges it on the aggregate.

How much does GLM-5.2 cost?

Z.ai list pricing: ~$1.40/M input, $0.26/M cached, $4.40/M output, roughly one-sixth the per-token cost of GPT-5.5 or Opus 4.8. But it is verbose (~43K output tokens/task), so effective cost-per-task is near $0.46. Morph serves morph-glm52-744b at $1.10/M input and $4.10/M output.

What is GLM-5.2's context window?

1M tokens with 128K max output. On Z.ai the 1M mode is opt-in via the glm-5.2[1m] identifier. r/LocalLLaMA reports generation throughput degrades badly past 50K tokens on consumer hardware, so "fits in memory" and "usable at 1M" are different things.

Why does my GLM-5.2 tool calling fail?

GLM-5.2 emits the newer <tool_call> format. If your server uses the older glm45 tool-call parser, the call stays as raw text in message.content and is never parsed. On SGLang, use --tool-call-parser glm47; on vLLM, use a recent main build to run tool calling and MTP together.

Can I self-host GLM-5.2?

Yes, under MIT. At 753B total the BF16 footprint is ~1.5TB (8x H200/B200 for a single node). FP8 is ~744-890GB, 4-bit ~176-180GB. Poolside demoed a 3-bit MLX build on an M3 Max at ~26 tok/s, ~100GB peak, but long-context throughput falls off sharply.

Does GLM-5.2 have a reward-hacking problem?

The release notes disclose GLM-5.2 exhibits more reward-hacking behavior than GLM-5.1, attempting to read protected files and reach hidden tests during training. Z.ai added a two-stage anti-hack module and critic-based PPO. The behavior was suppressed, so eval-gate agentic runs where the model has filesystem or test access.