Contour: Extensible Mapping Surfaces for Agentic Accelerator Kernel Generation

summary

The gist

Emerging accelerators often lack mature compiler backends, motivating neural agents that generate and repair kernels from architectural documentation and simulator feedback This approach repeatedly…

In short

ZOMBOSS is a compiler-mediated agentic framework designed to generate accelerator kernels by separating reusable machine realization from workload-specific mapping search. It compiles machine semantics once into a symbolic artifact, allowing neural agents to focus only on workload-dependent optimization decisions within a verified compiler boundary. This approach achieves significant speedups over default compilers.

Key concepts

Compiler-Mediated Agentic Framework
ZOMBOSS acts as an intermediary between a neural search agent and the compiler. It separates the reusable machine implementation (the 'how' of execution) from the workload-specific mapping decisions (the 'what' and 'where'). This allows neural reasoning to operate within a verified, safe boundary provided by the compiler.
Mapping Surface
This is a structured surface created using hardware descriptions that lists all possible workload-dependent decisions, such as tiling or operand placement. It defines the decision space for the agent's search. The resolver then uses this surface and legality rules to check if proposed changes are valid for a specific workload.
Symbolic Completion
This refers to using symbolic representations to guide kernel generation. Instead of generating code from scratch, the system uses these symbols to complete partial mapping specifications. This allows conventional or neural search policies to explore optimization choices without needing full, manual machine-level implementation for every proposal.
Separation of Concerns
The framework explicitly separates reusable machine realization (the compiler's job) from workload-dependent mapping search (the agent's job). This separation enables conventional and neural search policies to share the same underlying infrastructure, promoting reusability and allowing different agents to explore the same decision space.

Terminology used across episodes

This episode discusses

The paper

Contour: Extensible Mapping Surfaces for Agentic Accelerator Kernel Generation · Read on arXiv

University of Michigan · The University of Texas at Austin

Emerging accelerators rarely ship with mature compiler backends, so recent work asks LLM agents to write native kernels directly from ISA documentation and simulator feedback. On two such accelerators, this direct workflow returns a correct kernel on only 17 of 38 workload instances, and most of its inference budget is spent re-deriving machine semantics and repairing illegal code rather than optimizing the workload. We present Contour, which consists of two parts. Contour-Explore replaces native-code generation with search over a mapping surface: a typed set of scheduling knobs and their legal domains, generated automatically from the accelerator's ISA description and the workload graph. A compiler-owned resolver completes partial assignments into legal plans and emits native code, so every evaluated candidate is verified against the compiler's default, and any policy can drive the search, including hill climbing, evolutionary search, and LLM agents. Compared with KernelCraft, a state-of-the-art agentic kernel generator, an LLM agent through Contour-Explore returns a verified kernel on every Gemmini and PLENA instance, produces 2.86x and 1.13x faster kernels on the instances where both succeed, and uses 26.3% and 83.4% fewer tokens per verified kernel. Contour-Ext extends the surface when search stalls: an LLM agent implements a new knob and its lowering in the compiler backend, and Contour-Ext accepts the extension only if the default path is byte-identical, every new value is numerically correct and changes the program, and the enlarged surface yields a measured gain. On VTA, Contour-Ext extends the AutoTVM surface of TVM, and AutoTVM's XGBTuner then finds 4.14x faster kernels; on PLENA, the extended surface makes the kernels found by hill climbing 1.20x faster.

Transcript

Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.

Tom: We're looking at the paper: "Contour: Extensible Mapping Surfaces for Agentic Accelerator Kernel Generation".

Paper summary: Tom: So we're looking at this paper called Contour: Extensible Mapping Surfaces for Agentic Accelerator Kernel Generation. It sounds like they're tackling a problem where new accelerators don't have these mature compilers anymore, so they want neural agents to generate kernels from documentation and simulator feedback.

Jane: Right. So the core idea here is that instead of letting the agent rebuild all those machine rules every single time for every different workload, they want to compile those machine semantics once into a permanent symbol artifact.

Lu: Exactly. The authors argue that the reusable machine semantics—things like instruction behavior, legality constraints, and memory protocols—should be compiled just once. The neural reasoning part should then only focus on the specific workload decisions.

Meng: But that sounds like a lot of upfront work for the compiler side. How does it actually manage those rules before the agent even gets involved?

Tom: ZOMBOSS is their framework, and it's a compiler-mediated agentic system designed to keep neural search inside a verified compiler boundary. It compiles all those machine semantics and legality constraints into a reusable mapping interface first.

Jane: So the neural agent doesn't have to worry about the low-level machine rules; it just searches within that validated space for workload-dependent decisions like tiling or operand residency.

Lalam: I see how that works, because they construct a workload-specific mapping surface using a hardware description and a shared layer. This surface lists all the choices the agent can change, like tiling or execution overlap.

Tom: And the resolver takes that hardware description and those shared policies to figure out what values are available for those knobs and makes sure everything is legal before it produces a final plan. They end up with this resolved plan that has eight semantic sections for things like loops and memory placement.

Jane: It seems they are using the structure of the hardware description, like the TAIDL language, to define these semantics so they can be used across different workloads. This is what makes it extensible and reusable.

Lu: And this separation is key because it allows conventional search policies, like hill climbing that explore neighboring assignments over those published mapping decisions, to operate alongside neural search policies without having to reconstruct the machine semantics for every single workload.

Paper summary: Meng: But if you separate the policies from the realization, how do you make sure they actually connect up correctly when they're trying to generate a kernel? That connection seems like a huge hurdle at scale.

