Article · AI translation
Agents are beginning to participate in low-level GPU kernel optimization
By Yunzhong, reporting from Aofeisi
QbitAI | WeChat public account QbitAI
By Yunzhong, reporting from Aofeisi
QbitAI | WeChat public account QbitAI
Recently, Infinigence AI achieved impressive results on SOL-ExecBench [1], a GPU kernel performance benchmark leaderboard launched by NVIDIA Research:
It successively topped all four tracks: L1 basic operators, L2 fused operators, Quant quantization operators, and FlashInfer-Bench inference operators.
What is SOL-ExecBench?
SOL-ExecBench is an operator optimization benchmark launched by NVIDIA Research on March 19, 2026. SOL stands for Speed of Light, referring here to the theoretical performance limit derived from hardware capabilities.
Unlike traditional evaluations that mainly compare speedups against a software baseline, SOL-ExecBench introduces a SOL Score referenced to the hardware performance ceiling and conducts actual tests on high-performance computing GPUs.
The leaderboard contains 235 operator optimization problems extracted from 124 real and frontier AI models, covering language, vision, speech, video, multimodal applications, and other fields. It is divided into four tracks:
L1 basic operators: Tests efficient implementations of basic computing modules.
L2 fused operators: Tests the fused execution and coordinated optimization of multiple computing steps to reduce memory accesses, data movement, and execution overhead.
Quant quantization operators: Covers low-precision computing technologies such as FP8 and NVFP4, which are closely tied to the performance and cost of large-model inference.
FlashInfer-Bench inference operators: Focuses on key computations in online large-model inference, including attention mechanisms and mixture-of-experts networks.
A distinguishing feature of SOL-ExecBench is that it extracts workloads directly from the computational graphs of real frontier models and focuses on the performance limits of these computations on next-generation GPUs.
Note: This is a highly competitive global leaderboard that is updated frequently and continuously. As teams keep submitting new optimization approaches, the rankings change accordingly.
As of October 26, 2026, Infinigence AI still ranked first globally by total score in both the L1 and Quant tracks and second globally in both the L2 and FlashInfer-Bench tracks. Across all 235 GPU operator optimization problems, it led all participating teams with 88 individual first-place finishes, more than twice the number of the runner-up.
In particular, in the L2 fused-operator track, which tests the ability to optimize complex computations, Infinigence AI took first place in 39 of 82 problems, nearly half.
This competition, bringing together leading AI infrastructure and agent development teams from around the world, is becoming an important arena for assessing next-generation AI computing optimization capabilities.
Turning AI productivity into realized value depends on a complete conversion chain: “investment → electricity/GPUs → tokens → productivity → value.”
Under the early impetus of scaling laws, investing more computing resources and maximizing GPU efficiency were important ways to achieve breakthroughs in model performance and increase token production.
As agents develop, however, tokens have become inputs to task execution rather than the final deliverable. Models can use longer reasoning, more rounds of attempts, and more verification to tackle previously intractable problems, but simply spending more tokens does not necessarily improve task outcomes.
If an agent keeps repeating similar attempts and cannot adjust course based on feedback from execution, even a large number of tokens may be spent going in circles.
The industry's focus is moving beyond GPU Maxxing toward Token Maxxing: improving the efficiency of converting “electricity” into “tokens,” while also ensuring that more tokens become actual model capability and task results, efficiently converting “tokens” into “productivity.”
SOL-ExecBench offers a concrete setting for testing this capability. It extracts computational workloads from real frontier models, covering basic operators, complex fusion, low-precision computation, and inference optimization, and requires submitted code to meet both correctness and performance requirements. Here, agents must generate code, compile and run it, analyze performance, and tune it repeatedly; their work is ultimately measured by execution results on real hardware.
The benchmark has attracted participants including global data and AI platform company Databricks; SF Tensor, a Y Combinator-backed AI infrastructure startup; the team behind the well-known AI coding tool Cursor; and technical teams active in automated operator optimization, such as Recursive, doubleAI, and Geometric.
According to figures published by SF Tensor on September 25, 2026, 583 teams had submitted more than 31,000 evaluations by then, with public submissions averaging about 1 every 8 minutes and continually reshaping the leaderboard.
Many competing teams use agents to automatically generate, test, and optimize low-level computing code. The competition thus tests both GPU kernel optimization and the ability to organize model capabilities into systems that can continually complete complex engineering tasks.
Amid this intense global competition, Infinigence AI successively took first place worldwide in all four tracks: L1, L2, Quant, and FlashInfer-Bench.
This reflects the team's technical experience in operator optimization and hardware-software coordination. It also tests its ability to use Agentic Infra to turn token investment into verified gains in computing performance, while exploring effective ways for AI to complete complex tasks autonomously.
From resource investment to token production and then to the delivery of real productivity and the realization of value, Infinigence AI's Agentic Infra has consistently sought to turn this chain from a one-way progression into a closed loop of improvement.
The team hopes agents will do more than consume tokens to complete tasks: it wants the productivity they create to feed back into the infrastructure itself, continually increasing token production and exploring a path toward RSI in AI infrastructure.
Operator optimization provides a concrete starting point for exploring this process: GPU kernel execution efficiency directly affects how fully hardware performance is used. Once efficient implementations found by agents are verified and applied to training and inference systems, they may further reduce computing costs, extending the benefits of operator optimization to token production.
The first challenge along this path is enabling agents to produce reliable optimization results consistently. Whether code runs correctly, where performance bottlenecks lie, and whether a change yields a real benefit must all be determined through actual execution and used to guide the next round of exploration.
To this end, Infinigence AI built an operator optimization agent around SOL-ExecBench, organizing code generation, execution-based validation, performance analysis, and the accumulation of experience into a continuous workflow.
The following three aspects show how Infinigence AI supports continuous agent improvement based on feedback from real hardware: isolated execution in containers, awareness of Skills and shared Memory, and optimization strategies for different tasks.
For its execution architecture, the system uses container isolation to separate the agent workspace, evaluation environment, and debugging environment. In a workspace with network access but no directly assigned GPU, the agent loads Skills, shared Memory, and optimization strategies through external mounts, writes code, and submits compute requests.
A host-side resource scheduler centrally manages GPUs, queues requests, and allocates resources as needed. Evaluation and debugging run respectively in an image aligned with the official evaluation environment and an image with integrated performance profiling tools. Network access is disabled in both types of execution container, and results are returned to the agent, forming an iterative loop of “code generation → evaluation and validation → performance analysis → strategy adjustment.”
This isolation design helps prevent agents from bypassing evaluation constraints during automated optimization. When an agent optimizes for a performance metric, its exploration may stray from implementing the operator and instead attempt to modify evaluation scripts, interfere with timing logic, access reference results, or exploit vulnerabilities in the environment to obtain scores that do not reflect real improvements in computational efficiency. Container isolation, access controls, and a controlled submission interface together define execution boundaries, allowing the agent to keep optimizing candidate operators while limiting its ability to interfere with the evaluation process itself.
To develop agent capabilities, the system draws on technical knowledge from the open-source community through modular Skills. It also uses a dedicated framework-awareness Skill to help agents understand and use the relevant framework, and shared Memory to continually retain and reuse optimization experience.
Knowledge-base and performance-debugging Skills: Drawn from the open-source community, these provide agents with GPU programming knowledge, performance analysis methods, and optimization tools.
An interaction Skill for the execution framework: Helps agents in the workspace understand their execution environment, available capabilities, and operating boundaries, and use a unified CLI entry point to initiate debugging, submit evaluations, check task status, and read results.
Shared Memory: Records strategies, applicable conditions, and practical lessons verified as effective during optimization, allowing different tasks to reuse the results of earlier exploration.
Together, these mechanisms enable agents to call on specialized capabilities, use the execution framework correctly, accumulate experience through continued iteration, and reduce repeated exploration.
For optimization strategy, the system organizes exploration in layers around workload characteristics, performance bottlenecks, and time budgets.
The system guides agents to choose suitable programming abstractions and DSLs (domain-specific languages) according to the time available for optimization. It balances development efficiency and performance potential among DSLs at different levels, including Triton, TileLang, and CuTe DSL, and progressively generates lower-level languages such as CUDA and PTX to keep exploring the available hardware performance.
Optimization strategies are further tailored to different computing scenarios:
Compute-intensive tasks: Focus on assessing Tensor Core utilization, tiling, and data reuse; explore asynchronous data movement and pipeline overlap; and balance register and shared-memory use against effective parallelism.
Memory-intensive tasks: Prioritize reducing redundant reads and writes and the materialization of intermediate results; optimize coalesced memory access, vectorized access, and cache reuse; and reduce the amount of data moved per unit of useful computation.
Multi-operator computation chains: Assess the benefits of operator fusion for memory accesses and launch overhead while tracking the resulting changes in register pressure, synchronization complexity, and parallelism. For suitable dependency chains, programmatic dependent launch (PDL) can be explored so that work in a subsequent kernel that does not depend on earlier results can begin early, with the necessary synchronization completed before dependent data is read. For tasks suited to persistent execution, Persistent Kernels can be explored, with CTAs remaining resident and processing multiple work units in a loop to spread thread-block scheduling and initialization overhead across them, while using pipeline parallelism to further improve execution efficiency.
Small-shape, low-latency tasks: Focus on controlling the number of thread blocks, inactive threads, boundary handling, and instruction and synchronization overhead, avoiding excessive tiling or complex pipelines that introduce fixed costs too large to be amortized by useful computation.
By combining the reuse of open capabilities, layered performance optimization, and feedback from real hardware, Infinigence AI hopes to turn GPU operator tuning, which depends heavily on expert experience, into an optimization process that agents can explore autonomously, learn from continuously, and carry out at scale.
The SOL-ExecBench results are not an isolated technical breakthrough, but a natural extension of Infinigence AI's long-term work on innovation in Agenetic Infra technology.
From connecting “M types of models” with “N types of chips” to its Agentic Infra strategy built around “diverse heterogeneous systems, hardware-software coordination, and autonomous AI” and a “front store, back factory, and one center” structure, Infinigence AI has consistently explored and applied technology across the core links of the AI productivity chain.
This exploration and its results on SOL-ExecBench are a milestone in the company's long-term technical roadmap for optimizing low-level computation. More importantly, they demonstrate the feasibility of the RSI approach of entrusting AI itself with the ability to make these efficiency improvements, taking an initial step toward an evolutionary loop from token production to the creation of productive capacity, which in turn improves infrastructure.
Next, Wuwen Xinqiong hopes to extend this exploration to the framework through which agents execute tasks. By modifying and validating task planning, tool use, memory management, and feedback mechanisms, agents can gradually improve how they solve problems as they complete tasks.
When the results of optimization can improve not only computational efficiency but also the mechanisms that produce optimization strategies, continued exploration has a chance to become sustained growth in capability.
Looking ahead to the evolution of RSI and AGI, Wuwen Xinqiong's technical team is confident but also keenly aware that a single technical breakthrough is still a long way from genuine system-level capability. Turning local optimizations into real productive capacity will likewise require further technical exploration and collaboration.
From enabling AI to use computing power more efficiently to involving AI in the optimization of computing systems themselves, Wuwen Xinqiong continues to advance infrastructure from supporting AI innovation toward evolving together with AI, exploring new ways to sustain the delivery of effective AI productivity.
Acknowledgments:
Humanize community (https://github.com/humanfia/humanize)
References:
[1] SOL-ExecBench: Speed-of-Light Benchmarking for Real-World GPU Kernels Against Hardware Limits. 2026. https://arxiv.org/abs/2603.19173
[2] KernelBench: Can LLMs Write Efficient GPU Kernels? ICML 2025. https://arxiv.org/abs/2502.10517
[3] MultiKernelBench: A Multi-Platform Benchmark for Kernel Generation. 2025. https://arxiv.org/abs/2507.17773
[4] CANN Bench: Benchmarking Agent Generated Kernels against Real NPU and Algorithmic Limits. 2026. https://arxiv.org/abs/2607.20518
*This article is republished by QbitAI with permission. The views expressed are solely those of the original author.