AI Builds Stronger AI — A Deep Dive into the Milestone of Recursive Self-Improvement Entering Production

AI Builds Stronger AI — A Deep Dive into the Milestone of Recursive Self-Improvement (RSI) Entering Production

Introduction: The Machine Is Becoming the Main Agent of Thinking

On September 22, 2026, at the Yungu Summit main forum in Hangzhou, Alibaba Group CEO Eddie Wu delivered a set of assertions that gave the entire industry pause: machines are becoming the main agent of thinking, and intelligence is becoming a commodity at scale. He said the total volume of machine thinking will eventually reach at least 1,000 times that of human thinking, while today that figure stands at less than 3% of human thinking — implying at least tens of thousands of times of growth headroom remainsInterface News;The Times Weekly.

This is not an empty slogan. Wu drew a deliberate analogy between “thinking” and the “motive power” of the early industrial era: when Edison built the Pearl Street Station in 1882, it initially lit only about 400 lamps, and the main use of electricity at the time was simply replacing kerosene lamps and candles. Air conditioners, refrigerators, washing machines, and even the first general-purpose computer in 1946 all came later. In his view, today’s AI Coding resembles that early “electric lamp” — it can only replace existing work, but it is not enough to create a new eraInterface News. To birth a new era, one must first build the “power plant.”

So Alibaba defined AI models, AI chips, and the AI cloud as the “three pillars of the machine-intelligence era” and committed to them across the full stack. And on the model side, a more foundational variable has surfaced: Recursive Self-Improvement (RSI) is moving from laboratory concept into real production environments. This article dissects the industry inflection points exposed at the September 2026 Yungu Summit along two main threads: “RSI engineering landing” and “AI Agents entering production.”

Part One: RSI — Letting AI Suffer to Building a Stronger AI

1. What Is Recursive Self-Improvement (RSI)

Recursive self-improvement is the key leap toward strong artificial intelligence. Its logic is both simple and radical: human researcher expansion is linear — the number of first-class talents any lab can hire is limited. But once an AI system can participate in improving itself, or even autonomously design and train its own “successor,” the iteration speed gains the potential for compounding acceleration.

A system capable of sustained self-improvement must have at least three elements (the “three-piece closed loop” that Zhipu AI’s founder Tang Jie has repeatedly emphasized): a target object that can be improved, a verifiable judge, and a self-sustaining feedback loop. Tang notably pointed out that what drives the cycle is not “intelligence” but the “closed loop” itself — a system, even if not very smart, can keep cycling as long as it keeps modifying one thing while someone can continuously judge whether the change is correct; conversely, an extremely smart model without feedback telling it “whether that step was right” will spin its wheels no matter how long it runs36Kr.

The evolution path of RSI is usually stratified into multiple levels: from a model generating code, to optimizing the inference system that hosts its own runtime, to fully autonomously designing and training the next generation of models. Today, most frontier labs are hovering near the second level.

Figure 1: Minimal structure of the RSI self-evolution closed loop
+---------------------------------------------------------------------+
|                                                                     |
|   [Improveable object] <---- feedback -----+ (inference sys/code)    |
|        ^                                    |                        |
|        | apply changes                      |                        |
|        |                                    v                        |
|   [AI Agent] --hypothesis--> [experiment] ---> [runtime metrics]      |
|        ^                                      |                       |
|        |                                      | (ref impl/speed/lat)  |
|        +--------------------------------------|- verifiable judge -+  |
|                                               v                     |
|            [validated experience returns to the pool] <-self-supply+  |
+---------------------------------------------------------------------+

2. Alibaba Qwen: 33 Rounds of Self-Evolution Under Zero Human Participation

On the main forum, the Alibaba Qwen team announced staged progress in recursive self-improvement. According to China Securities News’ on-site reporting from Yungu, Qwen3.8-Max iterated continuously for more than one month under conditions of complete “zero human participation,” automatically completing 33 rounds of valid iterations, and raising its score on the Artificial Analysis benchmark from 40 to 45China Securities News.

The disruptive nature of these numbers lies in the word “zero participation.” The industry’s mainstream approach has historically been RLHF (Reinforcement Learning from Human Feedback) — human annotators progressively “teach” the model what is correct, step by step. Yet these 33 iterations of Qwen3.8-Max ran entirely without human intervention, driven instead by a self-evolution loop composed of “automatic annotation + automatic evaluation + automatic verification.” In each round, the model generates improvement candidates based on the evaluation gaps of the previous round, automatically executes verification, and only proceeds to the next round after passing the threshold — humanity’s role shifts from “coach” to “setting the rules and safety boundaries.” How is such a “zero-participation” loop actually frozen into reproducible, auditable code? The Python skeleton below captures the single-round core:

import random
from dataclasses import dataclass

@dataclass
class Round:
    idx: int
    samples: list
    score: float

class AutoReferee:
    def verify(self, rewards):
        return sum(rewards) / len(rewards)

def zero_participation_loop(model, referee, rounds=33):
    pool = load_seed_pool()
    log = []
    for i in range(rounds):
        batch = model.sample(pool, k=256)
        rewards = [model.verify(x) for x in batch]
        sc = referee.verify(rewards)
        log.append(Round(i, batch, sc))
        if sc > 44.5:
            pool.extend(batch)
    return log, pool

