GLM-4.5: Agentic, Reasoning, and Coding (ARC) Foundation Models

GLM-4.5: Agentic, Reasoning, and Coding (ARC) Foundation Models. Authored by the GLM-4.5 Team at Zhipu AI & Tsinghua University (Beijing). The paper is the technical report accompanying the open-source release of the GLM-4.5 series — a $355\text{B}$-total / $32\text{B}$-active Mixture-of-Experts flagship and the smaller $106\text{B}$ / $12\text{B}$ GLM-4.5-Air variant. The work positions itself as the first open-source attempt to jointly push agentic, reasoning and coding (the "ARC" axes) inside a single hybrid-reasoning model, rather than treating one axis as primary and others as side-effects.

GLM-4.5 is an open-source MoE LLM with $355\text{B}$ total / $32\text{B}$ activated parameters, designed as an Agentic-Reasoning-Coding (ARC) foundation model. It supports a hybrid reasoning mode that toggles between a deliberative thinking mode and a fast direct-response mode. The recipe is a multi-stage pre-training over $23\text{T}$ tokens followed by post-training with expert model iteration plus reinforcement learning. The model scores $70.1\%$ on TAU-Bench, $91.0\%$ on AIME 24, and $64.2\%$ on SWE-bench Verified — ranking 3rd overall and 2nd on agentic benchmarks among all evaluated models, while using far fewer parameters than its competitors. Authors release both the $355\text{B}$ flagship and a compact $106\text{B}$ variant (GLM-4.5-Air) to advance reasoning and agentic research.

The ARC framing. The authors frame the path to AGI as needing three interconnected capabilities — Agentic (tool/world interaction), Reasoning (multi-step math/science), and Coding (real-world software engineering) — collectively "ARC". While proprietary models like o1/o3 and Claude Sonnet 4 each excel in some ARC dimension, no single open-source model has unified all three. GLM-4.5 and GLM-4.5-Air target exactly this unification, introducing a hybrid thinking/non-thinking mode switch so that a deliberative chain-of-thought is available on hard problems while fast direct responses are available on easy ones. GLM-4.5 is the team's first Mixture-of-Experts release; both models are publicly open-sourced (weights + recipe) to advance agentic and reasoning research.

Headline numbers and parameter efficiency. GLM-4.5 posts results like BFCL v3 $77.8\%$, BrowseComp $26.4\%$, AIME 24 $91.0\%$, GPQA $79.1\%$, SWE-bench Verified $64.2\%$, Terminal-Bench $37.5\%$ — placing $3\text{rd}$ overall and $2\text{nd}$ on agentic benchmarks among the $12$ evaluated proprietary and open-source models. Notably it uses only about half of DeepSeek-R1's parameters and one-third of Kimi K2's, sitting on the Pareto frontier of SWE-bench-vs-parameters. The headline framing is therefore not "biggest model wins" but "parameter-efficient ARC generalist", made possible by a narrow-deep MoE shape, a repo-level + agent mid-training stage, and a multi-track expert-iteration RL recipe described in the rest of the paper.

GLM-4.5 adopts a MoE backbone with loss-free balance routing and sigmoid gates (following DeepSeek-V3), but diverges in shape: the team makes the model narrower and deeper than DeepSeek-V3/Kimi K2 because they found depth correlates more strongly with reasoning gains than width. The flagship has $3$ dense + $89$ MoE layers, hidden dim $5120$, $160$ routed experts with $8$ activated and $1$ shared expert, totalling $355\text{B}$ params / $32\text{B}$ active. Attention uses Grouped-Query Attention with partial RoPE; counter-intuitively they use $2.5\times$ more attention heads ($96$ heads for $5120$ hidden) — this does not improve training loss but consistently lifts MMLU/BBH at evaluation. QK-Norm stabilises attention-logit ranges, and an extra MoE layer serves as the MTP (Multi-Token Prediction) head to enable speculative decoding at inference time. GLM-4.5-Air is the compact sibling ($106\text{B}$ total / $12\text{B}$ active, $1$ dense + $45$ MoE layers, $128$ experts).

