Zhipu AI has achieved the minimum closed loop of RSI, Company A: I will supervise.

"Zhipu has achieved the minimal closed loop. The model optimization system serves the model, and the model empowers the system in return."

Recently, TANG Jie, Chief Scientist of Zhipu, used this sentence on social media to sum up the step Zhipu has taken towards Recursive Self-Improvement (RSI).

In Zhipu's published *Towards Recursive Self-Improvement*, an Infra Agent driven by GLM-5.3 participated in the construction and optimization of the GLM-5.3-Flash inference service. This service runs on more than 100,000 domestic AI chips, and it only took two weeks from the first successful run to taking over all online traffic.

The model has started working for itself. It helps optimize the system it runs on, making inference faster and lower-cost; the tasks, verification results and correction experience accumulated during the optimization process can become resources for subsequent R&D. The "minimal closed loop" mentioned by TANG Jie starts to operate right from here.

There is still a gap between this state and the scenario where AI fully independently develops the next-generation AI. But it brings up an increasingly specific problem: when models gradually take over the R&D work originally completed by humans, how can we know what stage self-improvement has reached?

A single inference speedup can be verified by throughput and latency; but what can be used to measure how much of its own R&D a model has undertaken? If more and more Agents are involved in the process, can humans still clearly understand what they are doing and intervene in time?

Anthropic recently released *Measuring the Pace of AI Progress at Frontier Labs*, which exactly pushes the discussion to this point. It proposes three measurement dimensions: how much AI R&D work is undertaken by AI, what kind of supervision the actions of Agents are subject to, and how computing power is allocated between model R&D and safety work. This is equivalent to installing three dashboards for the operating R&D process, so that people outside the lab can also see the changes inside.

According to the data disclosed by Anthropic, as of August this year, Claude has "led" 26% of model R&D work under human supervision, while this proportion was less than 1% in February. However, none of the R&D work it measured has reached a fully autonomous level.

The engineering practice demonstrated by Zhipu provides a specific sample for "AI participating in improving itself"; the measurement method proposed by Anthropic attempts to make this change continuously observable and verifiable. How the closed loop operates, and how to measure and supervise it after it runs, the two articles are connected around the same core problem.

What is the minimal closed loop of RSI?

Before understanding the minimal closed loop of RSI, we need to first understand TANG Jie's new viewpoint. In the past, when people understood RSI, their first reaction was "the model has become smart enough to evolve on its own".

TANG Jie's understanding is exactly the opposite: what makes the loop run is not intelligence, but the closed loop itself.

Even if a system is not smart enough, as long as it can continuously modify a certain thing and someone can continuously judge whether its modification is correct, the loop can be established. Conversely, no matter how smart a model is, if no one tells it "whether your last step was correct", even if it runs for months or even years, it can only spin in place.

Therefore, in TANG Jie's view, three puzzle pieces are needed to form a complete closed loop.

First, there needs to be an object that can be improved.

The model cannot modify its own weights, but it can optimize the supporting inference system for serving the model, such as kernels, parallel strategies, communication, memory management, and scheduling.

It's just like when you need coffee to refresh yourself in the office, but the coffee machine and water dispenser are too far away, so you have to walk a long way every time you want to get coffee. Then you move the coffee machine near your workstation.

In this way, even if the work you do every day remains the same, your work efficiency can be improved.

TANG Jie believes that this inference system is the key to realizing the closed loop.

Second, a verifiable referee.

After the modification, someone needs to make a decision immediately to tell the model whether the modification is correct or not, and this referee cannot be costly. This process is called dense feedback.

There are reference implementations for correctness, comparable indicators for throughput and latency, and objective judgments for right or wrong. In other words, there must be a cheap and reliable evaluation ruler.

Third, a self-sustaining loop.

The tasks completed in this round will become the training ground for the next round. Therefore, the loop does not require continuous external input, but generates the next iteration on its own.

Only when the three puzzle pieces are put together can the loop operate autonomously. What Zhipu has truly closed this time is the first puzzle piece: the model optimizes the inference system.

Although this minimal closed loop cannot improve the intelligence of the model in the true sense, it reduces the cost of the model developing itself. Only by adjusting its own workstation properly can the improvement of efficiency be discussed.