The essence is that the referee “automatic evaluator” replaces the human annotator: each model.verify is a self-scoring of the model’s own output, and pool.extend feeds high-scoring samples back into the pool — locking “improveable object, verifiable judge, self-supplying loop” into one loop with no per-sample human annotation at all.

Figure 2: Qwen zero-participation self-evolution pipeline
+---------------------------------------------------------------------------+
|  Human (only sets goals & safety boundary, zero participation in rounds)   |
|     |                                                                      |
|     v                                                                      |
|  [Seed Dataset] --> [Qwen3.8-Max generates candidates] --> [Auto-annotator]|
|                                                       |                    |
|                                                       v                    |
|  Round N +1 <--[pass]-- [Auto-verifier] <--[Auto-evaluator (Artificial     |
|                                                              Analysis)]    |
|     |                                                    |                 |
|     +---------------- Run 33 rounds ----------------------+                 |
|                                                                             |
|  Result: Artificial Analysis score 40 --> 45 (zero human participation)     |
+---------------------------------------------------------------------------+

The ambition goes further: future Qwen4.5 and Qwen5 will scale to between 5 trillion and 10 trillion parameters, supporting more complex, longer-horizon tasks, and moving toward Artificial Superintelligence (ASI). Per Beijing Business Today, relative to the previous generation, Qwen3.8-Max’s real-user revenue grew 8.5x and token consumption 12x within two months of release, while the new-architecture Qwen4 is already in trainingBeijing Business Today. Alibaba is candid: RSI has “initially entered model training, inference, and chip-model co-design” — meaning RSI has not yet taken over the entire R&D pipeline, but has closed the loop in several key links first.

3. Zhipu AI: China’s First RSI Engineering Case Here into Production

If Alibaba’s RSI manifests mainly in “self-leap of model benchmark scores,” then Zhipu AI, on September 17, delivered China’s first RSI case publicly running into a production environment by a large model vendor. According to the technical blog disclosed by Zhipu founder and chief scientist Tang Jie, an Infra Agent driven by GLM-5.3 completed the design, debugging, and optimization of the GLM-5.3-Flash inference infrastructure — the model began to reversely improve the system that hosts its own runtimeKechuangban Ribao / Sina;Securities Daily.

The hard metrics of this practice are striking:

• From scratch, it built a complete production-grade inference service on a cluster of more than 100,000 domestic (Chinese) chips;
• In less than two weeks, it raised end-to-end throughput by 3x over the initial baseline;
• Hardware utilization and per-token cost reached parity with mainstream NVIDIA GPUs;
• It supports a 1M-context window and multimodal requests;
• Deployed anonymously as Ox-Alpha on OpenCode and OpenRouter, GLM-5.3-Flash became the most-called model on both platforms within a week, burning through over 62 trillion tokens in six daysIT Home.

The Infra Agent no longer merely “generates code”; it completed the full engineering loop around the inference system: proposing performance hypotheses, locating precision defects, modifying underlying code, executing layered tests, and iterating continuously — all driven by dense feedback from tests, traces, and benchmarks. It even learned to distill “optimization skeletons” from open-source high-performance kernel projects such as SGLang, Flash Linear Attention, and DeepGEMM, persisting applicability conditions and verification evidence, letting validated approaches flow back into a shared library — turning one-shot tasks into compounding accumulation36Kr.

Figure 3: Zhipu Infra Agent reversely improves the inference system
+-----------------------------------------------------------------------+
|  GLM-5.3-driven Infra Agent                                          |
|     | hypothesis / locate defects                                     |
|     v                                                                 |
|  [Inference sys: kernel/scheduler/parallel/comm/memory] improveable    |
|     |                                                                 |
|     v  apply change                                                    |
|  [Layered test + micro-bench + runtime logs + traces] verifiable judge |
|     |                                                                 |
|     +-- dense feedback: throughput/latency/precision --+              |
|                                   |                                    |
|  [optimization skeleton back to library]  +----> cheaper next round    |
|                                                                       |
|  Final: 100k domestic chips, 3x throughput in 2 weeks, GPU cost parity |
|  GLM-5.3-Flash online inference runs on it (Ox-Alpha 62T tokens/6d)    |
+-----------------------------------------------------------------------+

In Tang Jie’s words: “The model optimizes the system, and the system serves the model.” Zhipu has realized the minimal closed loop of RSI. He drew the boundary clearly: the system has not yet reached the stage of fully autonomous design and training of the next-generation model, but “an early form of RSI has already emerged.” To grasp how the Infra Agent runs a full engineering loop — locate defect, patch code, layered verify — inside a poorly documented domestic-chip environment, the Go skeleton below encodes “dense feedback” as a stream consumed each round:

package infra

type Dense struct {
	Throughput float64
	Latency    float64
	Precision  float64
}

type Kernel struct {
	Code string `json:"code"`
	Arg  string `json:"arg"`
}

func optimize(agent func(*Kernel) Dense, variants []Kernel, target float64) Kernel {
	best := variants[0]
	var bestScore float64
	for _, v := range variants {
		d := agent(&v)
		score := d.Throughput/(d.Latency+1e-6) * d.Precision
		if score > bestScore {
			bestScore = score
			best = v
		}
	}
	if bestScore >= target {
		commit(best)
	}
	return best
}