Data. The pre-training corpus mixes English/Chinese webpages, multilingual documents, code from GitHub-and-peers, plus math/science from web+books+papers. Webpages are bucketed by quality score (Nemotron-CC style) — the highest bucket is up-sampled to $3.2$ epochs and the lowest discarded; SemDedup is used on top of MinHash to remove template-generated near-duplicates. Code is filtered by a language-specific quality model into three tiers (high up-sampled, low excluded), and gets a Fill-In-the-Middle objective. Math/science documents are scored by an LLM for educational utility and up-sampled above a threshold. Pre-training runs in two stages: stage one is general web, stage two up-samples code + math/science.

Mid-Training. After pre-training, three medium-scale stages further shape the base model. Repo-level Code: same-repo files are concatenated to teach cross-file dependency, and GitHub issues/PRs/commits are joined into one context with commits formatted as diffs; sequence length extends $4\text{K} \to 32\text{K}$. Synthetic Reasoning Data: massive math/science/coding-competition Q-A pairs are augmented with reasoning chains generated by a stronger reasoner. Long-context & Agent: extends $32\text{K} \to 128\text{K}$, up-samples long documents, and adds large-scale synthetic agent trajectories. Best-fit packing is used in mid-training (but not pre-training, where random truncation acts as augmentation).

Hyper-Parameters. The team uses the Muon optimizer for everything except embeddings, biases, and RMSNorm weights (Newton-Schulz steps $N=5$, momentum $\mu=0.95$, update RMS scaled to $0.2$); they note Muon both converges faster and tolerates larger batches. LR follows cosine decay from $2.5\text{e-}4$ to $2.5\text{e-}5$ — they explicitly say WSD underfits on SimpleQA/MMLU compared to cosine. Batch size warms up from $16\text{M}$ to $64\text{M}$ tokens over the first $500\text{B}$ tokens. Weight decay is $0.1$, no dropout. When extending to $32\text{K}$, RoPE base frequency is bumped $10\,000 \to 1\,000\,000$; loss-free routing's bias update rate is $0.001$ for the first $15\text{T}$ tokens then $0.0$; an auxiliary sequence-level balance loss with weight $0.0001$ avoids per-sequence imbalance; MTP loss weight $\lambda = 0.3$ then $0.1$.

Two-stage post-training with expert model iteration. Stage 1 (Expert Training) trains three specialist models — one each for Reasoning, Agent, and General chat — by doing cold-start SFT on each domain followed by domain-specific RL. Stage 2 (Unified Training) uses self-distillation to fuse the three experts back into a single hybrid-reasoning generalist that supports both thinking and direct-response modes. Cold-start SFT uses a small set of extended-CoT data to seed each expert with basic chat / reasoning / tool-use abilities; in Stage 2 the SFT objective is to distil the three experts' capabilities into one model. The overall RL algorithm is based on GRPO with the KL term dropped, and is specialised differently for each of the three expert tracks.

Scope & first two engineering tricks. Reasoning RL covers math, code generation and scientific reasoning — domains where correctness is programmatically verifiable, giving dense reliable rewards that let RL scale. Two of the four engineering tricks address what the model trains on and how long its outputs are: (1) Difficulty-based curriculum — stage one uses moderate-difficulty problems; stage two switches to extremely hard problems (pass@8 = 0 but pass@512 > 0) drawn only from a verified-answer pool, which keeps improving past the plateau of a single-difficulty baseline. (2) Single-stage RL at $64\text{K}$ output length — multi-stage length-increasing schedules cause irreversible length-collapse (once a policy collapses to short, it cannot be reverted), so the team runs RL directly at the target $64\text{K}$.

