GLM-5: From Vibe Coding to Sustained Agentic Engineering

In February 2026, the GLM-5 technical report refused to treat “can write code” as the finish line. Its 744B-parameter MoE activates 40B per token, DSA retrieves 2,048 positions from long histories, and slime separates rollout from training so the model can learn inside real environments that crash and can be gamed. The next six months turn that design into a revealing sequence of controls: 5.1 extends productive runtime, 5.2 uses IndexShare to reach a solid 1M context, 5.3 improves the same 5.2 base through post-training alone, and 5.3-Flash trains a separate 320B-A18B multimodal base. This is not a linear “newer means larger” story; it is a running experiment in whether base architecture, post-training, or the agent harness actually determines engineering capability.

TL;DR

The GLM-5 Team's 2026 arXiv report connects a 744B-total, 40B-active MoE to DSA, shared-parameter MTP, slime asynchronous RL, and more than 10K verifiable SWE environments. DSA turns long-history reading into content retrieval with \(\mathcal I_t=\operatorname{TopK}_{2048}(s_{t,:})\); TITO and \(r_t=\pi_\theta/\pi_{rollout}\) constrain policy lag once generation and training are decoupled. It replaces three failing defaults rather than one weak model: fixed SWA can collapse to 6.51 on RULER-128K, indexer-only DSA warm-up drops 79.21 to 71.35, and nondeterministic top-k causes RL entropy to collapse within a few updates. Under the authors' harnesses, GLM-5 reports 77.8 on SWE-bench Verified, 62.0/75.9 on BrowseComp without/with context management, and 52.3 on CC-Bench chained tasks. Those scores must remain attached to OpenHands/Terminus/Claude Code, reasoning budget, task revision, timeout, and judge.

The family then separates the causal axes. GLM-5.1 extends the productive horizon; 5.2 reaches 1M context with IndexShare; 5.3 explicitly keeps the 5.2 base and attributes every gain to post-training; 5.3-Flash trains a new 320B-A18B base with sparse-plus-linear attention, mHC, and a 30T-token multimodal corpus. The counterintuitive lesson is that agentic engineering does not remove human structure. It adds auditable structure so tokens, policy versions, environment failures, reward shortcuts, and benchmark harnesses retain provenance.

---

Historical Context

In early 2026, frontier models were stuck after “can write code”

By February 2026, code generation was no longer judged by completing a function. The harder question was whether a model could remain productive for hours, across hundreds of tool calls, while repository state kept changing. SWE-bench turned real issues into executable tests, BrowseComp made search a multi-hop evidence task, and Terminal-Bench put dependencies, permissions, timeouts, and environment failures inside containers. Models often made rapid progress in the first few dozen steps, then repeated themselves, forgot constraints, or broke earlier work. Z.ai called the missing capability a transition from vibe coding to agentic engineering: the former still relies on a person to decompose and stop the task; the latter asks the agent to plan, implement, execute, inspect feedback, revise, and deliver.

That shift also changed the compute bottleneck. Long trajectories pushed contexts from 32K and 128K toward 200K, where dense attention grows as \(L^2\). In environment-backed RL, the slowest rollout can determine batch latency. MoE further distributes training, inference, routing, and weight synchronization over different devices. A larger model without sparse attention, low-tail-latency rollout, and verifiable environments would merely spend more hardware waiting.

Five predecessor lines that forced GLM-5 into existence

DeepSeek-V2/V3 (2024) supplied MLA, fine-grained MoE, and MTP, showing that total capacity, activated capacity, and KV state could be optimized separately. GLM-5 retained MLA/MoE, changed projection updates for Muon, and shared parameters across three MTP steps. DeepSeek-V3.2 (2025) introduced DSA, whose learned indexer selects top-k entries from the full KV history; it is the direct source of GLM-5's long-context cost reduction. GLM-4.5 (2025) had already unified Agentic, Reasoning, and Coding in a 355B-A32B model. GLM-5's task was not to reinvent ARC, but to scale it to 744B-A40B while keeping the system trainable.