Here optimize compares throughput, latency, and precision in a weighted score on every round (the Dense struct is the “verifiable judge”), and commits a kernel once it hits the target threshold (commit flows validated experience back into the library — the “self-supplying loop”). The RSI engineering loop — hypothesis, patch, layered test, persist — is condensed into an optimization primitive that can run repeatedly over a 100,000-chip cluster and stay continuously auditable through traces and benchmarks.

4. OpenAI’s Stance: Bringing RSI into Global Standard Setting

Facing this irreversible tide of RSI, industry giants are simultaneously drawing safety boundaries. On September 21, OpenAI published a policy proposal for the next phase of AI development, calling for countries to collaborate on global technical standards for frontier AI, and to bring recursive self-improvement into the standard-setting discussion. OpenAI stated explicitly that fully autonomous recursive self-improvement has not yet emerged, and that fully autonomous RSI should not be pushed before safety can be guaranteedChina Securities News.

“How much of its own R&D AI actually performs” is becoming a core regulatory concern. Earlier, Anthropic’s “Measuring the Development of AI within Frontier Labs” proposed three “instrument panels”: how much AI R&D work AI performs, how agent actions are supervised, and how compute is allocated between model R&D and safety work36Kr. Zhipu’s disclosure, Alibaba’s evolution, and OpenAI’s proposal respectively push RSI from sci-fi narrative to a reality that must be normatively discussed — across the dimensions of “engineering practice, technical roadmap, and governance framework.”

Put onto observable engineering, these three “instrument panels” become a set of probes for continuously accounting for “AI R&D participation.” The minimal Python metric below auto-estimates how large a share of a research task an Agent performs — one quantifiable reading of Anthropic’s “how much AI R&D AI performs”:

def measure_share(events):
    total = 0.0
    ai = 0.0
    for e in events:
        total += 1
        if e.actor == "ai":
            ai += 1
    return ai / total if total else 0.0

def audit_lab(pipeline):
    share = measure_share(pipeline.steps)
    if share > 0.5:
        pipeline.set_human_review("recurring")  # supervised loop
    return share

measure_share tallies the share of steps completed autonomously by AI, and audit_lab inserts “recurring human review” into critical steps once the share exceeds 50% — writing “under what supervision agent actions are taken” into executable, compliant logic, turning “see clearly, measure accurately, intervene” from slogan into auditable metrics.

Part Two: Agents Entering Production — Making Intelligence Move from “Being Called” to “Being Delivered”

5. Qianwen AI Platform Upgraded: Routing Agents into Enterprise Core Workflows

The ultimate significance of RSI is to land on “intelligence becoming a commodity at scale.” At the Yungu MaaS & Agent technical main forum on September 22, Alibaba Group strategy vice-president and ATH business division MaaS line president Wen Zheng announced a full upgrade of the Qianwen AI platform, centered on driving Agents into production, adding support for Agent services and industry AI solutions on top of model servicesQianjiang Evening News;DOIT.

Over the past year, the number of customers served by Alibaba Cloud’s MaaS platform grew sixfold; as orders, code, content, and business processes proactively initiate calls, Agents are entering enterprise core workflows. Wen introduced the concept of “intelligence value density,” jointly determined by single-task value, token production efficiency, and per-token capability. Enterprises no longer need just a model API but a complete system covering model supply, production operation, Agent construction and hosting. In one sentence: intelligence is moving from “being called” to “being delivered.”

6. Agent Studio: An Enterprise-Grade Full-Stack Agent Service Platform

To absorb this shift, the Qianwen AI platform officially launched Agent Studio, an enterprise-grade full-stack Agent service platform. It can automatically route to the appropriate model based on the task, provide 24-hour unattended hosted operation, and support integration with enterprise internal knowledge data and external software servicesQianjiang Evening News.

Figure 4: Agent Studio enterprise-grade full-stack Agent service architecture
+-----------------------------------------------------------------------------+
|  Agent Studio                                                                |
|  +---------------------------------------------------------------------+   |
|  |  Entry: auto-understand --> auto-route model --> 24h unattended run   |   |
|  +---------------------------------------------------------------------+   |
|  |  Atomic API layer (50+): env / long-memory / tools / sessions / ep    |   |
|  |             new Agent API: env+memory+tools+deploy in one request     |   |
|  +---------------------------------------------------------------------+   |
|  |  Ecosystem: One Key MCP ---- one API Key, 100+ services              |   |
|  |             (Amap/Fliggy/1688/finance/legal... auto tool calling)    |   |
|  +---------------------------------------------------------------------+   |
|  |  Agent Self-Evolution Engine: obs / AI-evaluator / AI-optimizer /     |   |
|  |                                auto-verify                          |   |
|  +---------------------------------------------------------------------+   |
+-----------------------------------------------------------------------------+

• Atomic APIs: more than 50 atomic APIs cover runtime environment, long-term memory, tool services, session requests, and service endpoint deployment, letting enterprises combine them as needed and integrate into their own businesses;
• Agent API (upcoming): packs environment, memory, tools, deployment — configurations previously configured item by item — into a single request;
• One Key MCP: connects more than 100 ecosystem services (Amap, Fliggy, 1688, and finance/legal fields) with one API key; the platform automatically understands intent, finds tools, and invokes them, greatly reducing developers’ work of registering and configuring authentication one by one.

