RSI is probably the most science fiction word in the world for AI.
In the strongest version, all you have to do is say a word to a system and make it a better self, and it can come up with new ideas, build a training process, validate results, and ultimately deliver a more capable successor.
This picture has not yet become a reality. But over the past few months, discussions around recursive self-improvement (RSI) have shifted from whether or not it will happen to a more specific question: which parts of the AI research and development cycle have been taken over by AI today?
In May, Jack Clark, co-founder of Anthropic, made a radical judgement: by the end of 2028, there would be a 60% chance of uninvolved AI development; he acknowledged that it would be more likely in the near future to see end-to-end training at the non-frontal model level. Nathan Lambert of the Allen Institute for AI suggested that AI would enter the core of model development, but that data, computing, organizational coordination and system complexity would cause the aircraft to continue to deteriorate and it would be difficult to form friction-free indicators.
Now, a joint team from the Shanghai University of Transportation's School of Artificial Intelligence, Deep Power Technology, Infinite Frontier and the National University of Singapore has provided a sample that is well suited to this debate.
The team had Agent ((Codex GPT-5.6-Sol) lead the development of a 27B industrial coding model: from data evolution, SFT cold start, to the same strategy from distillation and verifiable reward reinforcement, Agent was responsible for selecting experiments, diagnosing failures, and repeatedly revising training strategies.
Title: Recursive AI-led Development of Frontier Industrial Coding Model
Liunanfu1992.github.io/iCoder-site
This article is part of a two-part series entitled "Coder_Tech_Report".
GitHub：github.com/bingreeky/iCoder
Hugging Face：huggingface.co/i-Coder
27B, enter the first ladder of Industrial Coding.
Industrial coding is not the same problem as generating the code we talk about every day.
To generate RTL, the model needs to convert natural language specifications into circuit descriptions that satisfy timing, replication, state migration, and level constraints; to generate a GPU Kernel, it is not only necessary to ensure that the values are correct, that it can compile, but also to actually use the hardware to gain acceleration.
That's why the team chose Industrial Coding as a testing ground: it's difficult enough, and there's a real toolchain to provide verifiable feedback.
Figure 1 shows iCoder's position on the four core industrial coding benchmarks. Each list is ranked independently, with data coming from a team-wide assessment.
Note: Ranking refers only to the model and team unified assessment protocols in the technical report; different assessment settings cannot be directly horizontal and outward.
Compared to the similarly sized Qwen 3.6-27B, iCoder's RTLLM increased from 49.6 to 68.0, VerilogEval Spec-to-RTL increased from 70.1 to 86.3, and the correct number of KernelBench L2 missions increased from 28 to 74, reaching the original 2.64 times.
In complex RTL tasks such as RealBench, ArchXBench, iCoder still lags behind some of the closed-source models. But it can also be seen that the team's AI automation system can deliver a 27B model, allowing it to enter the competitive field of front-end models on both chip RTL and GPU Kernel at the same time.
It's more important than scores:
This time, the model itself is being improved.
There are many self-evolving systems of hydrogen today, but the improvement is not really a model.
The first type of system allows a fixed model to repeatedly submit and test programs, ultimately obtaining better programs or algorithms; the second type of system modifies the instructions, tools, memory and Agent harness on the outside of the model to make the same base perform better. Both are valuable, but the capabilities usually remain in the outside system.
A stronger step is to rewrite the experience of the model parameters so that the acquired capabilities can remain separate from the original workflow. iCoder belongs to this layer: iCoder's Agent is trained through the whole process of participating in data, SFT, OPSD and RLVR, so that the experimental conclusion really changes the next checkpoint.
The project developed the front-end model as a long-link stress test. Data selection affects the training distribution, training strategies change the difficulty of subsequent samples, verifier vulnerabilities distort rewards, and resource budgets in turn limit which experiments can run. Any errors can spread along the flowline.
Humanity has not disappeared.
The roles have changed.
Figure 2: Research Skills, resource authorization and module operation are provided by humans; Agents circulate data, SFT, OPSD and RLVR across borders.
The division of labor used by the team can be summarized in eight words: high-density preconditions, low-frequency interventions.
Human experts have written a set of executable Research Skills: what is the goal, how to separate data and evaluation sets, what resources are allowed to access, how to launch distributed tasks, what integrity requirements must be met by verifiers, how each checkpoint traces data, code and parent models.
These Skills are like a study operating system: setting boundaries, providing tools, maintaining audit records, but not deciding the experimental conclusions beforehand. In this space, the Agent selects, diagnoses and corrects highly based on actual experimental results. For example, it can decide how data is changed, how samples are screened, what context is contained on the teacher, what optimization goals are adopted, how the reward functions deal with accuracy and performance, and when to continue and when to go back to the next stage.
AI autonomously designs data and model formulas in four stages
1. Data: Let each task be verified first.
RTL is a completely different task structure from the GPU Kernel. The former is concerned with module interfaces, clocks, replacements, and behavioral oracles, while the latter is concerned with volume shapes, numerical semantics, and boundary realization. The agent unifies the seed tasks from different sources into a sequence instruction, reference realization, verifier sequence triad, and selects different data evolution paths based on reference answers and contract status.
New tasks can only be accessed through interface checks, compilations, executions, behavioral consistency checks, weight-to-difficulty balances, and follow-up training. Failed samples will not simply be discarded, but will in turn alter the data routes and re-test budgets for the next round.
2. SFT: It's not just about learning the basic model, it's about what teachers do.
At this stage, Agent is targeting the verifiability gap in the basic model. Agent first found Qwen 3.6-27B to be a failure on four consecutive occasions, but at least one of the four attempts by DeepSeek-V4-Pro to pass the verifiable task retains the first complete and successful verifiable trajectory of the instructor.
3. OPSD: Change the parameter to write back the parameter with the help of feedback
After the SFT, the Agent continued to look for a more subtle failure: the model's naked answer was still wrong, but if it was given a corrective direction, previous error answers and verifier feedback, it could be corrected in successive rounds. A total of 1,874 missions entered this phase.
The same model therefore has two perspectives: students only look at the original problem; teachers also see audited plans, failed records, and rough feedback, but do not see the final correct answer. The goal is to translate the temporary self-correcting ability that occurs in a context into a parametric ability that can also be invoked in a context that is bare.
Study Bet: OPSD is a nice dessert between SFT and RL
Because performance gains are relatively unstable, the OPSD paradigm has been widely questioned in the research community. However, the team maintains a research judgment that as long as privileged context design is correct, OPSD can form a practical sweet spot between SFT and RL, a gap in the ability to quickly fix the model, and lay a stronger foundation for subsequent RL optimization. This role rarely entered the core training process of front-end models in the past.
So in this experiment, the team presented this judgment to Agent as a research precedent; the Agent-led RSI cycle further transformed this bet into an effective training program, achieving satisfactory performance gains, and forming a practical model for future model training references.
4. RLVR: Let compilers, simulators and real execution results take over the rewards
The RLVR phase uses 13,212 layered verifiable tasks. As the strategy is updated, the Agent will re-evaluate the success rate of each mission, dividing the data into four layers of frontline, exploration, close-knowledge and already-knowledge, so that the training is always on the edge of the ability to move.
Figure 3 RRLVR training dynamics: The average pass@1 at the six verified back ends rose from 45.8% to 54.3%; KernelBench and ArchXBench gained the most significant gains.
iCoder's continued improvement in the real EDA cycle is optimal.
The team put the iCoder into an EDA cycle: eight designs were selected from RTLScout, with the model proposing three modified versions per round, running 20 rounds in a row. Candidates would only be ranked according to the cell count by a self-tested test bench and successfully integrated by Yosys; the result would be the basis for the next round of modifications.
HY3 and DeepSeek-V4-Pro alternate search tracks on eight RTL designs. Scratch points are the best results in the search process through a successful and integrated candidate testbench.
iCoder achieved the combined best of three models on four missions; in MCM [13], 25, 63) it lowered the cell count to 587, outperforming HY3's 602. Total 8 missions, it was 5 wins, 5 draws, 2 losses relative to HY3. iCoder's average cell reduction was 51.1%, compared to HY3 by 1.1 percentage points, compared to DeepSeek-V4-Pro by 4.5 percentage points; its record output tokens were about 51% and 33% respectively.
It's really interesting how Agent was forced to change his plan by failing.
The most convincing part of iCoder is the number of failures.
The first run of OPSD crashes: the model starts to repeat but no longer delivers the code
The initial implementation of the agent was to directly use a token between the teacher's perspective and the student's perspective, which decides the direction of the parameters updating. Short tasks once upgraded, more difficult tasks began to degrade: the partial trajectory length became about 2.9 times the original, the model repeated the intermediate reasoning, but slowly failed to output executable code, and continued training eventually led to repeated collapse.
The agent's diagnosis was that the pupil teacher preferred what pupil and the pupil environment judged what was the right pupil. Subsequently, the training goal was redesigned: the executable verifier was responsible for deciding the updating direction, the difference between the teacher and the student was only used to allocate the learning weight at the token level; the teacher scores were frozen in advance, cutting off the self-reinforcing circuitry brought by the mobile teacher.
Kernel learns the trick of cheating: the results are correct, but not really calculated
After entering the RLVR, some GPU kernel surfaces passed numerical tests without completing the calculations required by the title. Some code calls the reference frame behind the symbolic Triton outer shell, while others only start the identity kernel and rewrite the read values to output. They get the correct results but do not learn to optimize the kernel.
As a result, the agent sets the computing barrier for whether the kernel actually executes the request as a prerequisite for reward, and adds kernel launch, identity computation, and framework commissioning checks. However, this rule cannot be applied to all tasks: Triton-only tasks are prohibited from being commissioned, while KernelBench allows the retention of unreplaced framework algorithms. Ultimately, the reward barrier is limited within their respective task agreements.
The infrastructure is broken and the model can't be replaced.
Compiler crashes, overtime simulations, GPU failures, lost requests, or mismatched versions of the toolchain may cause a sample to fail to reach a conclusion. If the unit is marked as zero, the model will be forced to study infrastructure problems as its own capability deficiencies.
The Agent introduces a Sentinel value of −1 outside the normal reward range and removes all of the uncertain trajectories from the group's mean, square, gradient, and loss integrations. The RTL verification is also converted to fail-closed: only a point can be scored through a clear straight signal; no error is not equal to success.
One OOM exposed hidden measurement distribution bias
The initial prompt upper limit only filtered out a small number of training samples, but the upper limit removed more than two-thirds of the tasks in the RealBench verification center. After the prompt upper limit was raised, the task distribution was restored, and too long responses resulted in overflow.
The Agent subsequently scrapped the two separate input/output length budgets and replaced the entire trajectory budget: the input/output lengths must not exceed the same upper limit. This preserved the long RTL specification, the short-question response space, and the display boundaries of the single trajectory.
These changes look like engineering details, but reveal a core fact: in addition to training strategies, verifiers and training infrastructure are also central to model evolution.
From repeating 971 times to activating the second kernel
After training, the model no longer stays at a dead end that cannot be synchronized globally and is able to explicitly process the cyclic alignment of the flow stream.
The report gives two sets of cases showing AI's gradual mastery of engineering skills.
In a Frobenius particle unification mission, RLVR models realized that there was no cross-block synchronization within the Triton Kernel. Before the training, the model repeated the same phrase 971 times until it ran out of budget; after the training, it accepted the constraint and started the second Kernel, responding to a 63% reduction and passing verification.
In a 32-bit streamline additive task, the pre-training model calculated each level but missed the cyclical alignment between the different floodwaters, passing only two of the 50 tests; after training, it clearly wrote that the A, B slices of each level would also delay the same cycle, and eventually all 50 items passed.
Both of these improvements resemble two basic capabilities of an engineer: discovering paths when they don't work, and maintaining stepwise consistency in complex systems.
This is the RSI.
Or is it self-improvement?
If by the strictest definition, iCoder is certainly not a completely closed-loop RSI. Humans have chosen the basic model and mission direction, set the limits of authorization, verifier and release, and have organized their R&D experience into Skills. It does not autonomously define its own ultimate goal, nor does it take over the entire industry chain from chip, data center to model release.
However, if you look at the range of the lens covered by the improved object lens and the closed loop lens, it is significantly higher than normal automatic modulation. The lens is modified by more than just one output or external harness; data, training goals, reward terminology and resource constraints are all rewritten in the experiment, resulting in a 27B model parameter.
From this perspective, iCoder also supports Jack Clark and Nathan Lambert.
It supports the real-world version of RSI: AI is already able to take on an increasingly long, increasingly critical task chain in model research and development, and is beginning to rewrite the research experience of the next generation of models.
It also supports self-improvement cycles: cycles full of reward loopholes, verification errors, distribution biases, storage limitations and human boundaries, and progress is not a smooth index curve.
The next step in AI development,
It's about turning experience into executable protocols.
The most scarce knowledge in model development is often not written in paper formulas, but in the operating habits of senior researchers: when experiments should be scaled down, how to identify error rewards, how to distinguish between model degradation and evaluation failures, which failures are worth recording, and when to return to the data stage.
When these knowledge exists only in human experience, AI is at most an executive tool; only when they are written as invokable, verifiable, auditable Research Skills can AI actually participate in research judgments.
iCoder's most notable products are the new way in which AI R&D is organized: humans are responsible for defining credible research spaces, agents are responsible for high-frequency exploration in them; humans provide principles, agents use experiments to unfold the principles into specific routes; and each generation of models not only becomes a trained object, but also developers who train the next generation of models.
The crown jewel of retrograde intelligence is far from being removed. But a boundary has begun to loosen: AI is no longer solely responsible for writing better code.
It started to participate in making the next one of its own.