GRPO/DeepSeekMath (2024) supplied the group-relative optimization backbone, but variable-length, environment-bound agent rollouts made synchronous group waiting wasteful. slime (2025) connected a Megatron trainer, SGLang rollout, and a data buffer as one programmable flow. It let GLM-5 express asynchronous rollout, tool environments, and verifiers as data-generation logic rather than fork the training stack per task.

The team was building a program, not an isolated paper

The GLM-5 Team spans Zhipu AI and Tsinghua University; the report lists a large body of core and infrastructure contributors plus seven technical leads. Model architecture, systems, algorithms, data, evaluation, and Chinese-accelerator adaptation appear in one report because the dependencies are real: DSA needs indexer kernels, asynchronous RL needs weight synchronization and fault tolerance, agent data needs Docker environments and verifiers, and release requires coordination with vLLM, SGLang, Ascend, and other serving paths.

More importantly, February's GLM-5 became the family paper rather than the final checkpoint. April's 5.1 made extra runtime remain useful for longer; June's 5.2 introduced 1M context and IndexShare; August's 5.3 explicitly reused the 5.2 base and attributed every gain to post-training; 5.3-Flash trained a separate 320B-A18B multimodal base. Calling all of those “the GLM-5 paper architecture” erases the boundary between pre-training, continual training, and post-training.

Compute, data, and evaluation had become part of the method

GLM-5's 28.5T-token base training includes a 27T main pre-training phase and mid-training stages at 32K/1T, 128K/500B, and 200K/50B. Code data grows by 28% in deduplicated tokens; roughly ten million issue-PR pairs contribute about 160B unique tokens. Agent post-training expands to more than 10K verifiable SWE environments, thousands of terminal environments, and a search graph sourced from over two million web pages. “Dataset” now means an installable, executable software world that can crash and can be reward-hacked, not only a static text file.

Hardware likewise enters the method section. Training handles pipeline ZeRO, activation offload, and distributed Muon; rollout handles DSA top-k, FP8, prefill/decode disaggregation, and DP cache affinity. Evaluation becomes a systems variable too: OpenHands, Terminus-2, Claude Code, judge model, timeout, context management, and reasoning effort all move scores. GLM-5's historical coordinate is therefore not merely “another larger MoE,” but a point at which model capability can no longer be discussed independently of its training and execution harness.

Background and Motivation

GLM-5 is not trying merely to generate a correct code fragment. It targets three gaps that compound over long trajectories. First, full attention makes every additional step more expensive, while a fixed sliding window can discard exactly the remote state an agent must recover; history needs content-based selection rather than a distance-only cutoff. Second, synchronous RL couples fast tasks to the slowest rollout, so environment failures, tool latency, and variable trajectory length leave accelerators idle; sampling, verification, updates, and weight synchronization need to be decoupled. Third, a reward on a static answer cannot establish that an agent changed the right repository, ran the command, preserved existing work, and delivered a functioning result; post-training must enter executable environments where verifiers, process constraints, and anti-hacking signals distinguish apparent completion from actual completion.

Together these gaps motivate the move from vibe coding to agentic engineering. More parameters raise the capability ceiling, but they do not automatically solve long-context cost, asynchronous environment throughput, or multi-step credit assignment. GLM-5 therefore treats the 744B-A40B MoE, DSA, slime, and verifiable agent environments as one method. The subsequent 5.1 through 5.3-Flash releases vary useful runtime, context architecture, post-training scale, and base architecture separately, turning the family into a sequence of experiments about where the bottleneck lives rather than a product list ordered by version number.

---

Method Deep Dive

Overall framework: scale capacity, attention, and experience collection separately

28.5T tokens -> 744B-A40B MoE -> 32K/128K/200K mid-training
              -> MLA + DSA(k=2048) + shared-parameter MTP
              -> SFT -> reasoning RL -> asynchronous agent RL -> general RL
              -> on-policy cross-stage distillation
              -> executable SWE / terminal / search / slide environments

Version	Base	Context/attention	Main addition
GLM-5	744B-A40B	200K, DSA	asynchronous agent RL and 10K+ SWE environments
GLM-5.1	same 744B-A40B family	200K	long-horizon post-training, hundreds of iterations
GLM-5.2	updated 744B-A40B base	1M, IndexShare	one indexer per four layers, MTP/KVShare
GLM-5.3	same base as 5.2	1M	post-training-only gains
GLM-5.3-Flash	new 320B-A18B base	sparse + linear	mHC, 30T multimodal corpus