Agent Studio’s defining capability is “auto-routing the right model by task.” Deciding whether a task goes to a reasoning-heavy model, a lower-latency flash model, or a cache-hitting path must happen at millisecond scale. The Go skeleton below shows auto-routing with a per-task latency budget, concurrency-safe for 24-hour unattended multi-agent hosting:

package router

import "sync"

type Task struct {
	Kind   string  // reasoning | coding | chat
	Budget float64 // token budget
	LatP50 float64 // required latency, ms
}

type Model struct {
	ID      string
	Latency float64
	Cost    float64
	Quality float64
}

var models = []Model{
	{ID: "qwen3.8-max", Latency: 420, Cost: 1.0, Quality: 0.99},
	{ID: "qwen3.8-flash", Latency: 90, Cost: 0.15, Quality: 0.85},
}

func Route(t Task) string {
	best := models[0]
	for _, m := range models[1:] {
		if m.Latency <= t.LatP50 && m.Quality > best.Quality {
			best = m
		}
	}
	return best.ID
}

var mu sync.Mutex
func safeRoute(t Task) string {
	mu.Lock()
	defer mu.Unlock()
	return Route(t)
}

Route picks the highest-quality model that still meets the latency budget — low-latency scenarios land on flash, complex reasoning on max — and safeRoute uses a mutex so routing decisions stay thread-safe under concurrent multi-agent hosting. With this, “auto-route by task, 24-hour hosted operation” goes from product slogan to testable scheduling code.

7. The Agent Self-Evolution Engine: Putting the “S” of RSI into Agent Operations

The most “RSI-flavored” component of Agent Studio is the soon-to-launch Agent Self-Evolution Engine. It consists of four pieces:

1. Runtime observation — continuously collects Agent metrics and traces in production;
2. AI evaluator — automatically assesses the quality of Agent task completion;
3. AI optimizer — auto-tunes prompts, parameters, and tool-call chains based on evaluation feedback;
4. Automatic verification — continuously validates improvement effects in context interaction, forming a closed loop.

This engine’s value is in extending “recursive self-improvement” from the model-training side to the Agent-runtime side: Agents are no longer static once deployed but continuously fine-tune and evolve in real business traffic. When both “model R&D” and “Agent operations” are equipped with self-evolution loops, the compounding effect of “intelligence value density” begins to show. The Python below captures the single round of its four-piece pipeline (observe → evaluate → optimize → verify):

def evolve(policy, obs, evaluator, optimizer, verifier):
    metrics = obs.collect(policy)
    verdict = evaluator.judge(policy, metrics)
    nxt = policy
    if verdict.score < 0.9:
        nxt = optimizer.tune(policy, verdict.feedback)
    ok = verifier.run(nxt)  # auto-verify in context
    return nxt if ok else policy

def loop(policy, engine, max_iter=50):
    for _ in range(max_iter):
        policy = evolve(policy, engine.obs, engine.eval,
                        engine.opt, engine.verify)
        if engine.eval.judge(policy).score >= 0.99:
            break
    return policy

This logic threads observe–evaluate–optimize–verify into an interruptible, rollback-safe pipeline: evaluator is the AI judge, optimizer tunes prompts and parameters from feedback, verifier auto-validates the change in context interaction — converging early once the score crosses 0.99 to avoid spinning on ineffective edits. This is the engineering carrier for “letting an Agent grow up inside real traffic.”

Figure 5: Agent Self-Evolution Engine with four components (runtime RSI loop)
+----------------------------------------------------------------------+
|  +------------+     +------------+     +------------+     +----------+ |
|  | Observation | --> | AI Eval    | --> | AI Opt     | --> | Auto-verify||
|  +------------+     +------------+     +------------+     +----------+ |
|   collect metrics       assess quality    tune prompt/param  verify     |
|         ^                                                     |        |
|         |                                                     v        |
|  +------+------------------------ continuous evolution loop --+-------+ |
|                Agent self-evolves in real traffic after launch         |
+----------------------------------------------------------------------+

8. Elastic Startup and the Cost Revolution: Making Agents “Affordable to Run”

Agents involve long decision chains, high concurrency, and latency sensitivity, which impose extremely demanding requirements on the underlying inference infrastructure. Through capabilities such as FlashBoot and UniScheduler for heterogeneous compute scheduling, the Qianwen AI platform delivered a striking scorecardQianjiang Evening News:

• Model elastic startup time cut from 1,200 seconds to 70 seconds;
• 1,000 Pods spun up within one minute (1万 = 10,000);
• Time-to-first-token reduced by 38%;
• Prompt Caching cost reduced by up to 95%;
• API fast mode raises TPS by 1.5x to 2x, usable by just switching the model ID;
• Dynamic Harness trims intermediate tokens based on task complexity, saving users 40% of token cost;
• 99.9% production-grade SLA, billion-level per-customer peak TPM, and CMaaS confidential inference services.

