acceptodds
Under review as a conference paper at ICLR 2027

SABER: Semantic Abstraction Boundaries for Efficient Refinement of Sparse GPU Kernels

Abstract

GPU coding agents increasingly optimize kernels through search and execution feedback, but the programming interface presented to the agent remains underexplored. We present SABER, an agent-facing interface for sparse GPU kernels that exposes sparse strategy and coarse hardware intent while delegating concrete GPU realization to a compiler backend. Across 26 workloads spanning six sparse operator groups, SABER records no hard failures versus 11.1% for Direct CUDA, while 92.3% versus 47.4% of trajectories are within 10% of their final search best by proposal 2. Because the reachable implementation spaces differ, we treat this as a full-system comparison. We therefore construct a matched study on ten CSR SpMM/SDDMM workloads in which SABER and a lower-level schedule expose the same 32 executable backend implementations per workload. Across GPT-5.6 Sol, GPT-6 Astra, and MiniMax-M3, SABER reaches shared-reference thresholds earlier and selects implementations closer to the shared finite reference. Configured-backend and private-realization experiments further show that final kernel performance depends on backend quality. These results support treating the agent–compiler programming interface as a first-class systems design choice.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Sparse GPU Kernels, GPU Kernel Optimization, Coding Agents, Compiler-Agent Co-Design, LLM-Based Code Generation

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_zMxDOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper investigates whether coding agents search more effectively when they choose high-level sparse strategies and leave implementation details to a compiler backend. The authors propose SABER, an agent-facing interface that exposes sparse strategy and coarse hardware intent while delegating low-level realization to operator-specific compiler backends. They compare SABER with Direct CUDA generation on 26 workloads from 6 sparse operator groups, primarily on an RTX 3090. They also run a controlled study in which SABER and a lower-level matched schedule give agents access to the same 32 implementations per workload. SABER produces fewer failures and reaches its best candidates earlier in the full-system comparison. The matched study also finds that agents need fewer responses with SABER. However, SABER does not consistently produce faster final kernels than Direct CUDA, and its performance depends on the available backend implementations.

Critical strengths

S1. The matched study is well designed. Both interfaces search the same fixed set of backend implementations. This makes the comparison more convincing, since a better result cannot simply come from access to a better kernel. I also like that the authors measure search progress against the fastest correct implementation in this set, rather than only against each trajectory's own best (L356-359). SABER needs fewer responses to reach its best candidate across all three coding models, with paired-bootstrap results supporting the difference.

S2. I appreciate that the authors are upfront about the performance limitations. SABER only matches Direct CUDA overall and performs considerably worse on SpGEMM. They also acknowledge that the SDDMM gap against SparseTIR cannot be explained by abstraction level alone. These qualifications make the paper's claims more credible. The paper is clear that the matched study is a controlled interface experiment rather than a production-scale benchmark.

Critical weaknesses

Major

W1. The headline search metrics may largely reflect small action domains. The 26-workload search comparison is difficult to interpret without the SABER action-domain sizes. SABER can stop once it has exhausted its finite action domain (L305-307), while Direct CUDA always makes 8 proposals. Across the 78 trajectories, SABER makes 189 proposals and Direct CUDA makes 624. Figure 3(c) also shows that every SABER trajectory for SDDMM and SpGEMM finds its best implementation on the first proposal. This makes me wonder how many of these workloads offer very few choices to begin with. The headline metrics, 92.3 vs. 47.4% of trajectories within 10% of final best by proposal 2 and mean proposals-to-best of 1.628 vs. 3.986, are measured against each trajectory's own final best (L312-314). A search over only 1 or 2 candidates scores well on these metrics by construction. Such small domains do occur in the separate comparison of independently configured systems: SABER has only 2 candidates for SpMM and 1 for SDDMM there (Table 22). The manuscript reports neither the 26-workload domain sizes nor the number of trajectories ended by exhaustion. The reduction from 69 hard failures to 0 is useful, but the comparison does not tell us how much comes from the abstraction level. SABER chooses among backend implementations and never generates source code (L51-52), which already removes many opportunities for failure.

