SemiAnalysis Analyst: OpenAI Engineers Are Unclear About Each Line of Their Own Kernel Code While Scrolling Through It
SemiAnalysis analyst Jordan Nanos stated that OpenAI engineers are not clear about what each line of their own kernel code does while scrolling through it, but this does not affect the results, as the AI can write, test, and run high-performance kernels.
He referred to this code as "not garbage because it runs," while also saying it is "essentially AI-generated assembly thrown into Gluon." Gluon is the low-level kernel language built by OpenAI on top of Triton, following a single program multiple data model and exposing hardware-near abstractions.
Nanos mentioned that engineers looking at the code understand hardware and system concepts but cannot clearly explain what the segment prepared for DeepSeek's MLA kernel is actually doing. They can point to each line, but the response is negative. Testing and correctness are handled by models and verification scripts.
SemiAnalysis's written materials state that OpenAI wrote the Jalapeño kernel using an internally scaled-up Codex, with some manually tuned kernels extending to about three thousand lines, accompanied by correctness checks and custom sanitizers. Initially, humans were involved, but later it shifted to more automation. The internal inference engine is named Teacup. Before using InferenceX for benchmarking DeepSeek, the company did not even have its own MLA kernel implementation.
Gluon creates layouts as first-class abstractions, mapping hardware resources to tensor elements and providing provable layout transformations. For NVIDIA GPUs, it can directly access instructions like tensor memory acceleration, matrix multiply-add, and memory barriers. Kernel optimization is described as a verifiable reinforcement learning loop: assigning tasks, conducting tests, and allowing models to iterate data movement and computation units.
In market mechanisms, the buyers are those looking to squeeze more tokens per watt from inference loads, while the sellers are the human-readable kernel crafts. The events are driven by self-developed chips and open-source model benchmarks, with funding shifting from manually tuned kernels in the CUDA ecosystem to "model-written kernels and testing closures"; benefiting are laboratories that can hand over hardware semantics to models in a closed loop, while those relying on a moat built on a few kernel engineers writing assembly face pressure.
Source: Public Information
ABAB AI Insight
OpenAI digs another layer down from Triton to obtain Gluon, not to make it more readable for humans, but to allow models to touch registers and data movement paths. The fact that Codex can write runnable MLA without human kernel group intervention indicates that verifiable loops are now more valuable than "understanding what each line does." Engineers still need to understand chips and systems, but they no longer need to be the final authors of assembly.
The capital path is transforming kernel development from human labor hours to reinforcement learning hours. Assign tasks, sanitizers, and performance tests to the model, allowing it to iterate on Jalapeño or GPUs. Money flows from high-salary kernel programming to self-developed compilation stacks and internal proxy computing power. Whoever first writes "measurable correctness" as a reward can treat the three thousand lines of kernel as a producible output.
The benchmark is the 37th move of AlphaGo after stepping out of human game records, and the automatic vectorization of compilers replacing handwritten SIMD. The industry is in a transitional phase from "humans writing CUDA" to "humans setting constraints, models writing kernels." DeepSeek's self-developed kernel stack forcing OpenAI to supplement MLA indicates that the kernel pressure from open-source models has already reverse-trained the toolchain of closed-source laboratories.
Structurally, this belongs to technological substitution. The mechanism is: when data movement and computation units can be locked by test functions, understanding each line is no longer a necessary condition for performance. Readability gives way to verifiability, and the software moat shifts from "who can write" to "who can make the model loop on this silicon."
ABAB News · Cognitive Laws
Code that can be tested does not need to be understood by humans.
With a reward function, assembly can be generated.
Those who understand hardware may no longer be the final authors.