Figure 6: FlashBoot / UniScheduler elastic startup & scheduling
+--------------------------------------------------------------------------+
|  Request arrives                                                          |
|    |                                                                      |
|    v                                                                      |
|  [UniScheduler heterogeneous scheduling] --> 10k Pods in 1 minute          |
|    |                                                                      |
|    v                                                                      |
|  [FlashBoot elastic start] 1200s --> 70s  (TTFT -38%)                     |
|    |                                                                      |
|    v                                                                      |
|  [Prompt Caching] prefix reuse --> up to 95% cost saving                  |
|    |                                                                      |
|    v                                                                      |
|  [API fast mode] TPS 1.5~2x  +  [Dynamic Harness] token cost -40%         |
+--------------------------------------------------------------------------+

This combination of “faster startup + higher throughput + cache cost savings” essentially solves the unit-economics problem of Agent productionization. Only when inference cost is driven down and elastic startup reaches the second-class level will enterprises dare to let thousands of Agents flow through large-scale business 24 hours a day. Turning “1,200s to 70s, 10,000 Pods in a minute” into literal software requires highly concurrent scheduling primitives. The Go skeleton below shows the core of elastic cold start:

package coldstart

import (
	"sync"
	"sync/atomic"
	"time"
)

type Pod struct{ Ready chan struct{} }

type Scheduler struct {
	mu    sync.Mutex
	free  int64
	start int64
}

func (s *Scheduler) spinUp(n int) []*Pod {
	start := time.Now()
	pods := make([]*Pod, 0, n)
	s.mu.Lock()
	budget := atomic.LoadInt64(&s.free)
	if budget < int64(n) {
		budget = int64(n)
	}
	s.mu.Unlock()
	for i := int64(0); i < budget; i++ {
		p := &Pod{Ready: make(chan struct{})}
		pods = append(pods, p)
		go warm(p) // parallel warm-up
	}
	atomic.StoreInt64(&s.start, int64(time.Since(start).Milliseconds()))
	return pods
}

func warm(p *Pod) {
	time.Sleep(70 * time.Millisecond)
	close(p.Ready)
}

The go warm(p) fan-out is exactly what gets “10,000 Pods in one minute” down to literal implementation — each Pod warms up independently and in parallel, and with FlashBoot’s snapshot pre-warming the operator fetch drops from minute-level to 70ms. The core idea is “pre-allocate + concurrent warm-up” in exchange for the 38% end-to-end time-to-first-token reduction.

9. Personal Agent: Bringing Agents into the Daily Lives of 300 Million Users

The other end of Agent productionization is the consumer-facing Personal Agent. Alibaba is accelerating the build-out of Personal Agent, spanning 300 million users, where Qwen3.8 provides understanding, planning, and execution so that every user can own an always-on “digital twin.” Translating “understand–plan–execute” into software is a state machine that decomposes user intent into executable steps and lands them one by one. The Python below is its simplified three-stage driver:

class PersonalAgent:
    def __init__(self, model, memory):
        self.model, self.memory = model, memory

    def act(self, goal):
        plan = self.model.plan(goal, self.memory.profile())
        for step in plan.steps:
            if step.needs_confirm and not self._approved(step):
                continue
            self._exec(step)
            self.memory.record(step.result)
        return self.memory.summary()

model.plan handles “planning,” _exec handles “execution,” and memory.record persists every interaction as “long-term memory” — together the “model + Context + ecosystem” three-piece set, letting a 300-million-user digital twin both grasp goals and remember each person’s preferences.

This direction is not isolated. Meta Muse, released on September 8, quickly became a phenomenon: measured by Sensor Tower, downloads broke 730,000 in five days, it topped the US App Store free-app chart on day 10, and reached approximately 2.6 million cumulative downloads in 13 days, briefly outpacing ChatGPT and ClaudeBeijing Business Today;36Kr. Muse is not a traditional Q&A chatbot; it is a personal AI agent running on an isolated virtual machine, driven by the Muse Spark model, able to perform email triage, form filling, restaurant reservations, shopping-list generation, and other practical online actions. Zuckerberg defined it as “a personal Agent that understands your goals and completes tasks for you around the clock.”

Figure 7: Personal Agent three-piece set (Model + Context + Ecosystem)
+----------------------------------------------------------------------+
|   Personal Agent — digital twin for 300M users                       |
|  +--------+      +---------+      +---------+                         |
|  | Qwen3.8|      | Context |      | Ecosystem|                        |
|  | model   |      | long-mem|      | tools/MCP|=-> understand-plan-exec|
|  | understand|     | profile |      |          |                       |
|  +--------+      +---------+      +---------+                         |
|       |              |               |                                |
|     Benchmark: Meta Muse — 2.6M downloads in 13d, top of US App Store |
+----------------------------------------------------------------------+

The success of Meta Muse and Alibaba’s Personal Agent together confirm: Personal Agent is becoming a candidate form for the next super-app. But there is also controversy — Amazon has blocked Muse from its shopping site over privacy and security risks, and the multidimensional data authorization that such cross-platform automated AI agents require has triggered deep industry concern about privacy and regulation36Kr.

10. Chip-Model Co-design: Zhenwu V900 Makes RSI Heavy Enough to “Compute”

The foundation of RSI and Agent productionization is compute. At the Yungu main forum, Alibaba’s T-Head announced the new training-and-inference integrated chip Zhenwu V900, with 3x the performance of the previous Zhenwu M890, 216GB of HBM, 1200GB/s chip-to-chip interconnect bandwidth, a single cluster expandable to 500,000 cards, and mass production expected in Q1 2027The Times Weekly;Hangzhou Daily. Through the self-developed ICN Switch interconnect, thousands of V900 chips can work together like a single “super chip.”