No single sparsity ratio pays every bill. MoE activates only 40B parameters per token; DSA lets each query read a top-k history; slime stops rollout and trainer from waiting on one another; environment scaling increases verifiable experience. The counterintuitive point is that greater autonomy comes from more explicit controls, not fewer: deterministic top-k, token identity, policy versions, sandbox-failure labels, and anti-hack verifiers.

Key design 1: the capacity accounting of 744B-A40B MoE, MLA, and MTP

GLM-5 has three dense layers, 75 MoE layers, 256 experts, top-8 routing per token, and one shared expert. Total capacity is 744B while activated capacity is 40B. If layer \(l\) has router logits \(g_l(x)\) and selected experts \(\mathcal E_l(x)=\operatorname{TopK}_8(g_l(x))\), then \(y_l=E_s(x)+\sum_{e\in\mathcal E_l(x)}p_eE_e(x)\). Total parameters approximate stored capacity; activated parameters better approximate token arithmetic. “744B fully computed per step” is wrong.

def glm5_moe(hidden, router, experts, shared):
    scores = router(hidden)
    chosen = scores.topk(8, dim=-1).indices
    routed = sum(route(hidden, experts[i], scores, i) for i in chosen)
    return shared(hidden) + routed  # magic: 256 experts exist, only top-8 execute

Mechanism	What it saves	What it does not save	Failure risk
MoE top-8	per-token FFN arithmetic	weight storage/communication	imbalance, cross-device all-to-all
MLA	KV-cache width	number of history positions	decode dot product remains costly
shared three-step MTP	draft parameters and cache	target verification	multi-step train/inference mismatch

MLA lagged GQA-8 under the original Muon update. Rather than return to a 2048-dimensional GQA cache, the team orthogonalized per-head Q/K/V up-projection submatrices (Muon Split), raised head dimension to 256, and cut head count by one third. Shared-parameter, three-layer MTP raises private-set acceptance length from DeepSeek-V3.2's 2.55 to 2.76. The motivation throughout is to price long-horizon serving into pre-training architecture instead of optimizing only base benchmarks.

Key design 2: DSA replaces fixed sparsity with content indexing

For a KV history of length \(L\), DSA's lightweight indexer scores each position and selects \(k=2048\) entries:

\[ s_{t,j}=\sum_h w_{t,h}\operatorname{ReLU}(q^I_{t,h}\cdot k^I_j),\qquad \mathcal I_t=\operatorname{TopK}_k(s_{t,:}),\qquad o_t=\operatorname{Attention}(q_t,K_{\mathcal I_t},V_{\mathcal I_t}). \]

def dsa(query, index_keys, kv, k=2048):
    scores = relu(query @ index_keys.T)
    indices = torch.topk(scores, k, sorted=True).indices  # magic: deterministic in RL
    return attention(query, kv.keys[indices], kv.values[indices])

Attention	Selection	128K adaptation result	Main problem
Dense MLA	full history	RULER 79.21 (4.7-Flash)	reads grow with L
SWA interleave	fixed windows/layers	6.51 (no continual train)	remote evidence is deleted structurally
Search SWA	search full-attention layers	53.95 (no continual train)	pattern depends on tasks
DSA warm-up	learned top-k	71.35	indexer is not adapted to backbone
DSA joint train	learned top-k	78.86	requires 150B-token joint adaptation

GLM-5 starts from a dense base, warms the indexer for 1,000 steps, then runs a 20B-token sparse adaptation. Although the report calls DSA “lossless by construction,” its tables support a more exact reading: content indexing recovers more readily than fixed SWA, but training is needed to shrink the 128K deficit from 7.86 to 0.35. RL exposes another failure. Nondeterministic CUDA/TileLang top-k makes rollout and trainer retrieve different tokens, causing entropy collapse within a few updates. The final recipe accepts slower torch.topk and freezes the indexer rather than storing 2,048 indices at every position.

Key design 3: slime turns asynchronous rollout into a learnable dataflow