Sampling temperature & per-domain specialisation. The remaining two tricks handle exploration and domain-specific reward shaping: (3) Dynamic sampling temperature — when mean reward plateaus, temperature is raised to encourage exploration, but bounded by a quality-control rule (no more than $1\%$ drop on a held-out set), so exploration cannot quietly destroy the policy. (4) Code & science specialisation — code RL uses token-weighted mean loss (faster convergence than sequence-mean, kills "base-case" length-hacking where the model writes only the trivial branch); science RL on GPQA-Diamond works best with exclusively expert-verified multiple-choice data — mixing unverified open-ended questions actually hurts the final score because noisy rewards leak into gradient updates.

Agentic RL focuses on two automatically-verifiable settings — web-search agents and SWE coding agents — because every action's outcome can be programmatically checked, yielding dense rewards that let RL scale. For web search the team builds a data pipeline mixing knowledge-graph multi-hop synthesis with human-in-the-loop content obfuscation, designed to elicit elusive interwoven facts. For SWE they curate GitHub PRs/issues into prompts with executable unit tests, evaluated inside a hardened distributed Docker sandbox. The objective is group-wise: $L_\text{RL}(\theta) = \mathbb{E}_{x \sim \mathcal{D}}\!\left[\tfrac{1}{K} \sum_{i=1}^{K} \bigl(r(x,y_i) - \bar{r}(x)\bigr)\right]$, where only model-generated tokens enter the loss (environment feedback masked out) and a process-format penalty zeroes the reward when tool-call format breaks.

Iterative self-distillation + test-time scaling via interaction turns. Because agent-task RL rollouts are slow, the team alternates RL with self-distillation: train RL on the cold-start model until it plateaus, then replace the cold-start SFT data with responses sampled from the RL-trained model to form a stronger SFT base, then RL again on that base — progressively ratcheting up difficulty. They also note that on web-search and SWE, RL gains generalise to other tasks (e.g. Terminal-Bench, general tool use). Crucially, for agent tasks test-time compute scales not by more output tokens (as in reasoning) but by more interaction turns with the environment; Figure 8 shows BrowseComp accuracy increases smoothly with browsing effort.

General RL — three reward sources, Holistic + Instruction-Following sub-tracks. General RL is the final post-training stage and combines three reward sources: rule-based, RLHF (human-preference reward model), and RLAIF (model-based scoring). It has four sub-tracks; the first two cover open-ended chat quality and instruction adherence. Holistic RL uses $\sim 5\,000$ prompts spanning $7/33/139$ category levels with both a human-pref reward model and rubric-based AI feedback, so the model improves across many broad chat categories without overfitting to any one rubric. Instruction Following RL defines a fine-grained $7$-major / $151$-minor constraint taxonomy and uses a hybrid feedback (deterministic verifier + RM + critique model) — Figure 9 shows SysBench-ISR climbs from $\sim 64$ to $77.2$ with no clear reward-hacking even at $1\,000$ steps.

Function-Calling and Pathology sub-tracks. The last two sub-tracks target tool-use correctness and low-frequency failure modes. Function Calling RL splits into step-wise rule-based (exact-match reward over function name / parameters / fields — any deviation zeros the reward, forcing strict structural correctness) and end-to-end multi-turn (only the final TaskCompleted signal matters, letting the model freely explore intermediate tool-use trajectories). Pathology RL targets a curated dataset of prompts likely to trigger language-mixing / repetition / formatting bugs, since these failure modes are too rare ($< 1\%$) for the other RL tracks to fix sample-efficiently — concentrating training data on the exact prompts that elicit pathology gives much higher signal-per-step than waiting for them to appear in general RL.

Slime is the open-source RL framework (Megatron training + SGLang/Router rollout + central Data Buffer) that ties everything together. It supports two scheduling modes selectable per task: colocated synchronous (training and inference on the same worker, ideal for reasoning/math RL because dynamic sampling fills GPU idle gaps) and disaggregated asynchronous (training and rollout GPUs decoupled, ideal for agentic RL where SWE/web environments have long-tail trajectories that would otherwise stall training). For rollout acceleration, Slime trains in BF16 but performs online block-wise FP8 quantisation for inference at each policy update. Agent-task infrastructure adds a high-concurrency Docker runtime for isolated environments and a unified HTTP endpoint + central data pool so heterogeneous agent frameworks (AgentGym etc.) can plug into the same RL loop.