Cheaper inference means that more computing power can be reserved for training under the same budget. A more efficient service system means that the next-generation model can be built on a more solid foundation.

Based on this closed loop, the production inference service of GLM-5.3-Flash runs on more than 100,000 domestic AI chips. It only took two weeks from the first successful run to taking over all online traffic, and the end-to-end throughput increased by about three times.

What is more critical is what flows in the loop. The model extracts the "optimization skeleton" from existing kernels such as SGLang, Flash Linear Attention, and DeepGEMM, and precipitates the applicable conditions and verification evidence together. The verified practices flow back into the library, making the next round of work more labor-saving.

Every task completed by the Agent can be inherited from the previous results. Training is no longer a one-time activity, but becomes a form of compound interest accumulation.

It's just like I will look for reference materials before writing an article, otherwise I can't understand the key information mentioned in Zhipu's paper at all. Then I convert this information into plain language that everyone can understand. At the same time, I can also improve my understanding of RSI in the process of searching for information, so that I can write better in the next article.

Then next, how far can this loop expand?

TANG Jie believes that the essence of expansion is to replicate the "verifiable environment" from the engineering domain to more domains. How far it can expand depends on the second puzzle piece.

As mentioned earlier, this referee must be cheap, fast, and its output results can be objectively verified.

All fields that meet these three conditions can be incorporated into RSI, such as coding, data processing, formal verification, and any measurable system.

Conversely, places without objective referees cannot be expanded, such as strategy, aesthetics, and narrative, where a cheap and reliable evaluation ruler cannot be found. If you argue whether a story is good or not, the model says it's good but you say it's bad, who has the final say?

Feedback determines the performance of Agents

Where exactly is the loop stuck?

TANG Jie stated in his long article that when the Infra Agent gets stuck, it is rarely because it cannot write code, but because it does not know why things go wrong.

For example, the referee feeds back to AI that its "throughput has dropped by 20%". This only indicates that something is broken, but it does not explain which layer is broken, where the current hypothesis is wrong, or what to test next.

TANG Jie said this is an old problem left over from reinforcement learning: sparse reward and credit assignment.

You often get a "good" or "bad" signal only after an action is fully completed and run end-to-end, and this signal cannot be attributed to which specific step, so the exploration will naturally be very slow.

It's just like an exam. After the exam, the teacher tells you that you got 60 points, but doesn't tell you which question you got wrong. Then you can only redo the whole test paper and try to modify the answers by guess.

You may modify a part that is not wrong at all, while the real error remains uncorrected.

Not only that, end-to-end benchmarks often take several hours. After the model puts forward a hypothesis and modifies a piece of code, it has to wait for a long time to know whether it is correct, which makes the exploration extremely slow.

However, there is a very interesting phenomenon: a senior engineer who has worked in infra for 10 years may only need less than 1 hour to optimize these same problems, because he has a set of unexplainable intuition. After modifying a piece of code, he may not even know how he makes the judgment.

The thoughts of these senior engineers are like "Hmm, something feels wrong, I'll check the timeline" "Hmm, maybe I need to run a microbenchmark here for comparison".

This set of experience is stored in his mind, he can't describe the steps clearly or write them into a document, but it works effectively.

What TANG Jie wants to do is to turn the set of "unexplainable but effective" intuition in the minds of senior engineers into a layered verification interface that the model can call directly, just like a master teaching an apprentice, explaining the experience to AI.

Correctness feedback answers "is the calculation correct", using reference implementations and error tolerances to judge whether the calculation is accurate; system behavior feedback answers "where is the time spent", using execution timelines and runtime events to reveal the temporal relationship between calculation, waiting and communication; performance feedback answers "which solution is better and under what conditions", using controlled experiments and comparable indicators to judge which path is truly more optimal.

The original text gives three cases for explanation.

The first case is KV transfer. The engineer first set an acceptance condition for the Agent: under the same load, the gap between Prefill plus transmission and pure Prefill should not exceed 5%.

As a result, the Agent found that this gap exceeded 20% in some scenarios. This feedback did not directly give the answer, but narrowed the investigation scope to the additional overhead and concurrent interaction introduced by KV transmission.