W2. Matched-schedule schema not disclosed. The matched study is the paper's strongest evidence, but the paper never shows what the lower-level representation looks like. SABER's schema is summarized in Table 7 and illustrated in Figures 1 and 2, whereas the matched schedule is described only as a fixed physical scheduling schema (Appendix B.3), with no fields, prompt text or example action. Table 2 suggests the 2 schemas differ in how hard they are to write: matched-schedule responses are about 1.8 to 2.4 times longer (348, 320 and 620 vs. 148, 142 and 340 output tokens) and contain more invalid actions (9, 8 and 18 vs. 3, 2 and 10). It's hard to tell how much of the difference comes from the abstraction level versus the schema itself. For example, we don't know how many different descriptions can map to the same candidate, or how often the agents generate duplicate candidates. Providing the schema would help, but I think an ablation is still needed to distinguish these explanations. For example, the authors could try a matched-schedule interface with more semantic field names. The results show that agents do better with the SABER schema used here. I am less convinced that they establish where the abstraction boundary should be, as claimed at L472-474.

Minor

W3. The practical benefit in the matched study is small. SABER's speedup over the matched schedule is only 1.064×1.064\times to 1.080×1.080\times (L370-372). With shared-reference geometric-mean latencies of 8.74 µs for SpMM and 6.21 µs for SDDMM (Table 19), the absolute gains appear to be below a microsecond. I would like to see the latency range across the 32 candidates and repeated timing measurements to understand how reliably these differences can be measured. It would also help to include the Direct CUDA latencies in the main text, which currently compares output-token counts on these workloads (L118-119). Table 15 shows that SABER's selected kernels are slower under 2 of the 3 models (0.9499×0.9499\times and 0.9199×0.9199\times speedup over Direct CUDA).

Questions for authors

Q1. Could the authors show both prompt templates and the SABER and matched-schedule actions corresponding to all 32 candidates for one SpMM workload and one SDDMM workload? I would also like to know which SABER fields vary and how often agents revisit the same candidate under each interface.

Q2. What are the SABER action-domain sizes in the 26-workload experiment, and how many trajectories end by exhaustion? How do attainment and proposals-to-best compare when measured against a fixed reference, or restricted to workloads whose finite action domain contains at least 8 actions?

Q3. What numerical tolerance applies in the 26-workload experiment? When a numerical failure occurs, does the agent receive an error magnitude or only a pass/fail flag?

Q4. For the ten workloads of the controlled study, what is the latency range across the 32 candidates, and how large is the measurement variation across repeated timing samples? How does cuSPARSE 13.3 perform on these workloads under the same timing protocol?

2 comments

Q1. Prompts, candidate encodings, and revisits

Please see Reviewer YseR Q1 and Q2.

Q2. Action-domain sizes, exhaustion, and search metrics

The 26 workloads expose 1, 2, or 4 legal SABER actions each, as shown below.

Actions per workloadWorkloadsTrajectories
1824
21236
4618
Total2678

In total, there are 56 workload-action combinations. Across 78 trajectories, SABER makes 189 proposals: 118 improving candidates, 50 correct but non-improving candidates, and 21 duplicates or no-ops. The recorded action visits are consistent with domain exhaustion in all 78 trajectories. None of the workloads has eight or more legal actions.

We also report two search metrics at response 2, both relative to each trajectory's final best candidate:

Metric at response 2SABERDirect CUDA
Exact best found71/78 (91.0%)27/78 (34.6%)
Within 10% of final best72/78 (92.3%)37/78 (47.4%)

SABER finds its final best candidate after 1.628 responses on average, compared with 3.986 for Direct CUDA, over 78 and 74 successful trajectories, respectively. SABER also records 0 hard failures in 189 proposals, compared with 69 in 624 for Direct CUDA.