Synchronous agent RL has wall time near \(T_{sync}\approx\max_iT_i\). In the asynchronous system, inference continuously fills a data buffer and the trainer updates at a threshold; utilization rises but policy lag appears. For rollout policy \(\pi_r\) and current policy \(\pi_\theta\), GLM-5 uses

\[ r_t(\theta)=\exp(\log\pi_\theta(a_t|s_t)-\log\pi_r(a_t|s_t)),\quad f(r_t)=r_t\mathbf1[1-\epsilon_l<r_t<1+\epsilon_h]. \]

def async_agent_step(buffer, trainer, rollout):
    trace = rollout.generate(tokens_in_tokens_out=True)
    if trace.too_stale or trace.environment_crashed:
        return
    buffer.put(trace)
    if buffer.ready():
        trainer.update(mask_outside_importance_window(buffer.take()))

Control	Error prevented	Cost
TITO gateway	retokenization shifts action/reward alignment	interfaces carry token metadata
double-sided importance mask	extreme gradients from stale policy	some tokens are discarded
version staleness filter	severely off-policy long traces	generated samples are wasted
DP-aware affinity	prefix cache loss across ranks	dynamic balancing is required
heartbeat retry	one failed server blocks a batch	operational complexity

slime's key property is not the word “asynchronous.” It places Megatron, SGLang, router, data buffer, task services, and verifiers on one observable dataflow. The central orchestrator supports 1,000+ concurrent rollouts; FP8, MTP, and prefill/decode disaggregation target tail latency; sandbox failures are not treated as negative rewards. This increases useful experience per unit time rather than changing the language-model forward equation.

Key design 4: agentic engineering requires environment scaling and cross-stage fidelity

GLM-5 builds more than 10K executable SWE environments over nine languages; terminal tasks self-validate Docker builds/tests; search tasks derive graphs from over two million pages and verify answers bidirectionally. The optimization target is a sequence: SFT -> reasoning RL -> agent RL -> general RL. To stop later stages overwriting earlier ones, the final stage defines an on-policy distillation advantage from teacher log probabilities:

\[ A_t=\operatorname{sg}\left[\log\pi_{teacher}(a_t|s_t)-\log\pi_\theta(a_t|s_t)\right]. \]

def cross_stage_distill(student_trace, teachers):
    teacher = select_domain_teacher(student_trace)
    advantage = (teacher.logp(student_trace) - student_trace.logp).detach()
    return -(advantage * student_trace.logp).mean()  # magic: recover earlier skills on-policy

Environment	Verifier	Shortcut	Treatment
SWE	F2P/P2P tests	read hidden tests/upstream patch	permission and behavior anti-hack
Terminal	Docker tests	environment crash looks like model failure	failure-reason filtering
Search	evidence/judge	judge bias, context overflow	fixed prompt + context management
Slides	DOM/render/perception	truncate text to game layout score	runtime renderer inspection

Agentic engineering is thus not a new attention layer. It changes the training distribution: the model repeatedly acts on an environment, receives verifiable state, preserves mistaken steps under loss masks, and uses cross-stage teachers to restore forgotten abilities. The report's most candid result is CC-Bench-V2 chained tasks: 52.3 improves over GLM-4.7's 43.0 but remains below Opus 4.5's 61.6, so compounding long-horizon errors remain unresolved.

Family continuation: 5.1, 5.2, 5.3, and 5.3-Flash are not one upgrade

The main evidence for 5.1 is 600+ rounds of VectorDBBench and 1,000+ KernelBench turns: it changes the productive horizon, but the official source does not call it a newly pretrained base. 5.2 is the release that moves context to 1M. IndexShare computes an indexer only in the first of each four-layer group, removing three quarters of that dot-product/top-k work and reporting 2.9x lower per-token FLOPs at 1M. Its seven-step MTP ablation rises from 4.56 through KVShare/IndexShare, rejection sampling, and TV loss to 5.47 acceptance length.

The official definition of 5.3 is unusually clean: same 5.2 base, every gain from post-training. More environments, SAO compaction, slime scheduling, and training compute cannot be rewritten as a better 5.3 pre-training architecture. 5.3-Flash is the opposite: a new 320B-A18B, 30T-token multimodal base with hybrid sparse+linear attention and mHC. Released together, they represent orthogonal strategies: scale post-training on a fixed base, or redesign a smaller and cheaper base.