A chef is stir-frying dishes in the kitchen, and the finished dishes need to be served to the restaurant. It is supposed that the chef can stir-fry the next dish while the waiter serves the previous one, so that the two processes do not interfere with each other.

But there is only one key to the food delivery door, and the chef puts the key in his pocket when cooking. When the waiter wants to take the dishes out, he has to wait for the chef to take out the key and open the door. The chef is so focused on cooking that he forgets the key, and the waiter can only wait beside the door doing nothing.

The Agent followed the timeline and even traced all the way to Python and C++. The intra-node path of DeepEP did not explicitly release the GIL, so the Python thread responsible for transmission in the same process could not grab the lock, and the KV transmission that was supposed to overlap with calculation was blocked by scheduling.

Entering C++ will not automatically release the GIL. It is this detail that explains why the lower layer supports asynchrony but the upper layer cannot realize it. After the repair, the gap between Prefill plus transmission and pure Prefill was reduced from more than 20% to less than 1%.

The second case is KDA precision drift. During kernel verification, differences appeared in the results of CP and non-CP paths, so the investigation turned to state propagation and merge calculation introduced by parallel execution.

The Agent found that the root cause was tf32. In the original implementation, tl.dot uses tf32 by default for performance. Even if the input is fp32, this lower precision will continuously accumulate errors in the chained merging of the state matrix, and the longer the sequence, the more obvious the error will be.

The teacher said a word on the stage, asking the first row of students to write it down and pass it to the second row, the second row pass it to the third row, and so on to the back rows.

But one student was lazy when taking notes, he didn't write down every word, only remembered the general meaning. Just like tf32 cuts off half of the digits after the decimal point in order to run faster, and loses a little precision after rounding at each calculation step.

When the first row passes the message to the second row, the meaning differs a little, which is almost unnoticeable. When the second row passes it to the third row, there is another slight difference. When the message is passed to the tenth row, it has been completely distorted. The teacher said "the meeting will be held at 9 o'clock tomorrow morning", but the last row heard "the iPhone Duo is too expensive".

The solution is to explicitly increase the precision to tf32x3, which minimizes the accumulated error while retaining the performance of Tensor Core as much as possible. This fix was later merged back to the upstream of Flash Linear Attention (PR #1180).

The third case is the decoding kernel. After receiving the feedback that "computation is the main bottleneck", the Agent found that the original implementation split along the V dimension, resulting in the same segment of FP32 normalization and gating calculation being repeated four times. It merged the splits into the same thread block, made the intermediate results stay in the registers permanently, and used one warp-level reduction to replace the repeated calculation, finally achieving a 1.71x speedup compared with the previous version.

The lesson at Tsinghua: The assignment he arranged is exactly the loop described in this article

These two days TANG Jie started his course at Tsinghua University, and the classroom was crowded with people. Interestingly, TANG Jie's course has a lot of assignments.

The assignment list is as follows:

Write Tokenizer and Transformer from scratch, and train a 0.1B model end-to-end; write Triton attention kernel by hand, and test the gains of multi-GPU training and inference by yourself; clean the corpus from raw dump, fit the scaling law and extrapolate; do controlled experiments of SFT, DPO and RLVR on the same base model; build a verifiable environment and harness, train long-range Agent, and encourage the self-judge loop.

The delivery method is to form teams of 2 to 3 people, submit assignments in English NeurIPS format, and conduct on-site demo in the 16th week. Assignments account for 40% of the total score, and the large project accounts for 60%.

Building a verifiable environment, training a long-range Agent, and encouraging the self-judge loop are essentially the youth version of the "dense feedback" loop.

The verifiable environment corresponds to the referee that can make objective judgments; the long-range Agent corresponds to the executor in the loop; the self-judge loop corresponds to the bootstrapping mechanism of "the completed task becomes the training ground for the next round".

The good news is that Anthropic has supplemented the assignments left by TANG Jie.

Anthropic believes that the public cannot see how RSI is implemented in frontier labs. To fill this information gap, it proposes to install three dashboards for "AI development speed".

The first dashboard is used to calculate how much R&D work AI has done for humans, and score each type of R&D task based on the six-level AL0 to AL5 scale of Epoch AI.

As of August 2