← /editions
#105

DAIly Agent #105: Agents Are Writing GPU Kernels Now

// MLC makes the case for agentic GPU programming and open-sources TIRx Harness, a compiler harness that puts TensorIR in the agent's feedback loop.

$ today_in_10_seconds

The MLC team, the group behind Apache TVM and MLC-LLM, is making a serious push to have agents write GPU code. They published a framing piece on agentic GPU programming for ML systems and an open compiler harness built to make it work. The message is that what holds back kernel-writing agents is the feedback loop around the model, more than the model's intelligence.

$ lead_story

Agentic GPU Programming for MLSys

Hand-tuned GPU kernels are some of the scarcest and most expensive engineering work in AI. Every new model architecture and hardware generation resets the clock on them. MLC argues that this work is unusually well suited to agents. It runs in tight write, compile, and benchmark loops, and each loop ends with an objective number instead of a judgment call. That makes kernels a proving ground for long-horizon, tool-heavy autonomy, where "it worked" is measured in microseconds instead of vibes. For founders, agents that can close even part of the kernel gap would shrink the advantage of having a CUDA wizard on staff.

// why_it_matters: Kernels are one of the rare domains where an agent gets a ground-truth reward on every iteration, so that's where autonomy should compound fastest.

read more →

$ also_worth_attention

  • TIRx Harness: An Open Compiler Harness for Agentic GPU Programming

    This is the infrastructure behind the thesis above. It's an open harness that connects an agent to MLC's TensorIR compiler stack, so the agent's kernel proposals get checked, compiled, and measured by the compiler instead of being eyeballed. The insight is that a structured IR gives an agent errors and transformations it can actually reason about, while raw CUDA tends to fail in ways that are hard to diagnose. When the compiler acts as the agent's most trustworthy tool, it doubles as a guardrail.

    link →

$ bigger_picture

The trend behind the headlines

SWE-bench taught the industry that the harness matters as much as the model, and the same lesson is now reaching performance engineering. The domains that agents take over first are the ones with cheap, reliable verifiers: tests for code, proofs for math, and now profilers for kernels. Open-sourcing the harness turns it into shared infrastructure, which means labs and startups will compete on the same loop. The likely result is better kernel agents and faster hardware bring-up. Expect "agent-ready" to become a design requirement for compilers, not an afterthought.

$ tool_of_the_day

Apache TVM

TVM is the open-source ML compiler that TensorIR, and so TIRx, comes from. If you want to understand what a kernel agent is actually manipulating, spend an afternoon with TVM's scheduling and IR layers. They're the action space.

explore Apache TVM →

$ subscribe --free

Get the next edition in your inbox

// DAIly Agent covers agentic AI three times a week

// free, no spam, exit anytime