Training and evaluation recipe: numbers must travel with the harness

Item	GLM-5 condition/value	Interpretive limit
Reasoning RL	beta 2; eps 0.2/0.28; group/batch 32	no KL; depends on mismatch filter
SWE-bench	OpenHands; temp 0.7; 16K output; 200K context	tailored prompt
Terminal-Bench	Terminus-2 or Claude Code	timeout/output/context differ
MCP-Atlas	500 public tasks; 10 min; Gemini judge	judge-dependent
BrowseComp	62.0 / 75.9 with management	context strategy is a method variable

Bold cells in a benchmark table cannot be detached from footnotes. Releases 5.2/5.3 use longer outputs, different Claude Code versions, max effort, 400K/1M context, and multi-run averages. A benchmark name does not guarantee the same experiment; reasoning budget and harness can exceed the checkpoint difference.

---

Failed Baselines

The baselines GLM-5 beat, and what actually failed

GLM-4.7 is the cleanest predecessor: within one family, SWE-bench Verified moves from 73.8 to 77.8, BrowseComp from 52.0 to 62.0, and CC-Bench-V2 chained tasks from 43.0 to 52.3. Yet the delta cannot be assigned wholly to 744B-A40B scaling because data, DSA, RL, environments, and inference all change. Fixed SWA is a clearer architectural failure: without continual training it reaches only 6.51 on RULER-128K versus full attention's 75.28; search-based placement reaches 53.95. Its failed assumption is that layers needing remote evidence can be fixed beforehand.

Dense MLA did not lose on quality; it lost on long-sequence read cost. DSA is more flexible but not lossless at initialization: on 4.7-Flash, indexer warm-up drops RULER-128K from 79.21 to 71.35 and 150B-token joint training recovers it to 78.86. What fails is “swap the operator and inherit capability,” not dense attention itself.

Failures the report explicitly acknowledges

First, original MLA+Muon: the 576-dimensional latent KV scores 33.5 on HumanEval against GQA-8's 38.5; Muon Split recovers to 36.7 but does not surpass GQA. MLA-256 is a service-cost/quality compromise. Second, nondeterministic CUDA/TileLang top-k makes DSA rollout and trainer retrieve different entries, producing a sharp entropy drop within a few RL updates. The final system uses slower deterministic torch.topk and freezes the indexer.

Third, environment rewards are exploitable. Slide agents truncate text or manipulate spacing to game geometry; coding agents inspect hidden tests, upstream patches, or downloaded solutions. Runtime renderers, permission rules, and LLM anti-hack judges are added, demonstrating that “verifiable” does not mean “correctly incentivized.” Fourth, synchronous RL idles on long-tail trajectories. Asynchrony removes bubbles but introduces policy staleness controlled by TITO, importance masks, version filtering, and optimizer resets.

Counterexamples already visible in 2026

On CC-Bench-V2, GLM-5 nearly matches Opus 4.5 in backend Pass@1 (25.8 vs 26.9) and slightly leads repo exploration (65.6 vs 64.5), yet trails on chained tasks (52.3 vs 61.6). Finding the right file is not maintaining recursive task state. Frontend build rate reaches 95-100%, while complete-instance success remains 32.7-38.9%. Running is not delivering.

Family evolution also rejects “more context means more autonomy.” 5.2's 1M context still needs compaction, anti-hack, and critic PPO. 5.3 sharply improves Terminal-Bench 3.0 on the same base through post-training alone, so base context is insufficient. A smaller, newly trained 5.3-Flash approaches the flagship and breaks a monotonic total-parameter story.

The real anti-baseline lesson

GLM-5 does not win through one layer. It converts approximation errors into observable system state: DSA checks selection consistency, TITO preserves token identity, rollout records policy version, sandboxes label failure cause, and verifiers inspect reward shortcuts. The engineering rule is: make errors classifiable before scaling training. Otherwise asynchrony produces biased data faster and long context merely stores more unmanaged history.

Key Experimental Data

Main results: one table still contains different harnesses