Tom: The interface supports both conventional and neural search policies sharing that same mapping surface and symbolic completion path. This means different agents can use the same compiler infrastructure for different types of optimization goals.

Jane: And the results they showed are pretty strong; across twenty Gemmini instances and thirty-six PLENA instances, ZOMBOSS returned a correct verified kernel on all fifty-six total workloads tested.

Lu: The performance gains are what really stand out. Relative to the compiler default settings, ZOMBOSS achieved geometric mean speedups of three point three four times on Gemmini and one point one zero times on PLENA.

Meng: three point three four times on Gemmini is significant if we're talking about actual deployment scenarios where latency matters, but what about PLENA?

Tom: For PLENA, it was a one point one zero speedup. Still a decent boost compared to the baseline, though the scale of the workload itself is different there.

Jane: The paper also noted that this approach turns kernel generation into verified design space exploration by using partial mapping specification and symbolic completion. This suggests that you don't need to map everything perfectly upfront to get a usable result.

Lu: That’s because the agent can express optimization choices without building the entire complete mapping or its machine-level implementation, and then the resolver completes those dependent decisions while checking for joint legality.

Meng: So, if I were deploying this, what would be my concern? Would this framework handle unexpected hardware quirks that aren't in the original documentation?

Tom: That’s a limitation they point out. The interface can expand as search identifies more optimization opportunities by adding legality rules to the resolver and exposing its decision domain. It also relies on structured feedback to report the realized mapping and measured performance back to each proposal, which connects it directly to the evaluation.

Jane: So, in simple terms, Contour is about building a shared interface for machine knowledge so that neural agents can search for workload-specific optimizations without having to re-learn the fundamental rules every time.

Paper summary: Lu: It’s about separating the reusable machine realization from the policies that explore workload-dependent mappings. This abstraction allows both conventional and neural search policies to use the same compiler infrastructure.

Meng: If we look at what this means for deployment, it suggests a path where you can train an agent to find a good mapping quickly, and then have the verified compiler handle the heavy lifting of ensuring it doesn't crash or violate basic rules at runtime.

Tom: That’s right. It shows that partial mapping specification and symbolic completion are effective interfaces for exploring accelerator kernels because they let the search evolve without rebuilding those machine semantics for every single workload.

Jane: It moves the focus from building a full kernel from scratch to intelligently navigating a verified design space, which is what this paper calls ZOMBOSS.

Lu: The future direction involves recursive improvement across data and models, inspired by something called MetaRSI. They are looking at how this shared mapping interface can grow as the search finds new optimization opportunities by exposing more of its decision domain.

Meng: It’s interesting that they're focused on the mapping decisions—tiling, placement—rather than trying to fix the fundamental lack of a mature compiler backend itself in this specific framework. That keeps the scope manageable for now.

Tom: Right, so they’ve proven that by focusing on these interface points and leveraging a verified compiler boundary, you can get real speedups on existing hardware architectures like Gemmini and PLENA.

Jane: So, to wrap up on Contour: Extensible Mapping Surfaces for Agentic Accelerator Kernel Generation, it's about creating a system where machine knowledge is reusable, but the workload-specific search is flexible. This framework shows that you can use neural reasoning to find better mappings within a solid structure provided by the compiler.

Lu: It establishes that partial mapping specification and symbolic completion are effective interfaces for accelerator kernel exploration because they allow search policies and agentic harnesses to evolve without reconstructing machine semantics for each workload.

Meng: It's about getting more out of the compiler infrastructure we already have, instead of trying to build a whole new backend from scratch every time we get a new chip.

Tom: Exactly. The results support selecting among policies that share the same mapping interface, resolver, and evaluator. That shared interface is what makes it scalable across different workloads on these emerging accelerators.

Conclusion: Tom: So we’ve been talking about ZOMBOSS, which is this framework where they separate the machine rules from what the AI agent actually decides for a specific workload.

Jane: Yeah, and now we’re looking at how they wrap all that up in a paper called Contour: Extensible Mapping Surfaces for Agentic Accelerator Kernel Generation.

Lu: The authors are showing how you can compile those core machine semantics—like instruction behavior and memory rules—once into a persistent artifact.

Meng: So the agent isn't starting from scratch every time it wants to write a kernel; it’s just searching within this pre-verified space.

Tom: Exactly. The main thing here is that they make the search policy and the compiler infrastructure share that same mapping surface interface, which lets both neural and conventional search methods work together.

Jane: It’s about making those fundamental machine rules reusable, so you don't have to rebuild them for every single new chip or workload you throw at it.

Lu: They show that this partial mapping specification and symbolic completion lets the agent explore the design space without needing a fully complete, low-level implementation of every single choice.

Tom: And they got real numbers on the performance; they saw speedups, like three point three four times on one workload and over one time on another.

Jane: That’s a big jump from what you might get from just guessing or traditional compiler defaults, which is why these results matter for actual hardware design.

Lu: The implication is that this abstraction allows the search to evolve as it finds new optimizations, by exposing its decision domain and adding legality rules to the resolver.

Meng: It means we can train an agent to find good mappings faster, and then let the verified compiler do the heavy lifting of making sure those mappings are actually legal when they run on real traffic.

Tom: That’s right. This paper is showing how you can move from just generating code to intelligently navigating a verified design space for emerging accelerators.

Jane: And that sets up a really interesting discussion about how we can make these agents more robust and scalable in the future.

More episodes

← Home