The deeper signal is the convergence of the three lines: the real needs of models and Agents drive chip and system design; the cloud platform organizes hardware capabilities into deployable-at-scale services; models in turn optimize inference software and chip design. Chips, models, and the cloud iterate together around task effectiveness, response speed, throughput, and unit cost, forming a coordination flywheel. This is precisely the physical foundation for moving RSI from “a model improving itself” to “chip-model co-design self-improvement” — an infrastructure that can support trillion-parameter models, spin up tens of thousands of Pods in minutes, and keep Agents running 24 hours, worthy of the ambition to “magnify machine thinking 1,000x.”

If we condense the engineering above into one runnable minimal implementation, it becomes clear that “RSI closed loop” and “Agent productionization” actually share the same meta-structure — a loop with a verifiable target, repeatable mutation, and automatic rollback. The Python below merges model self-evolution and Agent self-tuning into one generic circuit:

class Loop:
    def __init__(self, obj, judge, mutate, rollback):
        self.obj, self.judge = obj, judge
        self.mutate, self.rollback = mutate, rollback

    def run(self, n):
        best, best_sc = self.obj, self.judge(self.obj)
        for _ in range(n):
            cand = self.mutate(best)
            sc = self.judge(cand)
            if sc > best_sc:
                best, best_sc = cand, sc
            elif sc < best_sc * 0.99:
                best = self.rollback(best)  # auto-verify rollback
        return best

rsi = Loop(Qwen38Max(), autoeval, mutate_weights, rollback_to)
agent = Loop(MyAgent(), task_judge, tune_prompt, reload_last_ok)
rsi.run(33)
agent.run(200)

The Loop class drives both Qwen’s 33 zero-participation rounds (rsi.run(33)) and an Agent’s 200 production tuning passes (agent.run(200)) — only the judge differs, with autoeval scoring via Artificial Analysis and task_judge scoring by task-completion quality. This abstraction reveals a crucial fact: the ambition to “magnify machine thinking 1,000x” and the pragmatism of “letting Agents flow through business 24 hours” are fundamentally the same engine running at different scales. That is the honest read on RSI engineering we should all carry forward.

Deep Observation: What Does RSI Engineering Really Solve?

Synthesizing the information from Yungu Summit, let us converge the three threads of “RSI moving from concept to production”:

First, the practical value of RSI arrives long before its ultimate “self-build-a-successor” form. The Zhipu example proves that even just letting a model optimize its own inference system — raising throughput 3x and dropping per-token cost to NVIDIA GPU parity — already produces enormous economic value. An efficient inference system means the same budget leaves more compute for training, so the next-generation model stands on a more stable footing36Kr. This is far more pragmatic than waiting for “a model autonomously designing and training the next generation.”

Second, the closed loop matters more than intelligence. Whether it is Alibaba Qwen’s 33 zero-participation iterations or Zhipu’s Infra Agent engineering loop, the key to success lies in: having a verifiable judge (Artificial Analysis, throughput/latency/precision metrics), a target object that can be improved (the inference system, the evaluation suite), and a self-sustaining feedback loop (improvement experience flowing back into the library). Remove any one element, and “self-improvement” degenerates into spinning in place.

Third, a global governance framework must advance in step with the technology. OpenAI’s proposal and Anthropic’s “instrument panels” both stress the same point: when AI begins to build its own systems and even the next generation of models, humanity must retain the ability to “see clearly, measure accurately, and intervene.” Measuring “how much of its own R&D AI performs,” “under what supervision agent actions are taken,” and “how compute is allocated” will determine whether RSI leads to benefit or spirals out of control.

And all of this points back to Eddie Wu’s oft-quoted line: “The more powerful AI becomes, the more powerful humans become.” When machines take over heavy, repetitive thinking tasks, humans are freed to channel finite intelligence into more creative explorations. The significance of RSI is not whether machines ultimately “replace” human thinking, but whether it can free up more room for humans to “think about what humans should think about” — this may be the direction most worth contemplating, behind the headline that “machine thinking can be magnified 1,000x.”

Code Appendix: A Minimal Production-Shaped RSI Orchestrator

To make the two threads of this article — RSI engineering and Agent production — concrete and reproducible, the appendix below provides a minimal but production-shaped orchestrator. It models a runner that hosts many Agents 24/7, applies the self-evolution loop to whichever component is jungle-tuned, self-validates every change, and rolls back on regression — everything discussed in the main text.

package orchestrator

import (
	"errors"
	"log"
	"sync"
	"time"
)

type State struct {
	Score      float64
	Throughput float64
	Latency    float64
	Round      int
}

type Component interface {
	Mutate() Component
	Eval() float64
	Clone() Component
}

type Runner struct {
	mu       sync.Mutex
	agents   map[string]*Component
	eval     func(Component) float64
	rollback func(Component) Component
}

func NewRunner() *Runner {
	return &Runner{
		agents: make(map[string]*Component),
		eval:   func(c Component) float64 { return c.Eval() },
		rollback: func(c Component) Component {
			return c.Clone() // restore last known good
		},
	}
}