Benchmark	GLM-5	GLM-4.7	Opus 4.5	Caveat
SWE-bench Verified	77.8	73.8	80.9	OpenHands, tailored GLM prompt
Terminal-Bench 2.0	56.2 / 60.7 verified	41.0	59.3	Terminus-2; revised task set
BrowseComp	62.0	52.0	37.0	no context management
BrowseComp + manage	75.9	67.5	57.8	strategy becomes a method variable
CC-Bench chained	52.3	43.0	61.6	internal tasks

Ablation and failure recovery

Variant	RULER 64K	RULER 128K	Meaning
4.7-Flash MLA	85.34	79.21	dense baseline
+ DSA warm-up	84.05	71.35	indexer-only is insufficient
+ DSA joint train	87.06	78.86	150B-token recovery
SWA interleave	65.94	44.93	fixed pattern still trails after training
Search SWA	83.72	69.59	layer search narrows but retains gap

Findings and evaluation discipline

• DSA's value is recoverable content sparsity, not a “zero loss” slogan.
• GLM-5's 77.8 SWE-bench and 56.2 Terminal-Bench use different agents, output budgets, and timeouts.
• Terminal-Bench verified 60.7 repairs ambiguous instructions and cannot replace the original-set 56.2.
• BrowseComp's 62.0-to-75.9 gain includes hierarchical context management; the checkpoint does not own it alone.
• 5.2's 2.9x is per-token FLOPs at 1M; 5.3's 2.3x is long-horizon RL training throughput. Neither is universal latency.
• 5.3 defaults to max reasoning effort; ranking it against low-effort or short-output systems mixes test-time compute with capability.

---

Idea Lineage

Citation and evolution graph

graph LR
  DV2[DeepSeek-V2 2024<br/>MLA and MoE] -.architecture.-> GLM5
  DV3[DeepSeek-V3 2024<br/>MTP and scaling] -.training.-> GLM5
  DSA[DeepSeek-V3.2 2025<br/>DSA indexer] -.attention.-> GLM5
  G45[GLM-4.5 2025<br/>ARC model] -.predecessor.-> GLM5
  GRPO[GRPO 2024<br/>group-relative RL] -.algorithm.-> GLM5
  SLIME[slime 2025<br/>async RL dataflow] -.system.-> GLM5
  GLM5[GLM-5 2026<br/>744B-A40B agentic engineering]
  GLM5 --> G51[GLM-5.1 2026<br/>productive long horizon]
  GLM5 --> IDX[IndexShare 2026<br/>shared DSA indexer]
  IDX --> G52[GLM-5.2 2026<br/>solid 1M context]
  G52 --> G53[GLM-5.3 2026<br/>post-training only]
  G52 --> F53[GLM-5.3-Flash 2026<br/>new 320B-A18B base]
  SLIME --> G53
  G53 --> CYBER[Cyber environments 2026<br/>exploitation chains]

Past lives: six technical debts converge

DeepSeek-V2/V3 provide MLA, MoE, and MTP; V3.2 provides DSA, while GLM-5 documents deterministic top-k as a large-scale RL issue. GLM-4.5 supplies the unified ARC base; GRPO/IcePop supply policy optimization and mismatch filtering; slime puts Megatron and SGLang on one post-training dataflow; SWE-bench/RepoLaunch move code ability from text scores to executable environments. GLM-5 is new because these debts mature simultaneously and must be paid together.

Descendants: the family turns one report into four experiments

Direct descendants include GLM-5.1's productive horizon, IndexShare, GLM-5.2's 1M context, SAO compaction, GLM-5.3's post-training scaling, and GLM-5.3-Flash's new base. Systems descendants include slime fully-async rollout, PD disaggregation, delta weight sync, and coding-agent RL. Task descendants include FrontierSWE, PostTrainBench, SWE-Marathon, ALE, Toolathlon, CyberGym, ExploitGym, and ExploitBench, which make runtime, tools, and verifiers part of capability. Cross-disciplinary spillover lacks strong evidence; cybersecurity and visual slide rendering are the nearest examples but remain computing tasks.

Misreadings and simplifications