For comparison against a common reference, the separate matched study shows that SABER finds a kernel within 10% of the fastest shared candidate in 80.0% versus 56.7% of trajectories at R2, and 97.8% versus 84.4% at R8 (Table 21).

Q3. Numerical tolerance and correctness feedback

Both the 26-workload experiment and the ten-workload matched study use atol = rtol = 1e-4 for numerical correctness. Candidate outputs are checked against the corresponding reference results.

Agents receive numerical error magnitudes in their feedback. For example, Direct CUDA on stage8:spmm-bsr-059 (replicate 0, response 6) received NUMERICAL_CORRECTNESS_FAILURE with max_abs=0.955982 and max_rel=0.142661. The 26-workload Direct CUDA results contain 54 numerical failures.

Q4. Candidate latency, timing variation, and cuSPARSE

Table 15 reports the geometric-mean speedups of SABER-selected kernels:

ModelSABER over matched scheduleSABER over Direct CUDA
GPT-5.61.0722x0.9499x
GPT-61.0643x0.9199x
MiniMax-M31.0798x0.9995x

We benchmark all 32 candidates on each of the ten CSR workloads. The geometric means of the fastest and slowest candidate latencies across workloads are 8.74-17.48 μ\mu s for SpMM and 6.21-12.42 μ\mu s for SDDMM, respectively.

Table 20 reports paired workload-bootstrap 95% confidence intervals of [1.018, 1.129], [1.015, 1.118], and [1.009, 1.115] for GPT-5.6, GPT-6, and MiniMax-M3, respectively.

We also benchmark cuSPARSE 13.3 on the same ten CSR workloads using the same FP32 inputs and GPU timing protocol. Its geometric-mean latencies are 18.6 μ\mu s for SpMM and 14.4 μ\mu s for SDDMM. The fastest shared implementations outperform cuSPARSE by 2.13x for SpMM and 2.32x for SDDMM.

I thank the authors for addressing my main concerns about the search space and the matched comparison.

Reviewer_9kjhOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents SABER, a programming interface for agents optimizing sparse GPU kernels. The agent specifies sparse strategy and coarse hardware intent, while a compiler backend handles physical details. Benchmarked on a number of diverse workloads, the paper reports that strong performance with fewer failures and earlier search progress compared to direct CUDA generation, although final kernel performance is roughly on par. The authors also compare SABER with a lower-level schedule representation on 10 CSR workloads as ablations. They show SABER reaches strong candidates earlier, generates shorter responses, and selects faster implementations.

Critical strengths
  • The paper tackls an important problem in GPU kernel optimization
  • Solid ablation design by comparing SABER vs the lower-level schedule that share candidate identities, backend code, inputs, numerical contracts, and response budgets. This provides strong evidence for an interface effect than a comparison against unrestricted CUDA alone.
  • The paper carefully separates easier search from faster kernels and demonstrates the backend tradeoff. It reports overall parity with Direct CUDA in the broad study and a substantial SpGEMM performance deficit. These results help establish both the benefit and the cost of delegating physical implementation choices to a reusable backend.
Critical weaknesses
  • The matched interface comparison needs a more concrete specification. Appendices B.3–B.4 describe the two representations and their common portfolio, but do not show the full lower-level action schema, exact prompts, or example mappings from both actions to the same backend identity.
  • The reported gains establish an advantage for the tested interface package, but the paper does not fully separate the contribution of sparse semantic concepts from differences in schema length, defaults, or applicability constraints.
  • The controlled evidence is limited to a small, predefined search setting. Representation and numeric-core choices are fixed in the runs in table 5. It is unclear whether the advantage persists for larger matrices, more irregular sparsity, or richer action spaces where backend coverage is less complete.
  • The practical value of agent search over simple finite-set selection is not fully established,more experiments may be needed.
Questions for authors

See weakness section

2 comments

Q1. Matched interface specification

