Contour: Extensible Mapping Surfaces for Agentic Accelerator Kernel Generation
Listen
Radio episode about this paper
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.
University of Michigan · The University of Texas at Austin
cs.AR
Submitted: 2026-08-01
Updated: 2026-11-18
Code: https://github.com/zhang677/AccelOpt
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 91/100
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…
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
Summary
Emerging accelerators often lack mature compiler backends, motivating neural agents that generate and repair kernels from architectural documentation and simulator feedback This approach repeatedly reconstructs workload-invariant machine semantics—including instruction behavior, legality constraints, synchronization rules, and memory protocols—for every workload We argue that these semantics should be compiled once into a persistent symbolic artifact, while neural reasoning should focus on workload-dependent mapping decisions ZOMBOSS is presented as a compiler-mediated agentic framework for kernel generation that places neural search within a verified compiler boundary Across 20 Gemmini and 36 PLENA workload instances, ZOMBOSS returns a correct verified kernel on all 56 instances Relative to the compiler default, ZOMBOSS achieves geometric-mean speedups of 3. p. 0 edu
Abstract—Emerging accelerators often lack mature compiler
backends, motivating neural agents that generate and repair
kernels from architectural documentation and simulator feedback. This approach repeatedly reconstructs workload-invariant
machine semantics—including instruction behavior, legality constraints, synchronization rules, and memory protocols—for every
workload. ZOMBOSS compiles machine semantics
and legality constraints into a reusable mapping interface, then
uses a neural agent to optimize workload-dependent decisions
within the validated mapping space. Across 20 Gemmini and
36 PLENA workload instances, ZOMBOSS returns a correct
verified kernel on all 56 instances. ZOMBOSS compiles machine semantics
and legality constraints into a reusable mapping interface, then
uses a neural agent to optimize workload-dependent decisions
within the validated mapping space. Across 20 Gemmini and
36 PLENA workload instances, ZOMBOSS returns a correct
verified kernel on all 56 instances. ZOMBOSS compiles machine semantics
and legality constraints into a reusable mapping interface, then
uses a neural agent to optimize workload-dependent decisions
within the validated mapping space. Across 20 Gemmini and
36 PLENA workload instances, ZOMBOSS returns a correct
verified kernel on all 56 instances. ZOMBOSS compiles machine semantics
and legality constraints into a reusable mapping interface, then
uses a neural agent to optimize workload-dependent decisions
within the validated mapping space. Across 20 Gemmini and
36 PLENA workload instances, ZOMBOSS returns a correct
verified kernel on all 56 instances.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Pruning redundant reasoning tokens
The paper introduces ZOMBOSS, a compiler-mediated agentic framework that separates reusable machine realization from per-workload mapping search for emerging accelerators The core idea is to compile machine semantics and legality constraints into a reusable mapping interface, then use a neural agent to optimize workload-dependent decisions within the validated mapping space This design separates the reusable machine realization from the policies that explore workload-dependent mappings The framework connects a search agent to a reusable compiler through a workload-specific mapping interface
How the training signal is built
ZOMBOSS constructs a workload-specific mapping surface using a TAIDL hardware description and a shared mapping layer This surface lists the decisions that search may change, such as tiling, operand residency, or execution overlap The resolver uses the hardware description and these shared policies to derive the available knob values and check their joint legality Mapping completion produces a resolved plan, which includes eight semantic sections for the computation graph, matrix and vector decomposition, placement, memory, precision, pipeline, and loops
Where the gains come from
The performance improvements stem from separating search policies from compiler-owned mapping completion and kernel realization The interface supports competitive conventional and neural search policies, allowing them to share the same mapping surface, symbolic completion, code generation, and candidate validation path Conventional search policies like hill climbing explore neighboring assignments over the published mapping decisions The interface enables both conventional and neural search policies to operate within different agentic harnesses without reconstructing machine semantics for each workload
The framework's success is demonstrated through empirical results across various workloads Across 20 Gemmini and 36 PLENA workload instances, ZOMBOSS returns a correct verified kernel on all 56 instances The results show that partial mapping specification and symbolic completion turn kernel generation into verified designspace exploration
The comparison against KernelCraft shows that ZOMBOSS improves CANDIDATE-0 on 54 instances and matches it on two, with geometric-mean speedups of 3.34× on Gemmini and 1.10× on PLENA Additional naive-agent comparisons reduce tokens per verified kernel by 26. p. 1 5% on the full 36-instance PLENA suite to 100%. On the search suites, the naive-agent comparisons reduce
tokens per verified kernel by 26. ZOMBOSS compiles machine semantics
and legality constraints into a reusable mapping interface, then
uses a neural agent to optimize workload-dependent decisions
within the validated mapping space. Across 20 Gemmini and
36 PLENA workload instances, ZOMBOSS returns a correct
verified kernel on all 56 instances. They return verified results on all evaluated
instances, so this comparison measures performance and cost
beyond default coverage. Within the AccelOpt harness, ZOMBOSS finds kernels that
are 17. This observation motivates our compiler-mediated agentic
design: a reusable compiler captures target-invariant codeAlgorithm 1 Mapping search with explicit preference completion
1 Surface 2 Hard checks 3 Preferences
4 Region completion 5 Compile/evaluate 6 Selection
Require: workload W, target semantics T, search budget
1: 1 S ← DERIVESURFACE(W, T)
2: p0 ← RESOLVE(∅, W, T)
3: 5 b ← COMPILEANDEVALUATE(p0, W)
4: Require b to pass verification; F ← {b}
5: while proposal and evaluation budgets permit another batch do
6: I ← PROPOSE(W, S, F)
7: if target is Gemmini then
8: p ← catalog plan selected by I
9: P ← {p} if p is fresh, else ∅
10: else
11: Check region I and completion of its hard subset
12: 4 Sample I; complete intents with RESOLVE
13: Deduplicate plans; expand a short neighborhood
14: Filter static-cost outliers; select two diverse plans
15: P ← selected plans, or ∅ on rejection
16: end if
17: for all p ∈ P do
18: 5 r ← COMPILEANDEVALUATE(p, W)
19: if 6 r. verified and r is faster than b then
20: b ← r
21: end if
22: end for
23: F ← mapping outcomes, incumbent, remaining budget
24: end while
25: return b
26: function RESOLVE(I, W, T)
27: 2 A ← hard assignments in I
28: p ← complete A with defaults; check joint constraints
29: Reject if completion fails
30: for all preferences (k, v) in 3 fixed order do
31: q ← complete and check A ∪ {k = v}
32: if q is legal then
33: A ← A ∪ {k = v}; p ← q
34: else
35: Record the relaxation and its reason
36: end if
37: end for
38: Construct plan sections and schedule DAG; reject cycles
39: return plan with realized decisions and resolution records
40: end function
generation knowledge, while the agent focuses on workloadspecific mapping decisions.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
The paper concludes that partial mapping specification, symbolic completion, and structured feedback are effective interfaces for accelerator kernel exploration This design allows search policies and agentic harnesses to evolve without reconstructing machine semantics for each workload The interface can expand as search identifies additional optimization opportunities by exposing its decision domain and adding legality rules to the resolver A future direction involves recursive improvement across data, models, and harnesses inspired by MetaRSI
The results establish a shared mapping interface that lets both conventional and neural search policies use reusable compiler infrastructure The interface can expand as search identifies additional optimization opportunities by exposing its decision domain, adding legality rules to the resolver, and supporting its lowering in the backend This abstraction lets search operate on selected mapping choices while reusing completion and code generation across proposals
The paper presents ZOMBOSS as a compiler-mediated framework that separates reusable machine realization from per-workload mapping search for emerging accelerators This separation allows conventional and neural policies to share reusable compiler infrastructure The results support selecting among policies that share the same mapping interface, resolver, and evaluator
The framework's results show that ZOMBOSS improves CANDIDATE-0 on 54 instances and matches it on two, with geometric-mean speedups of 3.34× on Gemmini and 1.10× on PLENA The results support selecting among policies that share the same mapping interface, resolver, and evaluator The interface can expand as search identifies additional optimization opportunities by exposing its decision domain and adding legality rules to the resolver
The paper establishes partial mapping specification, symbolic completion, and structured feedback as an effective interface for accelerator kernel exploration By separating search from mapping completion and native code generation, ZOMBOSS lets conventional and neural policies share reusable machine realization The interface can expand as search identifies additional optimization opportunities by exposing its decision domain and adding legality rules to the resolver The results support selecting among policies that share the same mapping interface, resolver, and evaluator
The framework's results show that ZOMBOSS improves CANDIDATE-0 on 54 instances and matches it on two, with geometric-mean speedups of 3.34× on Gemmini and 1.10× on PLENA The results support selecting among policies that share the same mapping interface, resolver, and evaluator The interface can expand as search identifies additional optimization opportunities by exposing its decision domain and adding legality rules to the resolver The results support selecting among policies that share the same mapping interface, resolver, and evaluator
ZOMBOSS makes partial mapping decisions an explicit search interface: an agent can express optimization choices without constructing a complete mapping or its machine-level implementation The surface identifies the choices available for a workload, while the resolver completes dependent decisions and checks their joint legality Feedback reports the realized mapping and measured performance, connecting each proposal to the implementation actually evaluated The complete-specification ablation supports this design by allowing partial intents to improve mapping quality while reducing inference cost
The results support selecting among policies that share the same mapping interface, resolver, and evaluator The interface can expand as search identifies additional optimization opportunities by exposing its decision domain and adding legality rules to the resolver The results support selecting among policies that share the same mapping interface, resolver, and evaluator The interface can expand as search identifies additional optimization opportunities by exposing its decision domain and adding legality rules to the resolver
The results support selecting among policies that share the same mapping interface, resolver, and evaluator The interface can expand as search identifies additional optimization opportunities by exposing its decision domain and adding legality rules to the resolver
The results support selecting among policies that share the same mapping interface, resolver, and evaluator The interface can expand as search identifies additional optimization opportunities by exposing its decision domain and adding legality rules to the resolver
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
- Compiler-mediated agentic framework for kernel generation
ZOMBOSS places neural search within a verified compiler boundary by compiling machine semantics into a persistent symbolic artifact, allowing neural reasoning to focus only on workload-dependent mapping decisions.
- Workload-conditioned mapping surface interface
The system publishes typed decisions derived from the hardware specification and the workload,
supporting partial intents with required, preferred, and automatic choices that are completed into legal plans by a symbolic resolver.
- Separation of search policy from compiler realization
ZOMBOSS separates the search policy from compiler-owned mapping completion and native code generation, allowing conventional and neural search policies to operate within the same agentic harness.
- Enhanced performance through symbolic completion
The resolver completes partial intents into legal plans, ensuring that each invocation spends inference and validation feedback not only on workload-specific optimization, but also on instruction legality, configuration-state transitions, data-movement protocols, and synchronization.
- Improved token efficiency in kernel generation
ZOMBOSS achieves reductions in tokens per verified kernel compared to KernelCraft by utilizing symbolic completion and compiler-owned realization to let the harness focus its proposals on mapping decisions.
Abstract
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.
Sources
- DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence
- Autocomp: A Powerful and Portable Code Optimizer for Tensor Accelerators
- In-Datacenter Performance Analysis of a Tensor Processing Unit
- KForge: Program Synthesis for Diverse AI Hardware Accelerators
- MetaRSI / RSI2: A Meta-Recursive Self-Improving System for Recursive Self-Improving Systems Themselves
- TileLang: A Composable Tiled Programming Model for AI Systems
- AccelOpt: A Self-Improving LLM Agentic System for AI Accelerator Kernel Optimization
- CudaForge: An Agent Framework with Hardware Feedback for CUDA Kernel Optimization
Related papers
- Embedded Arena: Iterative Optimization via Hardware Feedback
- WitCert: Sound Runtime Risk Observability and Gating for KV-Cache Quantization
- SparsePixels: Efficient Convolution for Sparse Data on FPGAs
- Golden Ruler: A Numeric Format Catalog with Bit-Exact Conformance Vectors for FP8, BF16, MXFP4, and Microscaling Formats
- AMMA: A Multi-Chiplet Memory-Centric Architecture for Low-Latency 1M Context Attention Serving
- RFChipAgent: Multi-Agentic AI Flow for Analog/RF Chip Design