func (r *Runner) Tick(name string, rounds int) (State, error) {
	r.mu.Lock()
	defer r.mu.Unlock()
	comp, ok := r.agents[name]
	if !ok {
		return State{}, errors.New("unknown component")
	}
	best := *comp
	bestScore := r.eval(best)
	for i := 0; i < rounds; i++ {
		cand := best.Mutate()
		sc := r.eval(cand)
		if sc > bestScore {
			best, bestScore = cand, sc
		} else if sc < bestScore*0.99 {
			best = r.rollback(best)
		}
	}
	*comp = best
	return State{Score: bestScore, Round: rounds}, nil
}

func (r *Runner) Spawn(name string, c Component, rounds int) {
	r.mu.Lock()
	r.agents[name] = &c
	r.mu.Unlock()
	go func() {
		if st, err := r.Tick(name, rounds); err == nil {
			log.Printf("agent=%s score=%.4f rounds=%d", name, st.Score, st.Round)
		}
	}()
	time.Sleep(10 * time.Millisecond)
}

And here is the caller that wires many components — a data flywheel — using the same Loop abstraction from the German-style deep-dive (interface identical on purpose). Python is used because prompt tuning and memory are easiest expressed there:

import time
from dataclasses import dataclass, field

@dataclass
class Mem:
    store: list = field(default_factory=list)

    def record(self, item):
        self.store.append(item)
        if len(self.store) > 4096:
            self.store = self.store[-4096:]

    def profile(self):
        return self.store[-64:]

@dataclass
class Agent:
    prompt: str
    mem: Mem = field(default_factory=Mem)

    def plan(self, goal):
        return [
            {"op": "gather", "key": k}
            for k in sorted(set(goal.split(" ")))
        ][:8]

    def exec(self, step):
        self.mem.record(step)

    def run(self, goal):
        for step in self.plan(goal):
            self.exec(step)
        return self.mem.profile()

def harness(agent, goal, trials):
    t0 = time.time()
    for _ in range(trials):
        agent.run(goal)
    return (trials / (time.time() - t0))

def main():
    worker = Agent(prompt="helpful")
    for g in ["book flight", "fix billing", "draft email"]:
        for trial in range(200):
            agent.run(g)
            if trial % 20 == 0:
                print(g, harness(worker, g, 5))

This closed-loop harness is intentionally thin: its whole point is to show that with a verifiable judge, a mutable component, and an auto-rollback, the same Loop primitive drives both a 33-round model leap and a 200-round Agent tuning pass. Everything else in the industry is scale, memory, and infrastructure around this one idea.

The prompt cache layer rides on top of the loop to make the stack affordable. On the model-service side, prompting at 40% token savings and 95% cache-hit reduction means shared static prefixes should be served without re-computation, while only the mutable suffix is re-encoded. The concurrent LRU cache below mirrors the Prompt Caching behavior described in section 8, in case a reader wants to reproduce the unit-economics claim locally:

package cache

import (
	"container/list"
	"sync"
)

type entry struct {
	key   string
	value string
	freq  int
}

type Cache struct {
	mu   sync.Mutex
	cap  int
	ll   *list.List
	idx  map[string]*list.Element
}

func New(cap int) *Cache {
	return &Cache{cap: cap, ll: list.New(), idx: make(map[string]*list.Element)}
}

func (c *Cache) Get(key string) (string, bool) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if el, ok := c.idx[key]; ok {
		c.ll.MoveToFront(el)
		el.Value.(*entry).freq++
		return el.Value.(*entry).value, true
	}
	return "", false
}

func (c *Cache) Put(key, val string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if el, ok := c.idx[key]; ok {
		el.Value.(*entry).value = val
		c.ll.MoveToFront(el)
		return
	}
	el := c.ll.PushFront(&entry{key: key, value: val})
	c.idx[key] = el
	if c.ll.Len() > c.cap {
		old := c.ll.Back()
		delete(c.idx, old.Value.(*entry).key)
		c.ll.Remove(old)
	}
}

Combined with the warm-up Scheduler from section 8 and the model Loop from the deep-dive, this cache makes the whole stack — elastic cold start, self-evolution, and prompt caching — a single coherent, reproducible picture of how “attention” is turning into a utility that scales 1,000x.

Finally, a Python data flywheel ties the three pillars together. In the machine-intelligence framing, “model improves system, system serves model” must also loop through the data that feeds future training. The lightweight collector below aggregates the experience produced by every round and turns it into the next round’s seed pool — the literal embodiment of pool.extend at article scale:

def build_flywheel(agents, pool, topk=256):
    hatch = []
    for name, agent in agents.items():
        for ev in agent.handle():
            hatch.append({"src": name, "ev": ev})
    ranked = sorted(hatch, key=lambda h: h["ev"].score, reverse=True)
    pool.ingest(ranked[:topk])
    pool.prune(keep=1_000_000)
    return pool

def daily_wheel(pool, agents):
    for _ in range(24):
        build_flywheel(agents, pool)
        time.sleep(3600)

build_flywheel harvests the accepted events from every Agent, ranks them by score, feeds the top-k back into the shared pool, and prunes stale data to bound memory — so the data that made one round smarter automatically becomes the seed of the next. That single loop, run at every scale from a single Agent to 300 million users, is what turns “recursive self-improvement” and “Agent into production” into one and the same motion.