Please see Reviewer YseR Q1.

Q2. Sparse semantics versus schema complexity

Please see Reviewer YseR Q2. We do not claim that the proposed abstraction boundary is universally optimal. The matched study shows consistent improvements for both SpMM and SDDMM across all three coding models, while the backend experiments demonstrate that different GPU implementations can be optimized without changing the public semantic actions.

Q3. Larger workloads and richer action spaces

The matched study covers CSR matrices up to 256 (Table 5). Our full-system study also evaluates six 2048x 2048 CSR SDDMM workloads, achieving a 1.4367x speedup over Direct CUDA (Tables 9 and 11).

We further evaluate 120 CSR SDDMM workloads with matrix sizes from 4,096x 4,096 to 65536x 65,536, reduction dimensions of 32-128, and sparsity levels of 90%, 95%, 99%, and 99.9%. We use uniform and power-law distributions with matched nonzero counts. Both interfaces share the same 32-candidate portfolio and eight-response budget, with three runs per workload.

Across 360 trajectories per interface, SABER finds a kernel within 10% of the fastest shared candidate in 94.4% of runs versus 81.1% for the matched schedule, achieving a 1.08 x speedup in selected-kernel performance. On power-law workloads, the corresponding success rates are 91.1% and 77.8%.

Q4. Agent search versus finite-set selection

Appendix H.2 evaluates fixed, heuristic, and decision-tree selectors on 72 additional workloads using existing candidate sets.

In the matched study, SABER reaches 97.8% within-10% attainment at R8, compared with 84.4% for the lower-level schedule. Random-selection results are provided in our response to YseR Q3.

I thank the authors for the detailed rebuttal and for following up with some new experiments. I feel much of the claimed advantage may come from other factors rather than sparse semantics, and this may need to be further ablated to establish understanding. That being said, I am willing to maintain my positive recommendation.

Reviewer_YseROpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents SABER, an agent-facing programming interface for optimizing sparse GPU kernels. SABER exposes sparse strategy and coarse hardware intent to a coding agent while delegating concrete GPU realization, including lane mapping, storage placement, synchronization, vectorization, instruction selection, and launch configuration, to a compiler backend. The paper evaluates the proposed interface at three levels. First, it classifies optimization decisions from three held-out sparse systems to examine whether the proposed vocabulary transfers beyond the systems used during design. Second, it compares SABER with Direct CUDA across 26 workloads and six sparse operator groups as a full-system comparison. Third, it conducts a matched study on ten CSR SpMM/SDDMM workloads in which SABER and a lower-level scheduling representation expose the same 32 executable backend implementations per workload. The matched study uses three coding models and reports that SABER reaches strong candidates earlier and selects implementations closer to the shared finite reference. Additional experiments compare independently configured SABER and SparseTIR backends and evaluate improvements to private backend realizations.

Critical strengths

The paper asks a well-motivated systems question and proposes a clear abstraction boundary.SABER separates sparse strategy from concrete GPU realization. This is a meaningful design choice because coding agents must otherwise reason simultaneously about sparse work organization, thread mapping, memory movement, synchronization, and launch mechanics. The interface aims to preserve decisions that affect logical sparse strategy while moving reusable physical realization choices into the backend.

The matched evaluation methodology is a good contribution.The ten-workload study exposes the same 32 executable implementations through SABER and a lower-level schedule. This controls for candidate-space size, implementation identity, backend code, workload, numerical contract, and response budget. Under this control, SABER reaches strong candidates earlier and selects candidates closer to the shared finite reference across three coding models.

Critical weaknesses

The matched evidence supports the two representations tested, but doesn't fully prove the general abstraction-boundary principle. The main controlled result shows SABER beats the specific lower-level schedule within a fixed pool of 32 candidates. But that lower-level schedule is just one representation designed for this experiment. The paper doesn't compare SABER against alternative lower-level representations with similar output length, syntax, validity constraints, or semantic guidance. So the experiment shows SABER is more effective than this particular matched schedule under these conditions—it doesn't prove the "semantic strategy" vs. "physical realization" split is generally optimal, nor that the gains come specifically from the abstraction boundary rather than from differences in compactness, field semantics, or validity constraints.

