Z.ai had to get GLM-5.3-Flash — the fast variant of its flagship model — running in production on a cluster of more than 100,000 Chinese-made AI accelerators. No one had deployed that hardware at that scale. The chips had less memory and bandwidth than the NVIDIA parts most labs use, the software tooling was immature, and much of what should have been documented had to be guessed.

That work is normally weeks of senior infrastructure engineering. Here, much of it was done by an agent running on GLM-5.3 itself — and the interesting part of the post is not the model but the loop built around it. The team calls it dense feedback.

The argument is that an agent with a strong coding model still flounders on systems work, because the only signal it gets is end-to-end: “accuracy test failed,” “throughput dropped 20%.” Those tell an agent that it broke something, never which layer — a kernel here, a communication path there, memory management, or the serving scheduler on top. So they built the environment so every change produces feedback the agent can act on directly:

  • Local — tied to a specific kernel, code path, thread or launch parameter, not the whole service. Instead of “accuracy dropped after a fusion optimization,” the output difference for one request before and after the change.
  • Cheap and fast — a kernel test or a microbenchmark when that answers the question, not a full deployment and load test every time.
  • Objectively verifiable — correctness and speed decided by reference implementations and controlled experiments. Observed correlation is not a root cause.

Engineers kept three jobs: set the objectives and constraints, build the feedback environment, and review changes touching numerical behavior, concurrency and production risk. Within that frame the agent proposed hypotheses, made changes and ran its own experiments.

Three examples of what that bought

  • A silent precision bug. Comparing the parallel and non-parallel versions of the same computation exposed a numerical error in a kernel where a matrix-multiply helper had quietly defaulted to a lower-precision path even on full-precision inputs. Errors accumulated over long contexts. The fix was a higher-precision mode for those two operations; it has been merged upstream into the Flash Linear Attention project.
  • A concurrency bottleneck. The team set an acceptance bar: adding a step to the pipeline should cost no more than 5% versus the baseline. It cost over 20%. The agent traced it to Python’s global interpreter lock never being released in one library’s intra-node path, which stalled the transfer thread in the same process. Entering compiled code does not automatically release that lock — a sibling path already did it explicitly, which was the clue. After the fix the overhead fell below 1%.
  • A 1.71x kernel speedup. The agent mined optimization techniques out of existing open kernels (SGLang, Flash Linear Attention, DeepGEMM) into reusable “skeletons” with applicability conditions, then found the decode kernel was tiling along the wrong dimension — recomputing the same normalization and gating four times. Merging the tiles and keeping the intermediates in registers traded a little parallelism for a 1.71x speedup, with validated techniques flowing back into the skeleton library.

The numbers, and the caveat the authors attach to them

  • Over 100,000 Chinese-made accelerators, all production inference for GLM-5.3-Flash.
  • Roughly 3x end-to-end serving improvement over the initial baseline on the same hardware, with per-token cost and hardware efficiency “comparable to mainstream NVIDIA GPUs.”
  • First successful run to production in under two weeks.
  • The model shipped anonymously as “Ox-Alpha” on OpenCode and OpenRouter and was the most-used model on both within a week — over 62 trillion tokens in six days.

The framing is recursive self-improvement, and the authors are careful with it: they say this is an early form, not the thing itself, and that choosing objectives, setting boundaries and assessing risk remain human responsibilities they expect to stay human “for a long time to come.” The concrete claim is narrower and more useful: the bottleneck on agent-driven engineering is not model capability but whether the system can hand the agent attributable feedback. Their closing line is the whole thesis — the model optimizes the system; the system runs the model.

What the thread adds

The 208-comment thread on Hacker News mostly argues about geopolitics, but three things in it are worth keeping.

  • HarHarVeryFunny — unpacks what “Chinese-made” covers: the accelerators are Huawei Ascend parts fabricated by SMIC, using domestic CXMT memory alongside leftover pre-sanction Samsung memory, and SMIC is still running ASML’s older DUV lithography while a domestic DUV supplier moves into early production.
  • kgeist — the closest independent replication attempt in the thread, and it is partial. They run the same shape of loop — an agent comparing outputs layer by layer against a CPU reference — and report it fixes numerical problems easily, but that no current model they have thrown at it can match the performance of existing inference engines, even with reference code supplied. Their conclusion is a genuine question: either they are missing something, or Z.ai’s Infra Agent is a swarm doing brute force with heuristics.
  • gpugreg — the practitioner reply to that: DeepSeek-V4.1-Flash works well for CUDA kernel optimization, and access to NVIDIA’s profiling CLI (ncu) helps.
  • vblanco and kingstnap — the counterargument to reading this as a China-only capability. Both say US labs are already doing this: OpenAI brought up its own Broadcom inference chip using AI in the same way, and one price cut was publicly attributed to inference optimization. The second adds the sharper line — labs are “quite cut throat about dealing with stuff costing them money (inference),” and simultaneously “quite lax about stuff costing other people money.”
  • Two paying customers, one complaint — konart and esafak both report the opposite of a speedup from the consumer side: “dog slow” through z.ai and usage caps that cut sessions short. yorwba offers the mechanism, which is not a contradiction: serving many users at a lower per-user rate can beat serving one user fast, and when traffic drops you shut GPUs down rather than hand out extra speed. The published benchmark is throughput per chip, not latency for you.
  • zicohacks and dzonga — the export-control reading, offered as opinion: restrictions pushed Chinese labs to build their own accelerators sooner, one calling it “asteroid level” for Western labs because most work does not need frontier models. aurareturn lists winners and losers and concludes the American hardware makers lost the lobbying fight. These are theories posted in a thread, not findings.

One question the thread kept asking

Havoc asked the question the post does not answer: whether those 100,000 accelerators are domestic end to end — including lithography, memory and design — or a mostly domestic integration of imported parts. HarHarVeryFunny’s reply above is the best answer in the thread, and it is an uncited sketch rather than a sourced breakdown. For a claim this large, the sourcing gap is the thing to notice.

A note on reading comments as evidence: HN handles are pseudonymous, the site publishes no per-comment scores, and the ordering here is HN’s own ranking. This is a slice of the thread, not a consensus.