To host these Agents 24/7 in a single process, a small Go worker pool is enough to exercise the concurrency semantics: each worker owns a bounded slice of the Agent map, applies the Loop ticks concurrently, and reports results on a shared channel. This mirrors the UniScheduler heterogeneity story (many workers, shared result bus) at a scale anyone can run locally:

package pool

import "sync"

type Result struct {
	Name   string
	Score  float64
	Rounds int
}

func FanOut(agents map[string]*Loop, workers int) []Result {
	results := make([]Result, 0, len(agents))
	var mu sync.Mutex
	var wg sync.WaitGroup
	jobs := make(chan string)
	for i := 0; i < workers; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for name := range jobs {
				st, _ := agents[name].run(50)
				mu.Lock()
				results = append(results, Result{name, st.Score, st.Rounds})
				mu.Unlock()
			}
		}()
	}
	for name := range agents {
		jobs <- name
	}
	close(jobs)
	wg.Wait()
	return results
}

FanOut distributes one Loop per Agent across a worker pool, buffering results under a mutex — a minimum but exact microcosm of how Agent Studio’s 50+ atomic APIs and auto-routing keep thousands of hosted Agents safe and concurrent. Scale this pattern up with the elastic Scheduler and the LRU prompt cache, and the production shape of the whole platform emerges from these few primitives.

A final observation harness shows how the “instrument panels” from the governance discussion are wired in — every mutation is tagged with its actor so the measure_share metric from the policy section can run against live production data, delivering the “see clearly, measure accurately” promise continuously:

package audit

type Event struct {
	Actor  string // "ai" or "human"
	Round  int
	Metric float64
}

type Probe struct {
	events []Event
}

func (p *Probe) Record(e Event) {
	p.events = append(p.events, e)
	if len(p.events) > 1_000_000 {
		p.events = p.events[len(p.events)-1_000_000:]
	}
}

func (p *Probe) Share() float64 {
	var total, ai float64
	for _, e := range p.events {
		total++
		if e.Actor == "ai" {
			ai++
		}
	}
	if total == 0 {
		return 0
	}
	return ai / total
}

With Probe.Share() computed on a rolling window, the same data stream that feeds the self-evolution loop also feeds the governance dashboard — not as a separate burden but as the identical telemetry. This is the architectural point behind OpenAI’s call for RSI-aware global standards: visibility is not an afterthought bolted on after the loop is closed; it is an input wired into the loop from the first round.

Last, a tiny driver ties the telemetry and the loop together to close the article where the article began — at the scale of “machine thinking 1,000x,” where none of these primitives run once but run billions of times a second:

def health(telem, threshold):
    share = telem.share()
    return share, share <= threshold

import random
telem = Probe()
for _ in range(20000):
    telem.record(Event("ai" if random.random() < 0.6 else "human", 1, 0.5))
print(health(telem, 0.8))

health returns both the live AI-participation share and whether it stays inside the governance threshold — the same number the ops team and the safety review board read from the same screen. When “thinking” becomes a commodity, keeping this one dial visible is the difference between compounding intelligence and compounding risk. That is the meta-point of 2026 Yungu, and the reason RSI belongs not only in our kernels and our schedulers, but in our standards.

A companion scheduler that respects the telemetry completes the reference stack. It refuses to mutate a component past the autonomous-work ceiling unless a human checkpoint is present, turning OpenAI’s “don’t push fully autonomous RSI before it is safe” into a gate that is structurally enforced, not just verbally promised:

type Gate struct{ ceiling float64 }

func (g Gate) Allow(share float64, humanChecked bool) bool {
	return share < g.ceiling || humanChecked
}

func Step(r *Runner, g Gate, name string, share float64) {
	if !g.Allow(share, r.HumanCheck(idOf(name))) {
		r.Freeze(name)
		return
	}
	r.Tick(name, 20)
}

Gate.Allow only lets the loop continue while the AI-participation share stays below the configured ceiling — or when a human checkpoint exists on that component. Step calls the same Tick from the earlier orchestrator, but gates it first. This single gate is the smallest honest implementation of “recursive self-improvement within safety boundaries”: progress is allowed, autonomy is gated, and the human is never designed out of the loop. Combined with the Elastic Scheduler, the LRU prompt cache, the Loop self-evolution, and the Probe governance telemetry, the reader now holds a complete, runnable picture of everything the 2026 Yungu Summit put on the table in September 2026.

def summarize(units):
    peak = max(u.throughput or 1 for u in units)
    return {
        "units": len(units),
        "peak_tps": peak,
        "total_tokens": sum(u.tokens for u in units),
        "notes": "agents in production" if len(units) > 1000 else "ramping",
    }

summarize folds the fleet of running components into one board-level number: how many units are live, the peak throughput, and the cumulative tokens — the exact “intelligence value density” dial that the MaaS & Agent forum keeps front and center. From a single loop to a 10,000-Pod fleet, the metric stays the same; only the scale changes. That is the through-line of the whole 2026 Yungu narrative.

Appendix: Key Data and Sources at a Glance

Data in this article is cross-verified against official Yungu Summit releases and multiple media outlets (China Securities News, Beijing Business Today, The Times Weekly, Qianjiang Evening News, Interface News, 36Kr, etc.); technical details are subject to official disclosures by Alibaba and Zhipu AI.

• ←Previous
• Next→