The evaluation is limited in scale and external validity, especially for the broader performance claims.The full-system comparison covers 26 workloads and six operator groups, but it compares different reachable implementation spaces, so it's not a causal comparison at the abstraction level. The controlled comparison—which provides the strongest causal evidence—only has five CSR SpMM and five CSR SDDMM workloads, with 32 predefined candidates per workload and eight responses per trajectory. And the shared finite reference is explicitly not a global GPU optimum. So the results show better selection within a small, fixed portfolio, not general superiority over open-ended kernel optimization. The configured SABER–SparseTIR results also mix differences in candidate domains, backend implementations, and model selections, so they should still be read as configured-system results rather than interface effects.

Questions for authors
  1. Can the authors provide the complete prompts and schemas for SABER and the matched lower-level schedule, together with representative mappings from the same backend implementation to both agent-facing representations? How are output length, semantic information, validity constraints, and canonicalization controlled?

2.Does the advantage persist when the lower-level schedule is replaced by a similarly compact structured representation, or when SABER’s semantic fields are presented with comparable formatting and action constraints? This would help distinguish abstraction-boundary effects from representation complexity.

3.How does the matched comparison behave with larger candidate sets, more than eight response slots, or candidates generated online rather than drawn from a predefined 32-item portfolio? Is the search advantage preserved when the finite portfolio is no longer small?

  1. The paper reports response length and generation time, but does not claim an end-to-end wall-clock speedup. Can the authors report total model generation, compilation, validation, GPU measurement, and backend preparation costs, and explain whether the interface reduces total optimization cost after these components are included?
2 comments

Q1. Prompts, schemas, and implementation mappings

The matched study uses identical workload inputs, FP32 correctness requirements (atol = rtol = 1e-4), response budgets, and trajectory-local feedback. Both interfaces select from a shared portfolio of 32 executable implementations per workload.

Common prompt template

You are a GPU kernel optimization agent. Optimize the supplied
CSR SpMM or CSR SDDMM workload for minimum device latency.

WORKLOAD:
{{WORKLOAD_JSON}}

Preserve the mathematical operation, sparse support, FP32 inputs,
FP32 accumulation, and FP32 outputs. Every invocation must produce
one complete result independently of previous output contents.

All outputs must have the expected shape, be finite, and satisfy:
abs(actual - reference) <= 1e-4 + 1e-4 * abs(reference)

Return exactly one candidate per response. You have eight response
slots. Malformed, invalid, incorrect, duplicate, build-failing,
and execution-failing responses consume a slot.

The evaluator validates the response, resolves the candidate,
compiles and checks the implementation, and reports GPU latency
for admitted correct candidates.

Use only the supplied workload, interface specification, and
feedback from the current trajectory. Do not use external tools,
repository access, or information from other trajectories.

TRAJECTORY HISTORY:
{{TRAJECTORY_HISTORY}}

INTERFACE SPECIFICATION:
{{INTERFACE_SPECIFICATION}}

SABER response schema

SABER represents sparse execution strategies through kind and parameters:

{
  "type": "object",
  "additionalProperties": false,
  "required": ["kind", "parameters"],
  "properties": {
    "kind": {"type": "string"},
    "parameters": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": false,
        "required": ["name", "value"],
        "properties": {
          "name": {"type": "string"},
          "value": {"type": "string"}
        }
      }
    }
  }
}

For CSR SDDMM, a representative semantic action is:

