OpenAI engineer Chris Leary (Intelligence Processors team, formerly the creator of the XLA compiler at Google) published an article on September 1, 2026, titled “Compilers 2.0: AI as stochastic optimizer,” about how AI writes kernels for OpenAI accelerators. The key example is the MLA kernel from the Jalapeño project, presented at HotChips: starting from code that is almost indistinguishable from numpy, AI produced an optimized kernel with the same semantics in 48 hours, often outperforming manually tuned versions by experts. Leary describes AI as a “stochastic optimizer,” and names automatic semantic equivalence checking, rather than line-by-line human code reading, as the guarantee of correctness.

image

What happened

In the article, Leary reveals the pipeline architecture: AI takes the place of the meta-program emitter in XLA, where it simultaneously performs lowering and code optimization, meaning it is embedded in the compiler as a full stage, not connected from the outside as an assistant. The demonstration case refers to OpenAI's presentation on the Jalapeño project at HotChips: starting from code that is almost indistinguishable from numpy, AI produced an optimized MLA kernel with the same semantics in 48 hours of search work, and such versions often turned out to be faster than kernels that experts tuned manually. In this scheme, the correctness of the result is not checked by a human: it is ensured by automatic semantic equivalence verification, relying on strict mathematical contracts described in the article.

Context

The conceptual framework of the approach is older than the name “Compilers 2.0”: stochastic superoptimization STOKE appeared as early as 2013, and program synthesis is a long-standing field where programs are not written by a human but searched for in a space of variants. What is new in the article is not the idea of search itself, but its scale and industrial embedding: LLM occupies layers of the pipeline where manual emitters and dataflow rule heuristics used to work. The story did not arise out of thin air — the mechanism already caused a resonance around OpenAI's presentation on the Jalapeño MLA kernel at HotChips and SemiAnalysis breakdowns, however, a detailed first-hand explanation was not available before Leary's article. Additional weight is given to the claim by the author's position: Leary himself created XLA at Google and is now part of OpenAI's Intelligence Processors team working on the accelerators he writes about.

Why this matters for the industry

For the industry, this is the first detailed first-hand explanation of the mechanism behind OpenAI's buzzed-about presentation on Jalapeño at HotChips. The main shift is that correctness guarantees are transferred from human understanding of the code to automatic equivalence checking: hardware performance begins to depend on how many “shots” the AI optimizer managed to make — in the example, 48 hours — and not only on the manual work of performance engineers. The scarce expertise of manual kernel tuning is partially transformed into a computational budget, and a new trade-off appears: compute is spent on optimization, not just on inference. Accordingly, the value of teams shifts — from the ability to write fast code to the ability to formulate and verify strict contracts. There is no external product yet: the described pipeline is an internal OpenAI tool, and no public API, repository, or methodology is mentioned in the sources. The real action for teams today is methodological: to conduct an inventory of their pipelines for operations with strict contracts and to strengthen automatic equivalence checking, for example, with differential tests and property-based contracts.

Why this matters for users

For the reader, the article provides a working framework instead of magic: AI here does not “understand” assembly, but makes reasonable moves in the space of programs — like an experienced optimizer, only on a massive scale. The “assembly” level simply shifts upward: just as when compiling C++ with -O3, no one reads the final machine code, in AI optimization of kernels, line-by-line human control is not assumed. Hence a practical guideline: if an operation is mathematical and a strict equivalence contract can be written for it, there is no need to read the AI-optimized code line by line — the contract needs to be checked, not the code. This framework also helps to soberly assess news about “AI writing fast code”: the main question is not the beauty of generation, but whether there is independent automatic verification of the result.

What is still unknown / limitations

The demonstration is still just one: it is about dataflow accelerator kernels with mathematical contracts, so the conclusion about a reproducible workflow for any tasks with strict contracts is an extrapolation beyond the data, and the transferability of the approach to other classes of tasks remains a hypothesis, not a result. There is no independent verification: the methodology, full benchmarks, and artifacts have not been published, no public API or repository is mentioned in the sources, and the SemiAnalysis breakdown remains a retelling without independent numbers. The resource side is also unclear: the result depends on the computational budget of the search, and how many “shots” will be required for other kernels or domains is unknown. Until OpenAI publishes the methodology or independent replications appear, the combination of “AI emitter plus automatic equivalence checking” can correctly be considered a claim by one authoritative author.

Sources

Author

Look at AI, editorial team