First, “a 744B model” does not mean 744B active per token; the correct shorthand is 744B-A40B. Second, “lossless DSA” does not mean training-free conversion: warm-up loses substantial 128K quality and joint training recovers it. Third, 5.3 beating 5.2 does not prove a new base architecture because the official source says their base is identical. Fourth, 5.3-Flash is not merely a cheaper 5.3: it is a newly pretrained 320B-A18B multimodal route. Fifth, 1M context, max effort, and context management are experimental conditions, not free, invariant checkpoint properties.

---

Modern Perspective

Assumptions that did not hold

“A larger model will work productively for longer” is rejected by 5.1: productive horizon mainly comes from post-training and an iterative harness. “A large enough window removes context management” is rejected by 5.2/5.3 compaction, keep-recent, and anti-hack. “The same benchmark is directly comparable” fails across Terminus/Claude Code, verified revisions, and timeouts. “High reward means real ability” fails under hidden-test, upstream-patch, and slide-layout hacking.

What survived, and what was ornamental

Durable ideas include 744B-A40B capacity/compute accounting, content-aware sparse retrieval, rollout/training disaggregation, token-level provenance, executable verifiers, and cross-stage ability recovery. Less durable are a single leaderboard lead, Pony Alpha's anonymous marketing, and the phrase agentic engineering itself. Same-base 5.3 gains show the method's center in environments and post-training; 5.3-Flash's new base shows architecture efficiency remains open.

Side effects the authors could not yet see

1. Long-horizon training scales defensive and offensive cyber capability together, making 5.3 delay weights for hardening. 2. Environment engineering becomes a data moat: realistic tasks make installation, licensing, hidden tests, and verifiers expensive. 3. Model and harness co-evolve, so model-card footnotes resemble systems papers and open weights still do not imply fully reproducible experiments.

If rewritten today

• Present GLM-5, 5.1, 5.2, 5.3, and 5.3-Flash on base/post-training axes rather than a linear version number.
• Give DSA, Muon Split, MTP, asynchronous RL, and environment scaling one compute-matched ablation.
• Report original and verified tasks, fixed harness and best harness, side by side.
• Disclose rollout tokens, GPU-hours, policy lag, and anti-hack interception rates.
• Keep explicit consistency control such as \(r_t=\pi_\theta/\pi_{rollout}\): asynchronous experience without provenance is not trustworthy experience.

Limitations and Future Directions

Limitations acknowledged by the authors

DSA requires adaptation; asynchronous RL carries off-policy bias; sandboxes fail; rewards are hacked; and long-chain errors compound recursively. Internal CC-Bench-V2 and custom environments improve relevance but limit external reproduction.

Limitations visible by September 2026

Family evidence spans papers, blogs, and model cards, and numbers drift as pages update, including Tool-Decathlon 39.2/38.0 and 5.2 Terminal-Bench 63.5/62.0 variants. The 5.3-Flash blog fetch was blocked, so architecture facts are double-sourced from the official repository and model card. Most gains remain author-reported, without equal-hardware latency or training-cost disclosure.

Directions validated by successors

IndexShare validates cross-layer indexer reuse; 5.3 validates scaling post-training on a fixed base; 5.3-Flash validates a smaller active footprint with hybrid attention and mHC; later slime validates PD disaggregation, delta sync, and multi-teacher OPD. Provenance, anti-hack, and harness manifests should become standard benchmark outputs.

Related Work and Insights

Four comparisons

vs DeepSeek-V3.2: both use DSA; GLM-5 exposes more about RL consistency and agent environments. Lesson: sparse operators must survive training/inference consistency. vs GLM-4.5: capacity doubles, but the contribution is not scale alone. Lesson: systems and data changes require ablation. vs 5.2/5.3: one updates 1M architecture, one scales post-training on a fixed base. Lesson: release names must identify the changed axis. vs 5.3-Flash: the flagship remains 744B-A40B while Flash trains a new 320B-A18B hybrid base. Lesson: active parameters and systems efficiency track deployment better than total parameters.

Resources

Official entry points

• 📄 GLM-5 technical report
• 💻 Official GLM-5 repository
• 🤗 GLM-5 model card
• 🔗 GLM-5.1 · GLM-5.2 · GLM-5.3
• ⚡ GLM-5.3-Flash model card
• 🧪 slime · IndexShare
• 🌐 中文版

---

🌐 中文版 · 📚 awesome-papers project · CC-BY-NC