Self-Improving Compute Infrastructure is where AI agent swarms continuously improve the software that AI runs on. The category is being proven first on GPU kernels.
Key Takeaways
- Self-Improving Compute Infrastructure is where AI agent swarms continuously improve the software that AI runs on, making it faster, cheaper, and more reliable.
- The industry chases self-improvement at the model layer, years and billions of dollars away. Infrastructure is measurable now, so it arrives there first.
- We started with GPU kernels: the most unforgiving test we could find. Every layer after it must earn the same proof.
- Each improvement that removes a real bottleneck means the same GPUs do more work at lower cost.
“Self-improving” AI describes technology that becomes better at its own training or reasoning. Most of the industry pursues it at the model layer. That path is real, but it is also the long way: years of research and heavy capital before the technology ships. And it assumes intelligence is the bottleneck for AI progress. It isn’t. Infrastructure is. Every model, no matter how smart, runs on GPU code that helps determine whether it is fast, cheap, and reliable enough to deploy, and that code barely improves once the model ships.
At INT21, we apply self-improvement to that layer instead. Our agent swarms generate and evaluate candidate changes to compute infrastructure, and only candidates that pass defined checks are eligible for retention. Humans set the objectives and authorize what ships. We call this category Self-Improving Compute Infrastructure. This post explains what it is, why infrastructure came first, and what changes when improvement in the software layer beneath AI no longer depends solely on manual tuning.
What It Is and How It Works
Every AI workload runs on a deep stack of software most people never see: compilers, kernels, schedulers, memory management, and the code that translates a model’s math into work a GPU can execute. That stack helps determine how fast models run, how much compute they consume, and what it costs to serve them.
Today, much of that stack is hand-tuned by specialists with rare cross-layer expertise. Their work is iterative and verification-intensive, and the judgment involved is difficult to standardize and scale. New workloads, model architectures, GPU targets, and toolchains change what optimal looks like and require fresh measurement and validation.
Self-Improving Compute Infrastructure is where AI agent swarms continuously improve the software that AI runs on, making it faster, cheaper, and more reliable. It replaces that manual cycle with an autonomous one, with human-defined objectives, tests, and deployment authority. Swarms of specialized AI agents generate diverse candidate solutions, test them against real performance metrics on actual hardware, keep what works, discard what doesn’t, and build on the results. Humans review and ship the winners, and the loop runs again. The improvement work never waits on scarce specialist time.
Why We Started With the Hardest Problem
A self-improving loop is only as credible as the problem chosen to test it. A forgiving demonstration can hide weak search and incomplete validation, and produce results that look impressive without changing anything important. We wanted a proving ground with no room for ambiguity, so we chose GPU kernel development. By hardest, we mean the most unforgiving, measurable, and commercially consequential test we could find.
Here is why kernels qualify. A GPU kernel is the low-level code that performs one specific part of an AI workload directly on the chip, and PTX is NVIDIA’s assembly-like language that sits just above the hardware. At that level, everything is coupled: moving data more efficiently in one place puts pressure on memory and synchronization somewhere else, and a single wrong assumption produces code that is fast but invalid. The difficulty is well documented:
- It took the industry five years after the Transformer architecture was published to produce performant kernels for it, according to Stanford’s KernelBench team.
- A single production matrix multiplication kernel spans 3,000 to 5,000 lines of tightly coupled code, where one misplaced barrier silently corrupts results.
But that difficulty is exactly what makes kernels the right test, because here, you cannot fake a result. Every candidate the swarms produce has to prove it works before it even gets timed, and the timing happens on the real chip, run after run, until the numbers hold. Anything that only looks good on paper gets caught in hours. That is what makes the results credible.
It is also what makes them valuable. When a kernel gets faster where it actually counts, the same GPUs do more work, every unit of output costs less, and the next hardware purchase can wait.
And the system remembers. Plenty of tools can generate code. Ours keeps a record of everything it tried: what worked, what failed, and why. Every search starts smarter than the last one. That memory is what makes the infrastructure self-improving rather than just automated.
Kernels are the first proof, not the last. Every layer of the stack we move to next will be held to the same standard, and people hold it: humans set the goals, define the tests, and decide what ships.
Our Proof
INT21’s agent swarms are live with beta users today. The swarms operate across the modern GPU stack, generating optimized CUDA and PTX code for Hopper and Blackwell architectures. Humans set objectives, define acceptance criteria, and authorize what ships; the agent swarms run the search.
Three things about the results matter more than any single benchmark.
First, the search is continuous. Traditional infrastructure improves in release cycles. The agent swarms keep working between them. KDA (Kimi Linear Attention) only emerged from AI research in October 2025. Our first product, PTX Kernel Factory, already covers four NVIDIA chip generations with it, outperforming the best available implementation baseline by up to 59% in our published benchmarks. No release cycle, and no waiting for a specialist team to free up.
Second, the results compound. Each validated improvement becomes the new baseline, and the retained evidence shortens the next search. Our benchmarks focused on RMSNorm, a core building block running inside virtually every major AI model deployed today. The best available implementation took a leading team of GPU specialists months to develop for NVIDIA’s newest hardware. Our agent-generated code beat it in every comparable case. Unlike a hand-built kernel, that result is a baseline for the next search, not a finish line.
Third, the results survive contact with reality. Every change ships only after passing correctness verification and performance benchmarks on the specified target hardware and workload. Autonomy without verification is recklessness. Autonomy with verification is a new class of system.
What Changes
The consequences of this shift extend well past faster kernels.
Infrastructure teams change jobs. The critical skill stops being the ability to hand-write a fused attention kernel and becomes the ability to define objectives, set acceptance criteria, and govern autonomous systems. Engineers move up a level of abstraction, the same way they did when compilers ended hand-written assembly for most of the industry. The teams that adapt will govern a volume of verified experimentation no manual process can match.
The economics of compute change. Today, hardware is most valuable the day you buy it and depreciates from there. When validated improvements keep landing on the software layer, the same GPU can deliver more useful work over time: lower latency, more accepted output, headroom before the next purchase. For any company whose margins depend on inference costs, the difference compounds.
The performance race changes shape. Companies competing on AI have treated infrastructure performance as a fixed input, something you buy from a vendor or hire a rare specialist to improve. When infrastructure improves itself, the advantage goes to whoever runs the best verified improvement loop. This levels one playing field and creates another.
The path to broader self-improvement runs through here. GPU kernels are the proving ground. A method proven under this standard can move to other layers of the stack where feedback is just as fast, measurable, and governed. Each new domain earns its own evidence. That is how the category expands: one verified layer at a time.
The Self-Improving Infrastructure Era Has Begun
Self-Improving Compute Infrastructure is a category that’s emerging the way cloud and DevOps did. Categories emerge when the old way of working stops scaling and a structurally different model takes its place. That is where infrastructure is right now. The era of hand-tuned infrastructure is ending. Not because human engineers are inadequate, but because the search space is too large, the hardware cycles too fast, and the stakes too high for any manual process to keep up.
Every major shift in computing looked small at the beginning. Cloud started as a way to rent someone else’s servers before it rewrote how every company builds software. Self-improvement is following the same arc, and it is starting at the compute layer, where INT21’s agent swarms are already shipping verified optimizations to beta users. We are not predicting this future. We are operating in the first days of it.
The next decade of AI will be constrained by compute. The companies that win will be the ones whose infrastructure gets better every single day without being asked. The endpoint of this shift is a world where organizations stop asking whether to adopt self-improving infrastructure and start asking how fast they can get there.
INT21 builds Self-Improving Compute Infrastructure: autonomous agent swarms that continuously optimize the software layer running AI workloads. Request access to the private beta.