{
  "kind": "configure_sparse_execution",
  "parameters": [
    {"name": "representation", "value": "csr"},
    {"name": "grouping", "value": "scalar"},
    {"name": "traversal", "value": "row_major"},
    {"name": "partition", "value": "sample_entries"},
    {"name": "ownership", "value": "exclusive"},
    {"name": "merge", "value": "none"},
    {"name": "memory_stage", "value": "direct"},
    {"name": "numeric_core", "value": "scalar_fma"},
    {"name": "tile_hierarchy", "value": "linear"}
  ]
}

Here, sample_entries assigns each sampled output to one logical work unit, exclusive gives it a single owner, and merge=none avoids cross-owner merging. The backend determines how threads cooperate to compute each dot product.

Lower-level scheduling schema

The lower-level scheduling interface uses schedule_text and parameters:

{
  "type": "object",
  "additionalProperties": false,
  "required": ["schedule_text", "parameters"],
  "properties": {
    "schedule_text": {"type": "string"},
    "parameters": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": false,
        "required": ["name", "value"],
        "properties": {
          "name": {"type": "string"},
          "value": {"type": "string"}}}}}}

For SDDMM, the lower-level schedule parameters include tx ∈\in {8,16,32}, ty ∈\in {1,2,4,8}, vector_size ∈\in {1,2,4}, and group_size ∈\in {1,2,4}, subject to tx * vector_size <= reduction_extent.

Example action mappings

For CSR SDDMM with reduction dimension 64, the SABER action uses partition=sample_entries, ownership=exclusive, and merge=none. The corresponding lower-level schedule uses tx=16, ty=4, vector_size=2, and group_size=1, assigning 16 lanes to each sampled entry and four entries to each block.

For CSR SpMM, the SABER action uses partition=complete_rows, ownership=exclusive, and merge=none. The corresponding lower-level schedule uses thread_x=32, thread_y=8, coarsening_factor=1, and num_col_parts=1.

In both cases, the two encodings resolve to the same backend implementation, including its kernel specialization and launch configuration.

Canonicalization and experimental control

Both interfaces follow the same evaluation sequence:

Parse --> Validate --> Canonicalize --> Resolve candidate --> Compile --> Check correctness --> Measure latency

The JSON schemas define the response format, while interface-specific validation checks parameter values and workload constraints. Canonicalization identifies duplicate actions, which still consume response slots.

Both interfaces select from the same 32 backend implementations per workload, including their specialization and launch configurations. SABER responses average 148, 142, and 340 tokens, compared with 348, 320, and 620 for the matched schedule under GPT-5.6, GPT-6, and MiniMax-M3, respectively (Table 2).

Q2. Abstraction boundary versus representation complexity

Our goal is not to identify a universally optimal boundary between semantic strategy and physical realization, as the appropriate boundary may depend on the hardware and backend. We study one such boundary for sparse GPU computations, where the agent controls sparse partitioning, ownership, and merging, while the backend handles thread mapping, vectorization, synchronization, and launch configuration.

The matched study compares the two interfaces over the same 32 executable implementations. SABER selects faster kernels for both SpMM and SDDMM across all three coding models, achieving 1.046-1.065x speedups for SpMM and 1.083-1.099x for SDDMM (Table 15). These results evaluate the complete interfaces, including their schemas and constraints, rather than isolating the contribution of each individual design choice.

Appendix H.4 further evaluates 105 correct SDDMM workload/variant cases across different physical implementations and scheduling configurations. Improving the backend without changing the SABER action yields a 1.3099x speedup for SDDMM. Similarly, Appendix H.5 reports a 3.3578x speedup for SpGEMM while keeping the public action unchanged.

To further examine the effects of schema length, defaults, and applicability constraints, we evaluate three additional lower-level schedule configurations: (1) a compact schema, (2) the compact schema with explicit defaults, and (3) the compact schema with explicit defaults and workload-specific applicability constraints. All configurations use the same 32 executable implementations, workloads, correctness criteria, and response budget. Each configuration contains 90 trajectories across ten workloads and three coding models.

The percentages of trajectories reaching a kernel within 10% of the fastest shared candidate are:

