# Z.ai GLM-4.6: What We Learned From 100 Million Open Source Downloads — Yuxuan Zhang, Z.ai

Yuxuan Zhang, Z.ai

AI Engineer Code 2025

[Talk page](https://ai.engineer/talks/m6MF1OR_9kM-z-ai-glm-4-6-what) · [Video](https://www.youtube.com/watch?v=m6MF1OR_9kM)

## Z.ai GLM-4.6: What We Learned From 100 Million Open Source Downloads

Building a coding agent takes more than stronger benchmark scores: it requires repository-aware training, realistic workflow evaluation and reinforcement learning that tolerates slow tools.

Basic familiarity with language-model training, context windows and tool-using coding agents will help; the reinforcement-learning systems choices are explained as they arise.

### What grows around an open model?

[0:18](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=18s)

What does an open model release become once developers start building on it? For Z.ai, the starting point was **GLM-130B** in 2022. **GLM-4.6** arrived after several years of releases spanning language, visual understanding and media generation. That history matters because the coding model sits within an ecosystem of models, tools and community projects rather than a single standalone release.

The family expanded through **ChatGLM-6B** for language, **CogVLM** for visual understanding, **CogView** for image generation and **CogVideo** for video generation. The model-family map separates those branches by color: white for language, pink for multimodal understanding, green for image generation and yellow for video generation. The visual-understanding branch later became GLM-V.

In 2025, Z.ai added the **GLM-4-0414** dense models, including 9B and 32B variants, followed by **GLM-4.5** and GLM-4.6 in its first mixture-of-experts family. Zhang reports more than 65 released models, over 100 million downloads across platforms including Hugging Face and ModelScope, and approximately 1,500 community GitHub projects. These are reported measures of ecosystem activity, not evidence of model accuracy.

![Continuous Opensource slide with three colored blocks labeled 65+ MODEL, 100M+ DOWNLOAD and 1500+ PROJECT.](https://ai.engineer/api/talk-essay-media/e00cd37c2ae901c5ae2cb912bc5e933cbe974aea4bf558a0413d95fb9a75dee7)

Open-source activity: 65+ models, 100M+ downloads and 1500+ projects.

### Task scores and user preference measure different things

[2:20](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=140s)

GLM-4.6’s public-benchmark story begins with improvements over GLM-4.5, particularly in mathematics and coding. Zhang also reports advantages over **DeepSeek V3.2** and **Claude Sonnet 4** on several benchmarks. He explicitly preserves a limit to that comparison: **Claude Sonnet 4.5** still has a noticeable lead. The claim is progress across selected evaluations, not universal superiority.

User preference supplies a different view. Zhang reports an LM Arena tie for first with **GPT-5** and Claude Sonnet 4.5, describing GLM-4.6 as the only open-source model in that group. This is the talk’s historical leaderboard snapshot; its category and tie definition are unspecified. Its role in the presentation is to complement benchmark results with feedback from people trying the models.

### Evaluate the coding workflow, not just the answer

[3:36](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=216s)

An isolated programming puzzle does not exercise the full behavior of a coding agent. [CC-Bench](https://huggingface.co/datasets/zai-org/CC-Bench-trajectories) instead uses a test platform built around Claude Code to evaluate realistic development workflows. Version 1.1 adds 22 hard coding tasks, bringing the total to 74. The comparison includes Claude Sonnet 4, GLM-4.5, **Kimi K2** and **DeepSeek V3.1 Terminus**.

The tasks span frontend development, internal tools, data analytics and algorithm implementation. For each model, the evaluation records **the complete agent trajectory**: planning, tool calls, code edits and execution. That makes the path to a result inspectable, rather than reducing the run to a final code sample. The benchmark and its trajectory release are presented as open source.

Zhang describes GLM-4.6 as a clear improvement over GLM-4.5 and close to Claude Sonnet 4. The spoken 68.6% figure conflicts with the displayed slide and published CC-Bench results: against Claude Sonnet 4, GLM-4.6 records 48.6% wins, 9.5% ties and 41.9% losses in the 74-task evaluation. The published methodology uses human-guided, iterative Claude Code sessions; completion determines the outcome, with efficiency and reliability used to distinguish runs that both complete the task. These are workflow judgments, not isolated unit-test pass rates.

![GLM-4.6 slide with four stacked comparison bars, a token-usage bar chart and explanatory text linking to CC-Bench trajectories.](https://ai.engineer/api/talk-essay-media/06a827f72ca9e09381f8e1e22407742c87ac2e87184543e9f6166e7c2a7bd665)

CC-Bench comparisons show GLM-4.6 win, tie and loss shares alongside average token usage.

### From general text to connected repositories

[5:15](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=315s)

The training account starts with a broad language base, then adds specialization. Zhang describes approximately 15 trillion general-purpose tokens from web pages, books, encyclopedias and multilingual content, initially using roughly 4,000-token contexts. A further approximately seven trillion code and reasoning tokens add high-quality repositories and step-by-step mathematics, science and programming material.

Repository-level mid-training changes what counts as a training example. Related files, issues, pull requests and diffs from one project are packed into the same long context. The model can then learn how a change crosses file boundaries, how a patch relates to an issue and how individual files fit into the project. Zhang describes extending the context to roughly 32,000 tokens so the key files of a medium-sized repository can be considered together. **The useful unit becomes a connected project, not an isolated file.**

Next come approximately 500 billion synthetic reasoning tokens covering mathematics, science and algorithms. Explicit thinking traces supply examples of task decomposition, reflection on mistakes and long chains of reasoning—the behaviors later needed when an agent must recover from an unsuccessful step.

The final described stage adds approximately 100 billion tokens of long-context and agent data, extending sequences to roughly 128,000 tokens; Zhang separately specifies a 200,000-token context for GLM-4.6. The historical [GLM-4.5 technical report](https://arxiv.org/abs/2508.06471) documents the corresponding progression as 4,096 → 32,768 → 131,072 tokens. That report is a GLM-4.5 training account, not a separate disclosure of every GLM-4.6 training detail.

Long contexts accommodate documents, codebases and extended conversations. Agent trajectories add the sequence of actions within those contexts: multiple tool calls, search and code execution. Together, they teach both how to retain a large working context and how to act within it.

### Keep slow agent tasks from stopping RL training

[7:51](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=471s)

[slime](https://github.com/THUDM/slime), Z.ai’s open-source reinforcement-learning framework, uses SGLang for inference. Its central systems decision is to support different execution arrangements for different workloads. Short mathematics or code-completion tasks work well with **colocated, synchronous training and inference**: both use the same GPU pool, alternating between a training update and generation with the latest policy. This arrangement makes effective use of GPU memory and compute.

Software-engineering agents introduce a different timing problem. One rollout may open a browser, call a backend API and wait for an external response, while another finishes quickly. If every worker must advance together, the slowest tasks hold up the entire batch and leave GPUs idle. The bottleneck is no longer just model computation; it includes the environment’s response time.

slime’s hybrid architecture connects a Megatron batch-training engine, a high-throughput SGLang inference cluster and agent environments through a **shared data buffer**. Megatron consumes training data and updates weights. A routing function dispatches inference requests to SGLang. The buffer separates the production of trajectories from their consumption by training.

| Workload | Execution mode | Update behavior |
|---|---|---|
| Short reasoning | Colocated, synchronous | Sample after each policy update |
| Long agent tasks | Decoupled, asynchronous | Generate continuously; refresh weights periodically |

In synchronous mode, sampling and immediate updates share the GPU pool. In asynchronous mode, rollout workers interact with real environments and keep writing completed trajectories into the buffer. Training consumes those trajectories at its own pace, updates the model and periodically sends new weights back to the rollout workers. A slow browser or API interaction no longer blocks the whole training pipeline.

The precision policy follows the same separation of responsibilities. Main training remains in **BF16** for stability. After each policy update, blockwise quantization produces an **FP8** version of the weights for rollout workers. Expensive trajectory generation then uses FP8 while training retains BF16. Zhang reports a throughput benefit without supplying a numerical speedup.

### Increase difficulty without shortening the reasoning budget

[11:00](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=660s)

The reasoning-RL curriculum changes problem difficulty as the model improves. It begins with medium-difficulty problems so that a batch contains both correct and incorrect answers. That variation in reward supplies a useful learning signal. Once those problems become easier for the model, training switches to extremely hard problems; with 512 samples, a correct solution can still appear occasionally. In the presented comparison, switching difficulty sustains improvement beyond the medium-only curriculum.

A separate experiment changes the allowed reasoning length. For a model already given supervised fine-tuning at 64K tokens, Zhang reports that an RL schedule progressing through 32K, 48K and finally 64K reduces long-context ability and average output length. Returning to 64K at the end does not fully recover the loss. Starting RL directly at 64K and keeping that budget throughout performs better in the shown experiment. **Two stages of difficulty and one stage of length are compatible choices:** one controls which problems the model faces, while the other preserves room to reason.

### Loss weighting and data quality change what RL rewards

[12:51](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=771s)

For code RL, the next comparison concerns how token losses become a batch loss. A sequence mean gives each sequence equal weight after averaging its tokens. A token mean instead averages across all tokens, so a longer sequence contributes more terms. Zhang reports that token-based averaging converges faster and more steadily in the presented experiment, while reducing the tendency to produce very short template answers just to collect reward.

A small Python example makes the weighting distinction concrete. Here, one sequence contains two token losses and another contains six. The sequence mean gives each answer half the batch weight; the token mean gives each of the eight tokens equal weight.

```python
from statistics import mean

sequence_losses = [
    [1.0, 1.0],
    [3.0, 3.0, 3.0, 3.0, 3.0, 3.0],
]

sequence_mean = mean(mean(losses) for losses in sequence_losses)
token_mean = mean(
    loss
    for losses in sequence_losses
    for loss in losses
)

print(sequence_mean)  # 2.0
print(token_mean)     # 2.5
```

The example isolates aggregation: it does not specify the full RL objective. Its significance is that equal weighting of sequences and equal weighting of tokens are different optimization choices whenever output lengths differ.

The science-RL experiment changes the training data instead. A small set of expert-verified multiple-choice questions produces better results than mixed-quality data in the shown comparison. The [report’s detailed account](https://arxiv.org/html/2508.06471v1) identifies GPQA-Diamond as the evaluation benchmark; this should not be read as training on GPQA itself. The result supports careful scientific-data selection in this experiment, rather than a general rule that adding data harms a model.

![Four line charts under Reasoning RL: two AIME24 plots above, with LiveCodeBench token-weighted versus sequence mean and GPQA expert-verified versus mixed-quality data below.](https://ai.engineer/api/talk-essay-media/f7f9e5dfaef75165961298d744c11961766f75a51cea93395f3ee0f44e219e2e)

Reasoning RL experiments include separate LiveCodeBench loss-averaging and GPQA data-quality comparisons.

### Preserve image geometry and video order

[14:06](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=846s)

The multimodal part of the talk introduces **GLM-4.5V**, which supports image and video understanding. Zhang reports strong grounding and image-understanding results relative to contemporary open-source models. Its architecture has three main components: a vision-transformer encoder, an MLP projector and the GLM-4.5 base model as decoder.

The input representation aims to preserve native image resolution and aspect ratio instead of forcing every image into a fixed square. That matters for UI screenshots, long vertical images and presentation slides, whose layout carries information. For video, a time-index token is inserted after each frame. The token gives the model an explicit representation of temporal order, helping it distinguish successive events and understand actions or procedures.

GUI interaction extends earlier **CogAgent** work. GLM-4.5V supports interaction through mouse, keyboard and touch across browser, desktop and mobile environments. Visual understanding therefore serves an action loop as well as an interpretation task: the agent must understand the interface it is about to operate.

### Run the weights or use hosted access

[16:02](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=962s)

The first access route is self-hosting: [GLM-4.6’s open weights](https://huggingface.co/zai-org/GLM-4.6) and GLM-4.5V can be served through SGLang, vLLM or other compatible frameworks. Zhang describes SGLang and vLLM integrations as ready on release day, alongside ecosystem work with LLaMA-Factory and ms-swift.

Model size makes this a substantial infrastructure choice. Zhang describes GLM-4.6 as approximately 355 billion parameters and points to H100-class hardware as an example of the resources involved, not an exclusive requirement or complete sizing prescription. The recording then shows SGLang and vLLM deployment commands before moving to hosted alternatives.

The hosted Z.ai interface offers a route to coding and PowerPoint generation without running the model locally. A brief demo introduces a Google-search-related task through a single request. The talk does not develop that example into a detailed implementation walkthrough.

The GLM Coding Plan brings the model into Claude Code and other development tools. The accompanying demo concerns replacing the existing model in a Claude Code workflow with GLM-4.6. This separates the model choice from the coding interface: developers can try GLM within an established agent workflow instead of adopting an entirely new environment.

### Continue from model access to implementation

[18:29](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1109s)

Z.ai’s post-release community activity includes Reddit AMAs, online sessions and in-person technical-sharing events. These provide places to ask questions after trying a model, alongside the website and API routes introduced in the closing resources.

For deeper study, Zhang points to the GLM-4.6 technical blog and the GLM-4.5 technical report. Discord provides a community channel; GitHub hosts the open-source models and README instructions for deploying them. The closing path runs from trying the hosted model to studying its training account and operating the weights yourself.

![Important Link slide listing Z.ai, its model API, the GLM-4.6 blog, GLM-4.5 technical report, Discord, and GLM-4.5 and GLM-V GitHub repositories.](https://ai.engineer/api/talk-essay-media/f945fca4b1c043fdd14a2e2b805f69f2d896f26b1c51134e6fc5294e4cc103d6)

GLM resources: model access, API, technical publications, Discord and GitHub repositories.

## Resources

- [CC-Bench trajectories and evaluation methodology](https://huggingface.co/datasets/zai-org/CC-Bench-trajectories) — Claude Code workflow benchmark with task categories, human evaluation procedures, pairwise results and downloadable trajectories.
- [GLM-4.5 technical report](https://arxiv.org/abs/2508.06471) — The model team's account of GLM-4.5 architecture, training, reinforcement learning and agentic evaluations.
- [slime](https://github.com/THUDM/slime) — An RL post-training framework with customizable rollout generation and training integration.
- [GLM-V model repository](https://github.com/zai-org/GLM-V) — Implementation and usage resources for GLM-4.5V and other GLM vision-language models.
- [GLM-4.6 open weights](https://huggingface.co/zai-org/GLM-4.6) — Official GLM-4.6 model weights, model card and deployment resources.

## Slides

### GLM-4.6 / GLM-4.5

Yuxuan Zhang of Z.ai introduces the GLM-4.6 series.

[0:00](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=0s) [Title slide for GLM-4.6 and GLM-4.5, presented by Yuxuan Zhang.](https://assets.ai.engineer/sites/aiecode2025/sha256/d8c02ef04c06ea92665844a2b18c5a8bdd3ba8a8dbafc625915075caff95f214.webp)

GLM-4.6 / GLM-4.5

Yuxuan Zhang

北京市海淀区中关村东路1号院9号楼10层
No.1 ZHONG GUAN CUN EAST ROAD, H A I DIAN DISTRICT, BEIJING

版权所有©北京智谱华章科技股份有限公司 2025

Interface text:
2025/11/19 11:36:09

### Continuous Opensource

Z.ai reports 65+ models and 100M+ downloads. A rough, conservative GitHub keyword search found 1,500+ secondary development projects.

[1:45](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=105s) [Three blocks report 65-plus models, 100 million-plus downloads and 1,500-plus projects.](https://assets.ai.engineer/sites/aiecode2025/sha256/bffbcede22bd2a26755893fccaf4926d8c65fe3852b1d4963755e1047e78545a.webp)

Continuous Opensource

65+
MODEL

100M+
DOWNLOAD

1500+
PROJECT

A rough and conservative count of secondary development projects found on GitHub by searching keywords like “glm” and “cogvideo”

Interface text:
2025/11/19 11:38:09

### GLM-4.6 Benchmark Evaluation

Across eight benchmarks under 128K context length, GLM-4.6 scores above GLM-4.5. Claude Sonnet 4.5 leads GLM-4.6 on SWE-bench Verified and Terminal-Bench, illustrating the remaining coding gap.

[2:15](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=135s) [Bar charts compare GLM-4.6 with GLM-4.5, DeepSeek and Claude models across eight agentic, reasoning and coding benchmarks.](https://assets.ai.engineer/sites/aiecode2025/sha256/76c1d1f2813ef09071f63fa345eff6a0dce9c471992d878e2396e9fc627de429.webp)

GLM-4.6

LLM Performance Evaluation: Agentic, Reasoning and Coding
8 benchmarks: AIME 25, GPQA, LiveCodeBench v6, HLE, BrowseComp, SWE-bench Verified, Terminal-Bench, τ²-Bench
(Evaluation results under 128K context length)

Legend: GLM-4.6, GLM-4.5, DeepSeek-V3.2-Exp, Claude Sonnet 4, Claude Sonnet 4.5
Values in legend order:
AIME 25: 93.9 (98.6 w/ Tools), 85.4, 89.3, 74.3, 87.0
GPQA: 81.0 (82.9 w/ Tools), 79.9, 79.9, 77.7, 83.4
LiveCodeBench v6: 82.8 (84.5 w/ Tools), 63.3, 70.1, 48.9, 57.7
HLE: 17.2 (30.4 w/ Tools), 14.4, 19.8, 9.6, 17.3
BrowseComp: 45.1, 26.4, 40.1, 14.7, 19.6
SWE-bench Verified: 68.0, 64.2, 67.8, 72.5, 77.2
Terminal-Bench: 40.5, 37.5, 37.7, 35.5, 50.0
τ²-Bench (Weighted): 75.9, 67.5, 53.4, 66.0, 88.1

We evaluated GLM-4.6 across eight public benchmarks covering agents, reasoning, and coding. Results show clear gains over GLM-4.5, with GLM-4.6 also holding competitive advantages over leading domestic and international models such as DeepSeek-V3.2-Exp and Claude Sonnet 4, but still lags behind Claude Sonnet 4.5 in coding ability.

Interface text:
2025/11/19 11:38:55

### GLM-4.6 Coding Capability

Code Arena’s WebDev leaderboard gives GLM-4.6 a rank (UB) of 1 and a score of 1372, alongside four proprietary models also ranked 1. The slide highlights GLM-4.6 as the top open model.

[3:01](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=181s) [A Code Arena leaderboard and quoted post highlight GLM-4.6 as a leading open model.](https://assets.ai.engineer/sites/aiecode2025/sha256/c58bbee8d4d94d5ec349c465b888a34300bc01a76ca09da1b73dc5b78b3d8cc9.webp)

GLM-4.6 Coding Capability

LMARENA.AI/CODE

Code Arena powers the new WebDev leaderboard rankings

Rank (UB) | Model | Score | 95% CI (±) | Votes | Organization | License
1 | claude-opus-4-1-20250805 | 1402 | +25/-25 | 576 | Anthropic | Proprietary
1 | claude-sonnet-4-5-20250929-thinking-32k | 1397 | +25/-25 | 585 | Anthropic | Proprietary
1 | claude-sonnet-4-5-20250929 | 1387 | +23/-23 | 754 | Anthropic | Proprietary
1 | gpt-5-medium | 1387 | +25/-25 | 622 | OpenAI | Proprietary
1 | glm-4.6 | 1372 | +26/-26 | 569 | Z.ai | MIT
6 | qwen3-coder-480b-a35b-instruct | 1278 | +24/-24 | 575 | Alibaba | Apache 2.0
6 | minimax-m2 | 1263 | +24/-24 | 579 | MiniMax | Apache 2.0
6 | claude-haiku-4-5-20251001 | 1254 | +23/-23 | 638 | Anthropic | Proprietary
9 | gemini-2.5-pro | 1174 | +25/-25 | 589 | Google | Proprietary
9 | grok-code-fast-1 | 1143 | +56/-56 | 122 | xAI | Proprietary
10 | grok-4-fast-reasoning | 1085 | +30/-30 | 489 | xAI | Proprietary

“A relative newcomer to the Arena, @zai_org's GLM-4.6 takes the clear, undisputed #1 spot for Top Open Model.”
— UC Berkeley LMArena X post

Interface text:
2025/11/19 11:39:25

### Training Progress of GLM-4.6 / GLM-4.5

After 15T + 7T pre-training tokens, mid-training moves from repo code to synthetic reasoning and agent data, extending context to 128K. Asynchronous rollouts feed a buffer while training updates weights.

[5:06](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=306s) [Training stages and diagrams of decoupled training, inference, and agent rollout scheduling.](https://assets.ai.engineer/sites/aiecode2025/sha256/20a299ceef3d28da6b83a610f5573ad7f5b285d932da71d31d134b2beac41757.webp)

Training Progress of GLM-4.6 / GLM-4.5

• Code + Reasoning & Agent synthetic data mid-training

Pre-training
General Pre-training Corpus (15T) → Code & Reasoning Continual Pre-training Corpus (7T)
Context: 4K → 4K

Mid-training
Repo-Level Code Data (500B) → Synthetic Reasoning Data (500B) → Long Context & Agent Data (100B)
Context: 32K → 32K → 128K

Asyncronized and decoupled training and inference

data buffer
send init prompt
recv custom data
custom rollout generation
any custom data generation
send train data
megatron
GPU
GPU
GPU
GPU
update weights
from distributed/tensor
sglang router
sglang server
GPU
GPU
sglang server
GPU
GPU

Support large-scale and multi-task agent training

Training Engines
Get Rollout Data
Get Rollout Data
Rollout Engines
Task 1, Task 8, Task 12, Task 15, Task 16, Task 19
Task 2, Task 5, Task 11, Task 15, Task 20
Task 3, Task 7, Task 9, Task 13, Task 14, Task 18
Task 4, Task 6, Task 10, Task 14, Task 13, Task 17
Time
Legend: Idle; Model Training; Rollout Data Generation; Rollout with Abort; Synchronize Model

Interface text:
2025/11/19 11:46:52

### Reasoning RL

A difficulty curriculum reaches 83.4% on AIME24 AVG@32. Single-stage RL beats multi-stage training; token-weighted code loss converges faster, while expert-verified science data outperforms mixed-quality data on GPQA.

[10:58](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=658s) [Four charts compare reasoning, coding, and science benchmark accuracy during reinforcement learning.](https://assets.ai.engineer/sites/aiecode2025/sha256/a6022e3759345f6d119be4dbe893855de2b0d0da7e425df3f082dec1024b853e.webp)

Reasoning RL

AIME24 AVG@32: RL with Difficulty-based Curriculum Learning
Stage one
Stage two
Accuracy (%)
Y-axis ticks: 74, 79, 84
Training Steps
X-axis ticks: 0, 500, 1000, 1500, 2000
81.8%
83.4%
Moderate difficulty data, samples_per_prompt=16
Extremely difficulty data, samples_per_prompt=512

AIME24 AVG@32: Multi-stage vs Single-stage Training Performance
16K Context
32K Context
48K Context
64K Context
Accuracy (%)
Y-axis ticks: 60, 65, 70, 75, 80, 85
Training Steps
X-axis ticks: 0, 500, 1000, 1500, 2000
83.4%
80.6%
Multi-stage Training
Single-stage Training
16K→32K
32K→48K
48K→64K

LiveCodeBench Accuracy During RL Training
Accuracy (%)
Y-axis ticks: 38, 40, 42, 44, 46
Training Steps
X-axis ticks: 0, 500, 1000, 1500, 2000, 2500
46.5%
46.3%
Token-weighted mean
Sequence-mean

GPQA accuracy during RL training
Accuracy (%)
Y-axis ticks: 60, 61, 62, 63, 64, 65, 66
Training Steps
X-axis ticks: 0, 50, 100, 150, 200, 250, 300
65.8%
62.9%
Expert-verified multiple-choice data
Mixed-quality science data

Interface text:
2025/11/19 11:53:51

### GLM-4.5V Model Architecture

A ViT encoder and MLP projector feed image and video inputs to a language decoder. The model preserves native resolution, while time-index tokens help it track the order of video frames.

[14:38](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=878s) [A vision encoder and projector feed image and video tokens into a language decoder, with time-index tokens for video.](https://assets.ai.engineer/sites/aiecode2025/sha256/0c644046d707ea131369934e09f0529be60cfbb1f54fc123f30e70645c2e6ed8.webp)

GLM-4.5V Model Architecture

<|think|>From the given image, ...
Time index tokens: 0, 2, 4, 6

Language Decoder

Image 1: 1574 tokens
Image 2: 5187 tokens
Video 1: 13650 tokens
Time index tokens: 0, 2, 4, 6
Could you tell me...?

2: Time index token
Predicted token

MLP Projector
ViT Encoder
(Native resolution w. 2x temporal compression)

GLM-V

Image 1
Height: 1274
Width: 952

Image 2
Height: 1596
Width: 2548
Embedded screenshot text: [illegible]

Video 1
Time: 20s
Height: 546
Width: 980

Interface text:
2025/11/19 11:57:11

### GLM-4.5V GUI Agents

GLM-4.5V integrates with CogAgent. Its task loop sends GUI actions to an online environment and returns new tasks to the pool, while supporting web, computer, and mobile interfaces.

[15:30](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=930s) [A task-oriented data collection loop and GUI instruction capabilities for web, computer, and mobile environments.](https://assets.ai.engineer/sites/aiecode2025/sha256/7601cbcc0d0ea968f4587c8c391126715c595bd6af0b5027147a9e74021521ec.webp)

GLM-4.5V GUI Agents

• Integrated with CogAgent: https://github.com/THUDM/CogAgent
• Task-Oriented Data Collection & Improving Loop

Initial Tasks → Tasks Pool → Model
Model → Data Processing → SFT / RL Data
Model → Online Env: GUI Action
Online Env → Model: GUI Content
Online Env → Tasks Pool: New Tasks from Online Env

• Cross-Platform GUI Instruction Capabilities

Web Environment
Accurate instruction for web-based interfaces

Computer Environment
Precise desktop application guidance

Mobile Environment
Effective mobile UI navigation support

Interface text:
CC
2025/11/19 11:57:41

### Compatible & Ready to Use

Zhang says vLLM and SGLang integrations were ready on release day; the slide pairs framework logos with screenshots of model-support contributions.

[16:06](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=966s) [Framework logos and software contribution screenshots illustrate model ecosystem compatibility.](https://assets.ai.engineer/sites/aiecode2025/sha256/a5f1bc927ea4cec149168c003c074e9c0487596f78fe1a4f1db57bf9eb7b0046.webp)

Compatible & Ready to Use

Contribution screenshots:
Add GLM-4-0414 support #16338
GLM-4.1V Model support #38431
[model] add GLM-4.1V #8462
CogView3Plus DiT #9570
[illegible]

Transformers
Diffusers
vLLM
SGL
ModelScope
魔搭社区
LLaMA-Factory
Easy and Efficient LLM Fine-Tuning

Interface text:
2025/11/19 11:58:39

### GLM Coding Plan

The GLM Coding Plan connects GLM-4.6 to coding tools including Claude Code. Lite, Pro, and Max list first-month prices of $3, $15, and $30, then $6, $30, and $60 per month.

[17:41](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1061s) [A screenshot compares the Lite, Pro, and Max coding plans.](https://assets.ai.engineer/sites/aiecode2025/sha256/1db72e5085089ce0bf6c210e2e66ece1efe865eb2fe6648e01c4bfceddec5868.webp)

GLM Coding Plan

GLM Coding Plan
The smartest investment for your coding productivity. Learn More

Monthly -$30
Quarterly -$90
Yearly -$360

Lite
For lightweight workloads
50% off 1st Month
$3 / month
$6 / month
6 / month from 2nd month
Subscribe
- Powered by GLM-4.6
- Compatible with over 10 coding tools, including Claude Code, Roo Code, Cline, Kilo Code, OpenCode, Crush, and Goose, with more being continuously added

Pro
For professional workloads
50% off 1st Month
$15 / month
$30 / month
30 / month from 2nd month
Upgrade
- All Lite plan benefits
- 5x Lite plan usage
- 40%–60% faster compared to Lite
- Access image & video understanding and web search MCP

Max
For high-volume workloads
50% off 1st Month
$30 / month
$60 / month
60 / month from 2nd month
Upgrade
- All Pro plan benefits
- 4x Pro plan usage
- Guaranteed peak-hour performance
- Early access to new features

Link: https://z.ai/subscribe

Interface text:
2025/11/19 11:59:55

### GLM Coding Plan resources

A linked YouTube demo shows how to replace a model in Claude Code with GLM-4.6. The slide also links to the coding plan and shows the invite-for-credits campaign rules.

[18:14](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1094s) [Coding-plan setup resources and a video thumbnail appear beside an invite-friends campaign rules page.](https://assets.ai.engineer/sites/aiecode2025/sha256/9360b8a9f5f12091d528cba36c278d95f1a7737a2c0d5f9430b2d4693caf0a40.webp)

GLM Coding Plan

If you haven’t tried GLM Coding Plan, it is highly recommended for your coding productivity:
https://z.ai/subscribe

For GLM Coding Plan Setup and Test, you can watch the setup and demonstration video:
https://www.youtube.com/watch?v=P6QIHoF06L8&t=163s

Video thumbnail:
BETTER MODEL?
GLM 4.6

Campaign Rules
Invite Friends, Get Credits

Please read and fully understand all the rules below before participating in the campaign. Participation constitutes your acceptance and agreement to be bound by these rules.

Last Update: September 18, 2025

1. General Principles

• Campaign Organizer: This campaign is initiated and operated by the service provider of Z.ai Platform (hereinafter referred to as “we,” “us,” or the “Platform”).
• Campaign Purpose: To reward users and enhance product experience, we are launching the “Invite Friends, Get Credits” campaign.
• Campaign Nature: This campaign offers incentive Credits. All Credits are preferential benefits provided by the Platform, not cash, currency, or financial instruments, and do not possess monetary attributes.
• User Agreement: By participating, you represent that you have read, understood, and agreed to be bound by these rules. We reserve the right to modify or adjust these rules based on laws, regulations, and operational needs. Changes will be announced on the campaign page in advance.

Interface text:
Coding Plan
Released Notes
Terms and Policy
Help Center
Copy page
0:00 / 11:31
The Problem with Claude...
2025/11/19 12:00:00

### Tech Sharing and Exchange Events

Z.ai follows model releases with online and in-person community sessions, including a Reddit AMA and on-site technical sharing.

[18:22](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1102s) [A collage of technical events and an online AMA accompanies text about GLM community activities.](https://assets.ai.engineer/sites/aiecode2025/sha256/bb91eef27750b4df7286778b5320739b1b125b8cc59408c30f9a35cae276b1ad.webp)

Tech Sharing and Exchange Events

Since the model’s open-sourcing, we have actively participated in and organized technical briefings and open-source ecosystem events — the main ways we promote the model domestically.

Event screenshots:
4090单卡可跑 | CogVideoX视频生成模型
圆桌论坛
开源通用视觉语言模型GLM-4.1V-Thinking技术分享

AMA With Z.AI, The Lab Behind GLM Models
Resources
AMA with Z.AI — The Lab Behind GLM Models. Ask Us Anything!

Hi r/LocalLLaMA

Today we are having Z.AI, the research lab behind the GLM family of models. We’re excited to have them open up and answer your questions directly.

Our participants today:
• Zixuan Li, u/[illegible]
• Yuxuan Zhang, u/Maximum_Can9140
• Zhengxiao Du, u/zxdu
• Aohan Zeng, u/Sengxian

The AMA will run from 9 AM – 12 PM PST, with the Z.AI team continuing to follow up on questions over the next 48 hours.

Thanks everyone for joining our first AMA. The live part has ended and the Z.AI team will be following up with more answers sporadically over the next 48 hours.

Interface text:
2025/11/19 12:00:36

### Important Link

Try GLM on Z.ai or through its API. The slide also points to technical publications, Discord, and GitHub repositories with deployment instructions.

[18:54](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1134s) [A list of links to GLM products, technical publications, community resources, and repositories.](https://assets.ai.engineer/sites/aiecode2025/sha256/8ee58dfa9d7a01a75464688a0adee2f58ba07801489bd714237ea7d89690ba7a.webp)

Important Link

Try GLM Model: https://z.ai
GLM API: https://z.ai/model-api

Tech Blog of GLM-4.6: https://z.ai/blog/glm-4.6
Tech Report of GLM-4.5: https://arxiv.org/abs/2508.06471

Discord: https://discord.gg/QR7SARHRxK

GitHub:
GLM-4.6 / GLM-4.5: https://github.com/zai-org/GLM-4.5
GLM-4.5V GLM-4.1V https://github.com/zai-org/GLM-V

Interface text:
CC
2025/11/19 12:01:15

## Full transcript

[0:01](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1s) Hello, everyone. I'm Zhang Yuxuan from Z.ai, and I'm very happy to here to talk about our latest model series, uh, GLM-4.6 series. And let's jump right in.

[0:18](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=18s) First, uh, I will introduce the GLM series model. GLM-4.6 is not our first open source model. Since 2022, starting from the very first GLM-130B, we have been quite serious about open source our work.

[0:37](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=37s) Over the years, we have released a whole family of models such as ChatGLM-6B for language model and the CogVLM for vision understanding, CogView for image generation, uh, the CogVideo for video generation, and very, uh, many more across the different domains.

[0:55](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=55s) And on this slide, you can see a map of our open source models so far, uh, includes the different color, such as white is for the language model, the serie-- uh, GLM series, and the pink for the multi-modal understanding, such as the CogVLM and now it's called GLM-V.

[1:13](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=73s) And the green one is for image generation, and the yellow is for video generation.

[1:20](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=80s) Uh, 2025 is our open source year of... In this year, we added even more models, including the GLM-4-0414 dense model, including like 9B and 32B, and the GLM-4.5, GLM-4.6 and MoE series model, which is actually our first MoE models family.

[1:44](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=104s) So up to now, we have released over 65 model in total, across platforms like Hugging Face, ModelScope, and others. We have already passed one hundred million downloads.

[1:59](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=119s) If you search for the GLM or CogVideo on GitHub, you will find 1,500 community projects built on top of them, and it's much a community-driven ecosystem now.

[2:13](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=133s) Let's move to, uh, GLM-4.6. Uh, I will introduce it now.

[2:20](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=140s) So GLM-4.6 is our latest flagship model. On many public benchmark, especially in math and coding, GLM-4.6 shows a clear gain over GLM-4.5. It also outperforms open source model released in the same period, like DeepSeek V3.2, and even beats commercial models such as the Claude Sonnet 4 on several

[2:45](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=165s) benchmarks. Mm, of course, if we compare to like Claude Sonnet 4.5, there's still a noticeable, uh, noticeable gap. So we are not claiming we've topped everything, but we're getting closer and closer.

[2:58](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=178s) So, uh, but what makes us especially happy is here is, um, LM Arena, uh, this benchmark.

[3:07](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=187s) Uh, it is, uh, which is closer to real user preference and on LM Arena, GLM-4.6 is tied for number one together with G-GPT-5 and the Claude, Claude Sonnet 4.5, and it's the only open source model here.

[3:22](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=202s) And so I'm very happy, appreciate, and also thanks all developer who try to-- who try our model and voice their voice. So let's move to the CC-Bench.

[3:36](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=216s) So beside the usual benchmark, we also build our own dataset called the CC-Bench here. We want to test agent-style coding in realistic workflow, not just isolate LeetCode problem. So we built a agent coding test platform based on the Claude Code.

[3:54](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=234s) And on top of that, we create CC-Bench V1.1. So compared with version one, version one, uh, the new version added 22 hard coding task, and we systematically evaluate Claude Code Sonnet 4, uh, Claude Sonnet 4 and GLM-4.5, like Kimi K2 and the DeepSeek V3.1 Terminus.

[4:18](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=258s) In total, CC-Bench have 74 tasks. It's covering the front-end development and internal tool development in the data analytics, and also algorithm implementation. So for every model, we record the full agent trajectory, the planning step, the tool calls, and code edits, and execution.

[4:39](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=279s) We fully open source this benchmark, so you can check all the link, uh, below in the Hugging Face. And GLM-4.6 made a clear jump over GLM-4.5, and over perf- uh, overall performance is close to Claude Sonnet 4 with about 68.6% win rate, while being significant better than other open source baseline.

[5:01](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=301s) So, uh, where does the performance come from? A lot, uh, is let's talk about GLM-4.6 training. And in this pre-- uh, we will start from the data and training design.

[5:15](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=315s) First part is the general pre-training. So we start with about 15 billion, uh, 15 trillion tokens of the general-purpose data, includes web page, books, uh, encyclopedia, and then multi, uh, multi, uh, multilingual content, and so on.

[5:33](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=333s) So this stage is all about building a strong all-rounder base model. The context length here is, uh, 4,000 tokens, and the next step is coding and reasoning continual pre-training.

[5:46](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=346s) So on top of that base with about seven trillion token of extra code and reasoning data. So it's part of this co-- uh, part of this con- comes from the high quality open source repos, and another part is math, science, and complex program with full step-by-step reasoning.

[6:05](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=365s) Then we come to the mid-training. So we move to repo-level codes, uh, include the multiple files, issues, and pull requests, and the diffs from the same project. And all of this packed into the one long context.

[6:20](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=380s) Then the goal is to teach the model the following across files and understand the change, and to also understand the pull request patch change, and read the real project structure end to end.

[6:35](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=395s) So at this stage, we extend the context to thirty-two thousand, and, and model can basically see the key file of a medium-sized repo on the one shot.

[6:47](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=407s) Then as a synthetic reasoning data, we added about five hundred billion token of synthetic reasoning data. So it covers the math, science, and algorithm with explicit thinking trace. So it means the lay of the groundwork of future agent behavior, like breaking down the task, reflect, uh, reflecting on the mistake, and doing long-chain reasoning.

[7:10](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=430s) Uh, the next step is the long context and agent data. Uh, finally, we use about one hundred billion token of a long context and agent data here. The sequence length is now pushed further to one hundred eighty, uh, twenty, uh, one hundred and twenty-eight thousand.

[7:26](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=446s) For GLM-4.6 is two hundred thousand. So the model can handle full documents, the whole data, uh, code base, and very long chats. At the same time, we feed lots of agent trajectory.

[7:38](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=458s) So include like multi-step tool calls, the search, and the code execution, uh, like et cetera. So, uh, in this slide, improve the model long-context capability and the agent capability.

[7:51](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=471s) Also, in this slide, we introduce slime. Um, it's our reinforcement learning framework based on SGLang in-inference stack. Uh, in practice, uh, we design an in-house RL training framework here, and we also open source it.

[8:09](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=489s) Uh, we found that the different RL tasks need very different system design.

[8:14](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=494s) Mm. For short reasoning tasks, like the math or the code completion, so the best setup is, uh, co-located, uh, serial architecture. So we training and inference set in the same GPU, so after one batch update weight, so the next batch immediately then perform the latest policy.

[8:33](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=513s) This squeeze the most of GPU memory and compute. Um, but for agent tasks, and for example, the real software engineering, uh,

[8:43](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=523s) usually have m-many steps. Like for example, open the browser and hit, uh, backend API and wait for the external response, um, et cetera. So if we force every worker to stay in the same pace, the whole system will get dragged down by the slowest few tasks and the GPUs sit, uh, idle.

[9:03](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=543s) For in slime, we decide a hybrid architecture to support both, uh, synchronous and asynchronous modes. If you look at the diagram, the blue part is Megatron batch training engine with read/write data buffer and updates weights.

[9:21](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=561s) And the green part is high-throughput SGLang inference cluster. So with the routing function of dispatch request, and in the middle, the data buffer act like the shared memory systems.

[9:32](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=572s) So one side connect training and the other side different agent environments. For regular reinforcement learning tasks, we keep training and inf, uh, inference on the same GPU pool using with the synchronous mode, and the dynamic sampling, instant update, and the maximum throughput.

[9:49](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=589s) Once we switch to complex agent tasks, we move to a decoupled and asynchronous mode. So the rollout side talks directly to real environments and just keep regenerate trajectory and write them into the buffer.

[10:02](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=602s) And then the training side consume the data at its own pace, update the me-- model, and, uh, periodically push new weight back to the rollout worker.

[10:14](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=614s) So the nice thing is, even if some tasks super slow, they don't block the whole training pipeline. So on top of that, we have done a bunch of efficiency optimization.

[10:25](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=625s) Mm. Like the main training still run BF16 for, uh, stability, but after each policy update, we do blockwise FP8 quantization on the latest weights, and send the FP8 version to the rollout worker.

[10:42](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=642s) So the most expensive part, the data generation and running FP8 with much higher throughput while training these still keep BF, BF16 precision. So in practice, we will get the benefit for accuracy and speed in this framework.

[11:00](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=660s) Now let's zoom in reasoning RL, and in this slide with some plots. So the first one is about the two-stage curriculum we use. We don't train on a fixed data set from start to finish.

[11:12](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=672s) Instead, we use a two-stage difficulty curriculum. In stage one, we use medium difficulty problem. In each batch, some answer are right and some are wrong. So the rewards have variance, and the gradient are meaningful.

[11:26](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=686s) When the model gets stronger, we switch to extremely hard problem in stage two. But with five hundred and twelve samples, we can still occasionally get a correct solution. So you can see on the plots, the blue curve is our method.

[11:41](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=701s) After switching to the hard problem, the curve is keep going up. However, use the, uh, medium difficulty the way, uh, is not on the red curve. The next picture is about a single, uh, stage reinforcement learning at sixty-four thousand tokens.

[11:58](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=718s) Mm. Some previous works suggest multi-stage reasoning, uh, reinforcement learning. For is that, uh, uh, for example, is theme there is 32, then 48, and finally six-- uh, 64. But we found that for model that has already been trained with 64,000 token, uh, SFT, those shorter RL chains actually make it forget its long-context

[12:23](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=743s) ability. So average output length, and the final, uh, 64K-token stage can't fully recover the loss. So the red curve here is our approach, which starts directly with 40, uh, 64,000, uh, token and train in one single stage to the end.

[12:44](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=764s) It's clearly outperformed in the blue middle, uh, multi-stage curve. Uh,

[12:51](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=771s) the, the picture below is for the code RL. So on the left bottom plot, we compare two ways of computing the loss for code RL. So the blue one is classic sequence mean loss.

[13:04](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=784s) Each sequence has one loss value, and the red one is our token-based mean loss, which average over token instead of sequence. The token-based version converge faster and more sta-steadily, and it reduce the tendency to generate very short template answer just to gain the reward.

[13:24](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=804s) In the right, you can see the data. Uh, we do get a science re, uh, reinforcement learning on GPQA dataset, and the message is almost the opposite of more data is better.

[13:38](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=818s) The red curve, red curve is trained only the small set of expert-verified, but high-quality multiple-choice questions, and the blue curve use mixed quality data. So this result that a small but clean data set gives much better performance.

[13:58](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=838s) So for scientific reasoning, data quality really matters more than raw size.

[14:06](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=846s) After talking about GLM-4.6 language model, we move to the multimodal model.

[14:14](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=854s) GLM-4.5V supports the both image and the video understanding. It is our latest visual understanding model, and go-- and on grounding and the image understanding benchmark, it shows strong performance and clear advantages over other open source model released around the same time.

[14:35](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=875s) So architecturally, we have the three main parts here.

[14:41](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=881s) The one is a vision transformer encoder backbone, and then, then it's like with MLP projector, and the final is GLM-4.5 base model as decoder. So we try hard to keep the visual input as original as possible.

[14:58](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=898s) So the model can see the image native resolution and aspect ratio instead of forcing everything into a fixed square. So this matches a lot of UI screenshots and also long vertical image and the PowerPoint slides.

[15:12](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=912s) So for the video, we in-- also insert a time index token after each frame. Basically tell the model this is the first scene, and this is the second scene, and that help it understand the temporal order and event, which is crucial for action understanding and step-by-step re, uh, procedures.

[15:32](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=932s) Uh, we also use a method, uh, as we researched before Co-- uh, in CogAgent. Now, the GUI agent capability is also supported on GLM-4.5V. So it can, like, uh, it can also help you to control a computer and also, like, a website to control, uh...

[15:50](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=950s) It can use the mouse or the keyboard touching and to communicate with, uh, uh, browser, also computer or mobile environments.

[16:02](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=962s) So how to use GLM-4.6 or GLM-4.5V model?

[16:07](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=967s) The first one is using open source weights. Uh, as we know, this, both these two model is open source, so you can use the SGLang or vLLM or other framework to inference it.

[16:20](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=980s) Uh, along with the weights, uh, on the release day, we already had SGLang and the vLLM integrate ready, and we also work with very sup-- popular open source frameworks like LLaMA-Factory or ms-swift.

[16:33](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=993s) So thank you to this community. There you have-- You can choose, uh, any framework you want and to try our model. But

[16:42](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1002s) GLM, uh, GLM-4.6 model is a large model with, like, more than 305, uh, 355 billion parameter. So if you don't have that H100 or, like, other, uh, GPU, there's an easier way to, uh, use our model.

[17:02](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1022s) So in this slide, we show the deploy, uh, commands of using SGLang or the vLLM here.

[17:10](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1030s) The next slide, uh, we can use the GLM on the Z.ai, uh, Z.ai. This is a website, and you can try GLM, uh, directly, and you can use it writing code, you can use it to generate PowerPoint, and then also on.

[17:28](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1048s) And in this, uh, demo is, uh, using

[17:33](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1053s) one command to write the Google searching in our [REDACTED:url], uh, demo. So you can just, uh, communicate with it.

[17:44](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1064s) And also, GLM is famous in coding capability. So it also provides the GLM coding plan, which connects GLM with tools and our plugins like Claude Code or other coding develop tool, uh, develop tools, and to provide a very strong coding assistant experience.

[18:06](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1086s) We also have a short demo video that, uh, show how to replace, uh, a old model in a Claude Code lifestyle with GLM-4.6 here. And you can, uh, see the...

[18:18](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1098s) You can watch this on YouTube. Then is the, uh, our community activity.

[18:29](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1109s) Beyond today talk, we are regularly host events both online and offline. So whenever we release a new model, we usually run the several community session afterwards. Uh, as the first one, there is AMA in the Reddit, and we also have some, uh, we also have some, uh, offline, um, on-site, uh, techno- uh, technology sharing, so you can

[18:52](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1132s) join us. The final, uh, slide is some important links you may to know, uh, is about website, uh, as I would, as I mentioned before, to try GLM model at Z.ai and also our API on here.

[19:11](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1151s) Then we also provide GLM-4.6 technical bo-- uh, technical blog, uh, GLM-4.5 tech reports. Uh, you can check it, and if you want to join our community, here is the Discord link.

[19:25](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1165s) And also the GitHub link is below with the open source model, including the, uh, README to how to u- deploy on the open source method. That's all of today.

[19:36](https://www.youtube.com/watch?v=m6MF1OR_9kM&t=1176s) Thank you very much.
