AI has already started to program itself
Westworld (2016), Bernard the android builder was actually an android all along (oops spoilers).
For a long time, a self-improving AI was just a recurring sci-fi theme (see above), however, it is already silently happening in the real world. Let’s dive into the why and the how.
Software ate the world, now, AI is eating software, creating fast growing demand for new high performance and cost-efficient infrastructure. However, only a handful of players are equipped with the talent needed to meet that demand.
AI usage is exploding, in both volume and variety with new model types, ways of serving them, and hardware to run them on. It’s driving demand for novel optimized systems (by system, we mean anything from a distributed memory system to low level GPU code).
While this frontier work was historically conducted by a small pool of experts, systems architects, compiler* specialists, AI researchers, performance engineers, today, leading players hoard those scarce talents at a price nobody else can match. It’s estimated that there is “probably one good GPU kernel engineer per 100,000 software developers”, and Nvidia spends around $800m per year on its GPU performance engineering workforce (cf. appendix).
It’s obvious that AI systems are now scaling faster than the people who optimize them. As a consequence, design and engineering result in inefficiency, with increasing cost combined with low-grade performance, e.g. DeepSeek-V3 is estimated to have left about 80% of its GPUs theoretical maximum compute on the table.
We need another way to tackle this problem: a new infrastructure layer, one where AI self-optimizes its infrastructure. Researchers call this, "Recursive Self-Improvement" (RSI).
After months deep in the research with the people who know it best, here's our view on what's coming up and what challenges remain to be solved.
Our conclusion is simple: the key bottleneck arrives during the evaluation of systems, not generation. Evaluation has to be quick enough to enable fast and cost-efficient iterative improvement, while in parallel confronting the system with real world conditions. Cracking that problem will unlock compounding value.
Given those requirements we built the conviction that the early winners we want to back will emerge from the systems engineerings layer.
First let's have a look at the four layers we identified in the AI stack where we can apply this self-improvement concept.
Strip any of these systems down and you find the same anatomy: propose candidates, evaluate them, learn from the scores and iterate on that loop**.** The core idea is that the probabilistic nature of the LLM output allows for broad exploratory search while the evaluation score grounds the result in “truth”. Once you integrate that process within a loop and repeat that at scale it can lead to powerful automated discoveries.
The search method varies: some research lineages use evolutionary loops descending from FunSearch, others use reinforcement learning, as in AlphaChip or the RL-trained kernel generators from Cognition. What every variant shares is a total dependency on its evaluator. A cheap and trustworthy optimize-and-verify cycle is the key to unlock gains at scale.