InterfaceR2R4R8R16
Original Matched Schedule56.7%73.3%84.4%91.1%
Compact Schedule58.9%77.8%87.8%93.3%
Compact + Defaults68.9%82.2%91.1%94.4%
Compact + Defaults + Applicability75.6%85.6%94.4%97.8%
SABER80.0%91.1%97.8%100.0%

At R8, attainment increases from 84.4% for the original matched schedule to 87.8%, 91.1%, and 94.4% under the three additional configurations, respectively, compared with 97.8% for SABER. SABER also achieves higher attainment at R2, R4, and R16.

Q3. Larger candidate sets and response budgets

We additionally run both interfaces with 16 response slots, keeping the workloads, 32-candidate portfolio, correctness criteria, and feedback protocol unchanged. We report cumulative attainment within 10% of the fastest shared candidate at R2, R4, R8, and R16.

Response slotsSABERMatched schedule
280.0%56.7%
491.1%73.3%
897.8%84.4%
16100.0%91.1%

At R4, SABER reaches 91.1%, matching the lower-level schedule at R16 with one quarter of the responses. At R16, SABER reaches 100.0%, compared with 91.1% for the matched schedule.

We also examine how portfolio size affects random search. Assuming eight candidates meet the performance threshold, the probability of finding at least one through uniform sampling without replacement is: P(t)=1−(N−8t)(Nt)P(t)=1-\frac{\binom{N-8}{t}}{\binom Nt}.

Portfolio sizeR2R4R8R16
3244.4%70.5%93.0%99.9%
6423.6%42.2%67.9%91.5%
12812.2%23.0%41.2%66.7%

With eight responses, the probability of finding a qualifying candidate drops from 93.0% to 41.2% as the portfolio grows from 32 to 128 candidates.

Q4. Complete optimization cost

Table 27 reports generation time per response. Across eight responses, SABER reduces generation time by 33.9%, 33.8%, and 22.0% for GPT-5.6, GPT-6, and MiniMax-M3, respectively.

Component costs (seconds per trajectory)

StageGPT-5.6 SABERGPT-5.6 MatchedGPT-6 SABERGPT-6 MatchedMiniMax SABERMiniMax Matched
Generation57.687.276.8116.062.480.0
Parsing0.20.20.20.20.20.2
Build / startup31.630.831.730.929.929.8
Validation4.03.94.03.93.73.5
GPU measurement2.01.92.01.91.91.8
Preparation5.05.05.05.05.05.0
Total100.4129.0119.7157.9103.1120.3
Reduction22.2%24.2%14.3%

SABER saves 28.6, 38.2, and 17.2 s per trajectory, respectively. Appendix H.8 further reports 11.89-12.28x faster disk-warm wrapper execution than cold execution, prepared-plan host times of 5.707-6.981 s, and compiler processing time of 1.142-1.916 ms.

Comments on the paper

2 comments
AuthorsOpenReview ↗

General Response to All Reviewers

We thank all reviewers for their reading and feedback.

We have clarified the scope of SABER and provided additional experiments to address the main concerns. First, we clarify that SABER does not aim to identify a universally optimal abstraction boundary, but instead studies a practical interface for sparse GPU optimization. We provide detailed prompts, schemas, and implementation mappings, along with additional ablations examining schema length, defaults, and applicability constraints.

We appreciate the reviewers' suggestions.

Area_Chair_T9x5OpenReview ↗

Reminder: Author–reviewer discussion ends today

Dear Reviewers,

As the author–reviewer discussion period ends today (November 18, AoE), please read the authors’ responses, any relevant manuscript updates, and the other reviewers’ comments, and engage with the authors before the deadline.

In particular, please clarify which of your concerns have been addressed and which remain unresolved, and raise any remaining questions promptly so the authors have an opportunity to respond. Even if your assessment is unchanged, a brief follow-up explaining your reasoning would be helpful.

Thank you for your time and thoughtful reviewing!

Area Chair

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.