Base model. GLM-4.5-Base (the pre-training checkpoint, no instruction tuning) is compared against Qwen3-235B-Base, Llama-4-Maverick, DeepSeek-V3-Base, Kimi-K2-Base across English (SimpleQA / BBH / MMLU / HellaSwag / PIQA / TriviaQA), Code (EvalPlus / LiveCodeBench-Base), Math (GSM8K / MATH) and Chinese (CLUEWSC / C-Eval / C3 / Chinese-SimpleQA). GLM-4.5-Base scores broadly competitively — e.g. MMLU $86.1$, LiveCodeBench-Base $28.1$ (best in the table), C-Eval $86.9$, Chinese-SimpleQA $70.1$ — validating that a single unified base can hold up across English/Chinese/Code/Math without sacrificing one axis to win another.

Agentic benchmarks. On TAU-Bench (Retail / Airline) and BFCL v3, GLM-4.5 matches or beats Claude Sonnet 4 (TAU-Retail $79.7$ vs $80.5$, TAU-Airline $60.4$ vs $60.0$, BFCL v3 $77.8$ vs $75.2$); BrowseComp is harder ($26.4$, close to o4-mini's $28.3$ but well behind o3's $49.7$). Agentic average $58.1$ puts GLM-4.5 second only to o3. In coding-agent head-to-head human eval, GLM-4.5 wins $40.4\%$ / ties $9.6\%$ / loses $50.0\%$ vs Claude Sonnet 4, but crushes Kimi K2 ($53.9\%$ win) and Qwen3-Coder ($80.8\%$ win); tool-calling success rate hits $90.6\%$ — the highest among compared models.

Reasoning & Coding benchmarks. Reasoning: AIME 24 $91.0$, MATH-500, SciCode, GPQA $79.1$, HLE $14.4$, LCB (2407-2501) $72.9$ — competitive with frontier reasoners though not topping every line. Coding: SWE-Bench Verified $64.2$ and Terminal-Bench $37.5$ — beating GPT-4.1 and Gemini-2.5-Pro, closing in on Claude Sonnet 4. On a newly constructed novel-logical-reasoning evaluation built to avoid web contamination, GLM-4.5 scores $62.0$, close to DeepSeek-R1-0528 ($62.1$) and Gemini 2.5 Pro ($65.8$). For translation, GLM-4.5 averages $1.71/3$ on $100$ tricky idiomatic cases (netizen slang, domain nicknames, emoji semantics), beating specialised models like Qwen-MT-plus ($0.38$) and Seed-X ($0.65$).

The GLM-4.5 series (GLM-4.5 and GLM-4.5-Air) consolidates MoE architecture, expert-iteration post-training, and a three-track RL recipe (Reasoning → Agentic → General) into a single open-source release. GLM-4.5 reaches 3rd place globally among open-source and proprietary models on the ARC benchmarks while staying parameter-efficient. Weights are released to advance applications and research on agentic foundation models.

References (p.23 onward). The bibliography is intentionally omitted from this reader; the original PDF starts the reference list on page $23$ and runs through the back-matter. Key papers cited in line throughout GLM-4.5's design include — DeepSeek-V3 (loss-free routing, sigmoid gate, MTP head); Kimi K2 (the $1\,043\text{B}$ comparator on SWE-Bench); Qwen3-235B (open-source MoE peer); GRPO (group relative policy optimisation, the base RL algorithm); Muon optimizer (Newton-Schulz orthogonalised update); Megatron and SGLang (training and rollout backends inside Slime); SWE-Bench Verified / TAU-Bench / BFCL v3 / BrowseComp / AgentGym (the agentic evaluation suite). For exact citation strings, see the PDF.