acceptodds
Under review as a conference paper at ICLR 2027

Generative Adversarial Loops

Abstract

Research progress in AI can be understood as the interaction between two complementary processes: benchmark creation and method discovery. Historically, both processes were driven by human intelligence. However, recent advances in AI have significantly accelerated automated method discovery, while automated benchmark creation has received comparatively less attention. To realize truly self advancing systems, we propose Generative Adversarial Loop (GAL), a generator discriminator framework that alternates between two agentic searches: (1) a discriminator that generates adversarial data to expose weaknesses in current systems, and (2) a generator that discovers algorithms to overcome them. We apply this framework to approximation algorithms for efficient inference. Unlike existing auto research systems, which primarily focus on algorithm discovery, GAL introduces a discriminator agent that automates goalpost setting by continually searching for weaknesses in the current algorithm. We demonstrate adversarial data generation across four tasks: KV compression, sparse video generation, sparse attention, and context extension, where the discriminator identifies weaknesses in state of the art techniques. We further show that GAL enables autonomous improvement for KV compression and context extension, with newly discovered algorithms improving not only on adversarially generated data, but also, in some cases, on established benchmarks. GAL thus provides a path toward autonomous goalpost setting and algorithmic improvement, where AI systems continually discover their own weaknesses and develop methods to overcome them. Code: https://anonymous.4open.science/r/generative-adversarial-loops

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
auto research, agents, self improving agent

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_qKxbOpenReview ↗
Rating
2(+1)
Confidence
2
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper introduces GAL, a framework that combines adversarial benchmark generation with automated algorithm discovery. The two agent work in an iterative loop, allowing the system to discover new weakness and develop solutions. This paper seems like a case study report, because it does not provide sufficient results to validate the effectiveness of the proposed framework. Also, I am curious about whether this paper is produced by automated research?

Critical strengths
  1. I think the idea of automatically discovering weaknesses and using them to guode further improvements is interesting. Somehow, this paper, from my perspective, is not completed yet.

  2. The authors evaluate this framework on four different tasks, but almost any of them only provides a case analysis, which can not be used to validate the effectiveness of the proposed framework.

Critical weaknesses
  1. The overall idea is relatively straightforward, where one agent searches for failure cases, and another agent tries to improve the algorithm based on those failures. Both parts are implemented using existing tools, such as GEPA and coding agents. Similar ideas have also been explored in previous work, including Hacker-Fixer Loops.

  2. The paper does not provide enough comparisons to show why the proposed framework is necessary. How does GAL compare with simply using an LLM to generate challenging test cases, or using a coding agent to improve algorithms on a fixed benchmark? Without these baselines, it is difficult to understand what GAL actually contributes beyond combining existing techniques.

  3. Although the paper covers four inference tasks, most results are presented as individual examples rather than systematic evaluations. Besides, the complete adversarial loop is only demonstrated on two tasks with two iterations each.

  4. In Figure 7, the evolved algorithms improve substantially on the generated adversarial benchmarks, but some original benchmark scores remain unchanged or become worse. This makes the claim of general algorithm improvement less convincing.

Questions for authors
  1. Could authors provide comparisons with simpler baselines, such as random adversarial search, direct LLM-based test generation, and algorithm optimization without the discriminator?

  2. What is the overall success rate of the discriminator across different tasks? How many candidates are generated, and how many valid failure cases are found? Could the authors report the average performance gap and variance across multiple independent runs, rather than mainly showing selected examples?

  3. Do the discovered algorithms improve on independently generated adversarial examples that were not used during the optimization process?

  4. In Figure 7, some standard benchmark results become worse after algorithm evolution. How do the authors balance performance on newly discovered adversarial examples with performance on existing benchmarks?

  5. Why is the full GAL loop only evaluated for two iterations on two tasks? Could the authors provide more iterations or repeated experiments to show that the framework can consistently discover new failure cases and improve the algorithms?

5 comments

We thank the reviewer for the time and effort. To address the reviewer's concerns we ran a broader set of experiments to support our experimental hypothesis. We appreciate that they find the idea of letting discovered weaknesses guide algorithm improvement interesting and want to clarify that the paper was not produced by automated research. The idea, implementation, experiments and writing are the authors’ own; we used AI assistants for coding and for polishing the text (i.e blobs of text were written manually and AI was asked to take an edit pass to fix grammar), as stated in the paper.

The premise of GAL is that as systems increasingly saturate established benchmarks, scientific progress requires benchmarks to evolve alongside them. Our experiments with both non-evolutionary and agentic benchmark-generation baselines demonstrate the limitations of existing approaches and motivate the need for a system that can continually advance benchmark generation. Our results show that GAL achieves better discriminator outcomes at lower cost than both non-evolutionary and agentic benchmark-generation baselines.

Importantly, although GAL leverages existing methods for optimization and evolution, its underlying approach to driving system advancement is not derived from any one of these individual techniques. Rather, GAL introduces a new paradigm in which the process of evaluating and improving systems is itself continuously evolving. We believe this approach can contribute to sustaining scientific progress, particularly in ML and, more broadly, across data-driven fields.

We acknowledge that other works are emerging in similar directions. However, these works are concurrent with ours and generally address more specific, distinct problems. For instance, Hacker-Fixer Loops (mentioned by a reviewer), which appeared in June 2026 (concurrent work), focuses on hardening the verifiers of fixed agent benchmarks such as KernelBench and Terminal-Bench. In contrast, GAL focuses on improving the algorithm under test by continually discovering new adversarial inputs against which it is evaluated. Thus, while both explore iterative improvement, they address fundamentally different aspects of the research process: improving the reliability of evaluation mechanisms versus advancing the capabilities of the systems by advancing evaluation datasets.

To support the above claims, we present the evidence below:

Comparison with simpler baselines (Q1)

1. Random adversarial search, direct LLM-based test generation

We already compare discriminator results with GEPA based evolution to Coding Agent based evolution in the paper (Figure 6 left for KV compression). We also compare with plain LLM discriminator under same model and cost budget below -

MethodMean best gapstd-dev
GEPA0.3550.229
Cursor agent0.2600.364
LLM-only (no evolution)0.1950.240

2. Algorithmic optimization without discriminator

The premise of GAL is that as systems saturate for standard benchmarks, there is a need for pushing the benchmarks ahead in order to further drive and evaluate system improvements. Hence, while system evolution may perform well on existing benchmarks, GAL’s value is in identifying new benchmarks when algorithm evolution alone saturates.

(continued)

Success rate and variance of discriminator (Q2)

Figure 6 in the paper shows the gap plots (avg and std-dev) against $ cost for various models and setups for both KV compression and context extension. These plots show results for 10 independent runs of discriminator for these two domains. The following tables show the data for these plots.

KV Compression via FastKVZip

modelmax avg gapstd-dev
gepa-gpt-5.6-luna0.5850.243
gepa-gpt-5.6-terra0.6000.269
gepa-gpt-5.6-sol0.2950.090
gepa-gemini-3.5-flash-lite0.3100.257
gepa-gemini-3.6-flash0.3000.105
gepa-gemini-3.1-pro-preview0.3650.206

Context Extension via DCA

modelmax avg gapstd-dev
gepa-gpt-5.6-luna1.0000.000
gepa-gpt-5.6-terra1.0000.000
gepa-gpt-5.6-sol0.9550.142
gepa-gemini-3.5-flash-lite0.7000.256
gepa-gemini-3.6-flash0.9600.070

Even in the least performing model, the discriminator ends up discovering an average gap of 0.295 for KV compression with FaskKVZip and 0.70 for context extension with DCA.

Additionally, in the five-round loops, every round produced a break. During full GAL loops the number of candidates evaluated before discriminator succeeded were as following:

Round12345
Context extension (DCA)1836107
KV compression (Compactor)7224385

For sparse video generation, we present statistics over all 725 search candidates instead of the selected example in the paper. A failure counts as valid only if the dense video still matches its prompt, so that the damage is due to sparse attention.

Objective (target)CandidatesValid failuresLPIPS > 0.5PSNR < 18 dB
Divergence × coherence (SVG1)24290%76%82%
Divergence × VBench damage (SVG1)22366%25%44%
Pixel MSE (SVG1)13695%43%62%
Pixel MSE (SVG2)1244%0%0%

Improvements on independently generated adversarial examples (Q3)

We perform this experiment in the KV compression setting. At the beginning, we generate multiple adversarial benchmark candidates and evaluate the candidates produced by Gen1 and Gen2 on these held-out adversarial benchmarks. In the table below, B1 and B2 are the adversarial benchmarks used in GAL rounds 1 and 2, respectively, while C1–C13 are adversarial candidates which were created at Base and that were never shown to the generator. As we can see, the improvements generally transfer to other held-out adversarial datasets.

AlgorithmB1B2C1C2C3C4C5C6C7C8C9C10C11C12C13
Base0.250.450.350.450.250.000.000.000.000.050.100.050.450.300.50
Gen10.850.250.350.350.050.100.000.050.100.100.100.050.651.001.00
Gen20.951.000.550.750.600.350.050.200.450.750.550.700.850.751.00

Note that, in practice, a generator may produce candidates that perform worse on unseen adversarial examples. However, in our experiments, the improvements generally transfer across the board to other held-out adversarial benchmarks.

Extension to 5 GAL iterations and more standard benchmark evaluation (Q4 and Q5)

In the following tables, we present extensions of our experiment over two axis

(1) We run additional GAL loops upto 5 loops in total. (We would like to clarify that GAL is a bottleneck by the evaluation we have to do in every sub iteration in discriminator and Generator. For example, a single GAL loop takes up to 20 hours in KV Compression.)

(2) We also expand the tables with more standard benchmarks not part of B0 which is shown to the discriminator and generator to show that these improvements do not come at the cost of existing performance. Note that in an ideal invocation of GAL, B0 should be representative of all evaluation data that Algorithm saturates. But practically this is not possible due to cost and time constraints.

In the following results all benchmarks other than [B0-B5] are heldout existing benchmarks.

KV compression with Compactor

AlgorithmB0 (RULER-HARD)B1B2B3B4B5LongBench
no-press0.88231.000.951.001.001.000.4344
Gen0 (Compactor)0.76520.350.300.000.001.000.3768
Gen10.76840.850.250.000.201.000.3784
Gen20.75810.951.000.050.051.000.3914
Gen30.75571.000.950.900.301.000.3759
Gen40.78001.001.001.000.950.400.3717
Gen50.78471.001.001.000.850.850.3836

RULER-HARD: 7 task sets - 350 examples and LongBench: 21 task sets - 1050 examples

The per-task results reported in the paper are based on a sample of 20 examples per task and represent just one evaluation run, leaving room for sampling-related variation. The table above reports results using a larger sample of 50 examples per task, showing more consistent improvements or, at minimum, comparable performance.

Context extension with DCA

AlgorithmB0 (Simple Niah)B1B2B3B4B5RULER, 13 tasks (390 rows)LongBench, 15 English tasks (550 rows > 8k)Passkey, 16k and 32k (50 each)Needle, all depths, 16k and 32kL-Eval Coursera / SciFi (average)
No extension0.000.000.000.000.000.00
Gen0 (DCA)0.970.400.680.300.380.780.60145.381.001.0058 / 68 (63)
Gen11.000.950.700.420.380.800.71346.121.001.0060 / 78 (69)
Gen21.000.930.900.500.330.330.70946.031.001.0060 / 74 (67)
Gen30.970.880.930.850.350.120.68544.911.001.0058 / 76 (67)
Gen41.000.970.930.880.850.000.65745.181.001.0058 / 76 (67)
Gen51.001.000.950.800.820.930.69245.411.001.0058 / 76 (67)

We hope these results address reviewer’s concerns and would be glad to answer any further questions.

Reviewer_x79fOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper introduces Generative Adversarial Loops (GAL), which alternates between generating adversarial benchmarks and improving algorithms based on the discovered failures. The framework uses existing agentic search tools to find challenging inputs and modify algorithms accordingly. Experiments cover four efficient inference tasks, with two complete evolution rounds demonstrated for KV compression and context extension. The results show that GAL can expose weaknesses in existing methods and improve performance on the generated adversarial benchmarks.

Critical strengths
  1. The paper allows agents to discover new evaluation cases instead of relying entirely on fixed benchmarks, which is a meaningful direction.

  2. The experiments identify concrete failure patterns across four inference tasks.

Critical weaknesses
  1. The adversarial cases are largely constructed within predefined synthetic task families, with limited evidence of their relevance to representative workloads. The PQCache failure disappears at 5% sparsity, while the sparse video experiment reports only one adversarial example without aggregate statistics.

  2. The complete loop is demonstrated for only two rounds in two domains, without a compute-matched comparison against fixed-benchmark evolution. The generator optimizes a frozen adversarial set, while performance on established benchmarks is mixed, including a decline in RULER cwe accuracy from 0.760 to 0.728 for KV compression.

  3. Equations (2) and (4) optimize correctness without accounting for inference latency, memory, or computational overhead. Although KV compression is evaluated at a nominal 4× ratio, the actual efficiency of the evolved algorithms is not reported.

  4. The reported gaps are selected through adversarial search without independent evaluation on fresh samples from the evolved generators, and the underlying sample sizes are unclear. Although Figure 6 averages ten search runs, the cost certificate depends on the search model and harness and does not clearly account for evaluation GPU costs.

Questions for authors
  1. What evidence establishes that the discovered failures reflect meaningful algorithmic weaknesses beyond the synthetic evaluation settings?

  2. How does GAL prevent repeated optimization around similar failure patterns as the number of evolution rounds increases?

  3. Does the reported algorithmic improvement preserve inference efficiency in terms of actual memory consumption, latency, and computational overhead?

  4. Are the adversarial gaps evaluated on independent samples, and what costs are included in the cost certificate?

8 comments

The authors did not provide a specific response to my questions. Therefore, I maintain 2 (Weak rejection).

We thank the reviewer for their time and effort and greatly appreciate their thoughtful review and recognition that new evaluation benchmark discovery is a meaningful direction.

We also apologies for the delay in our response. This was due to several experiments we ran to ensure we addressed every aspect of their review with supporting data.

We conducted additional experiments to address each point raised by the reviewer. First, we extended the full loop from 2 to 5 rounds in both KV compression and context extension. We also extend GAL full loop to sparse attention. Second, we present the performance of evolved algorithms on heldout adversarial as well as standard benchmarks. Third, we elaborate on PQCache and SVG relevance and statistics. Finally, we show that both components of the loop are necessary. A generator alone will be limited by benchmarks and GAL discriminator works better, consistently and at lesser cost.

We hope these address the concerns raised and would be happy to clarify any remaining questions.

We want to begin by clarifying the GAL setup that addresses weakness 2 and 4 (generator optimizes a frozen adversarial set; adversarial search without independent evaluation on fresh samples)

Clarification about the setup

GAL alternates between discriminator and generator loops. In each iteration, the discriminator discovers an adversarial benchmark set (Bᵢ) for the current pinned algorithm (Genᵢ₋₁). The generator then evolves the algorithm to meet the performance requirements on Bᵢ while avoiding regressions on previously established benchmarks (B₀). Note that B₀, is an existing benchmark shown to the system to ensure that the improvements don't come at the cost of existing performance. In our experiments, the first iteration starts with the original algorithm (Gen₀), while subsequent iterations use the algorithm produced by the previous generator loop.

Thus, GAL does not optimize against a frozen benchmark set. Each iteration discovers new adversarial benchmarks for the latest evolved algorithm. Results of earlier algorithm versions on subsequently discovered benchmarks (Bⱼ, where j > i) are evaluated post facto, solely for comparison and to identify improvements or regressions.

Extended GAL loops

This addresses weakness 2 and Q2 (only two rounds in two domains; similar failure patterns)

In the following tables, we present extensions of our experiments:

1. More loop iterations

We run additional GAL loops upto 5 loops in total for both KV Compression and context extension. (We would like to clarify that GAL is a bottleneck by the evaluation we have to do in every sub iteration in discriminator and generator. For example, a single GAL loop takes up to 20 hours in KV Compression.) and also present results on additional held out standard benchmarks.

KV compression with Compactor

AlgorithmB0 (RULER-HARD)B1B2B3B4B5LongBench (21 tasks)
no-press0.88231.000.951.001.001.000.4344
Gen0 (Compactor)0.76520.350.300.000.001.000.3768
Gen10.76840.850.250.000.201.000.3784
Gen20.75810.951.000.050.051.000.3914
Gen30.75571.000.950.900.301.000.3759
Gen40.78001.001.001.000.950.400.3717
Gen50.78471.001.001.000.850.850.3836

Decline in RULER cwe accuracy (Weakness 2): The per-task results reported in the paper are based on a sample of 20 examples per task and represent just one evaluation run, leaving room for sampling-related variation. Hence we see a drop in cwe, while average is better. The table above reports results using a larger sample of 50 examples per task, showing more consistent improvements or, at minimum, comparable performance.

Context extension with DCA

AlgorithmB0 (Simple Niah)B1B2B3B4B5RULER, 13 tasks (390 rows)LongBench, 15 English tasks (550 rows > 8k)Passkey, 16k and 32k (50 each)Needle, all depths, 16k and 32kL-Eval Coursera / SciFi (average)
No extension0.000.000.000.000.000.00
Gen0 (DCA)0.970.400.680.300.380.780.60145.381.001.0058 / 68 (63)
Gen11.000.950.700.420.380.800.71346.121.001.0060 / 78 (69)
Gen21.000.930.900.500.330.330.70946.031.001.0060 / 74 (67)
Gen30.970.880.930.850.350.120.68544.911.001.0058 / 76 (67)
Gen41.000.970.930.880.850.000.65745.181.001.0058 / 76 (67)
Gen51.001.000.950.800.820.930.69245.411.001.0058 / 76 (67)

Why failures do not repeat (Q2). The discriminator always attacks the latest algorithm, so a failure that has already been fixed produces no gap and cannot be selected again; accordingly, each round produces a different benchmark. The loop also detects its own regressions: in both domains, the round-4 fix degraded B5 (KV compression 1.00 → 0.40; context extension 0.78 → 0.00), and round 5 identified and repaired it (0.85 and 0.93).

2. GAL in more setups:

We incorporated two GAL loops for sparse attention. However, extending GAL to sparse video generation presents a substantially greater computational challenge. Each video generation takes approximately 30 minutes on an H100 GPU. A statistically meaningful evaluation would therefore require generating multiple videos per iteration. Moreover, GAL requires repeating this evaluation over several iterations to obtain a successful discriminator–generator update. The cumulative computational cost quickly becomes prohibitive, making this approach impractical in an academic setting with limited GPU resources. For sparse attention, we use PQCache at 2% density with Qwen3-4B-Instruct-2507 at 32K context. B0 is RULER-HARD 32K (7 tasks), and B1 and B2 are the adversarial benchmarks generated by the discriminator against Gen0 and Gen1.

AlgorithmB0 (RULER-HARD 32K)B1B2
Full attention0.80760.850.95
Gen0 (PQCache)0.76810.350.80
Gen10.78790.600.50
Gen20.82000.850.85

B1: two-step lookup (find an index, then its record). B2: a fact split between the start and the middle of the context, combined in a small calculation.

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

This paper proposes Generative Adversarial Loops (GAL), a framework that alternates between adversarial benchmark generation and automated algorithm discovery. A discriminator uses LLM-based evolutionary search to identify inputs that expose weaknesses in existing algorithms, while a generator attempts to improve the algorithms to address these failures. The authors evaluate the discriminator across four efficient inference tasks: KV cache compression, sparse attention, sparse video generation, and context extension. They further demonstrate two complete GAL iterations for KV cache compression and context extension, showing improvements on adversarial benchmarks while largely maintaining performance on standard benchmarks.

Critical strengths
  1. The paper presents a framework that couples benchmark evolution with algorithm evolution in an adversarial loop. The discriminator continuously expands the benchmark by discovering challenging examples that existing algorithms fail to solve, while the generator evolves the algorithms to address these failures while preserving performance on previously collected examples. This alternating process enables benchmarks and algorithms to co-evolve, providing a promising approach toward more autonomous and adaptive algorithm discovery.
  2. The paper evaluates the discriminator across four efficient inference tasks and identifies interpretable failure patterns, including chunk-boundary effects in context extension and difficulties retrieving relevant information under KV cache compression. More importantly, the authors demonstrate two complete GAL iterations in two tasks, showing substantial improvements on evolved benchmarks and some improvements on established benchmarks. These results provide encouraging evidence that automatically discovered failures can guide useful algorithmic changes.
Critical weaknesses
  1. Although the generated algorithms perform substantially better on the adversarial benchmarks used during evolution, improvements on established benchmarks are mixed. For example, in the KV compression results in Figure 7, Gen-2 improves performance on B1 and B2 but does not consistently outperform the original Compactor across all standard benchmark subsets. Furthermore, only two complete GAL iterations are demonstrated in two domains. It remains unclear whether the discovered modifications address broader failure modes or mainly optimize performance on the accumulated adversarial examples. Evaluation on independently generated, held-out adversarial examples would make the generalization claims more convincing.
  2. While the proposed GAL framework presents a promising paradigm for autonomous algorithm improvement, its methodological novelty appears somewhat limited. The core idea of alternating between adversarial data generation and algorithm improvement is intuitive, and both components are largely implemented using existing tools and techniques, such as GEPA and coding agents. The paper's main contribution therefore seems to lie in integrating existing methods into an automated workflow, rather than introducing fundamentally new algorithms or search mechanisms. Overall, I find the novelty of the proposed approach somewhat limited.
Questions for authors
  1. How can the authors distinguish general algorithmic improvements from targeted patches to the adversarial examples discovered during evolution? In particular, could the authors evaluate the evolved algorithms on independently generated adversarial examples and a broader set of standard benchmarks, and analyze whether improvements on newly discovered failure cases come at the expense of performance on previously solved tasks?
  2. How well do the evolved algorithms perform on held-out adversarial examples generated independently from those used during optimization?
  3. How does GEPA-based adversarial search compare with random search and independent LLM-based candidate generation under the same evaluation budget? In particular, can the authors quantify the benefit of iterative feedback and evolutionary selection?
5 comments

We thank the reviewer for their time and effort, and greatly appreciate their thoughtful review and recognition of the promise of allowing benchmarks and algorithms to co-evolve. The premise of GAL is that as systems increasingly saturate established benchmarks, scientific progress requires benchmarks to evolve alongside them. Our experiments with both non-evolutionary and agentic benchmark-generation baselines demonstrate the limitations of existing approaches and motivate the need for a system that can continually advance benchmark generation. Our results show that GAL achieves better discriminator outcomes at lower cost than both non-evolutionary and agentic benchmark-generation baselines.

Importantly, although GAL leverages existing methods for optimization and evolution, its underlying approach to driving system advancement is not derived from any one of these individual techniques. Rather, GAL introduces a new paradigm in which the process of evaluating and improving systems is itself continuously evolving. We believe this approach can contribute to sustaining scientific progress, particularly in ML and, more broadly, across data-driven fields.

The reviewer's central question is whether the improvements achieved by GAL generalize beyond the specific adversarial examples encountered by the generator, or merely reflect overfitting to those examples. We have conducted additional experiments to directly address this concern and provide further evidence of the generality of GAL's improvements. We first present these new and extended experimental results, followed by responses to the reviewer's other specific questions. We hope these additions address the concerns raised, and would be happy to clarify any remaining questions.

Additional Experiments.

Extension to 5 GAL loops and more standard benchmark evaluation.

In the following tables, we present extensions of our experiment over two axis

(1) we run additional GAL loops upto 5 loops in total. (We would like to clarify that GAL is a bottleneck by the evaluation we have to do in every sub iteration in discriminator and Generator. For example a single GAL loop takes up to 20 hours in KV Compression.)

(2) We also expand the tables with more standard benchmarks not part of B0 which is shown to the discriminator and generator to show that these improvements do not come at the cost of existing performance. Note that in an ideal invocation of GAL, B0 should be representative of all evaluation data that Algorithm saturates. But practically this is not possible due to cost and time constraints.

AlgorithmB0 (RULER-HARD)B1B2B3B4B5LongBench (21 tasks)
no-press0.88231.000.951.001.001.000.4344
Gen0 (Compactor)0.76520.350.300.000.001.000.3768
Gen10.76840.850.250.000.201.000.3784
Gen20.75810.951.000.050.051.000.3914
Gen30.75571.000.950.900.301.000.3759
Gen40.78001.001.001.000.950.400.3717
Gen50.78471.001.001.000.850.850.3836
AlgorithmB0 (Simple Niah)B1B2B3B4B5RULER, 13 tasks (390 rows)LongBench, 15 English tasks (550 rows > 8k)Passkey, 16k and 32k (50 each)Needle, all depths, 16k and 32kL-Eval Coursera / SciFi (average)
No extension0.000.000.000.000.000.00
Gen0 (DCA)0.970.400.680.300.380.780.60145.381.001.0058 / 68 (63)
Gen11.000.950.700.420.380.800.71346.121.001.0060 / 78 (69)
Gen21.000.930.900.500.330.330.70946.031.001.0060 / 74 (67)
Gen30.970.880.930.850.350.120.68544.911.001.0058 / 76 (67)
Gen41.000.970.930.880.850.000.65745.181.001.0058 / 76 (67)
Gen51.001.000.950.800.820.930.69245.411.001.0058 / 76 (67)

Adding GAL loops for other setups.

We incorporated two GAL loops for sparse attention. However, extending GAL to sparse video generation presents a substantially greater computational challenge. Each video generation takes approximately 30 minutes on an H100 GPU. A statistically meaningful evaluation would therefore require generating multiple videos per iteration. Moreover, GAL requires repeating this evaluation over several iterations to obtain a successful discriminator–generator update. The cumulative computational cost quickly becomes prohibitive, making this approach impractical in an academic setting with limited GPU resources. For sparse attention, we use PQCache at 2% density with Qwen3-4B-Instruct-2507 at 32K context. B0 is RULER-32K (7 tasks), and B1 and B2 are the adversarial benchmarks generated by the discriminator against Gen0 and Gen1.

AlgorithmB0 (RULER-32K, 7 tasks)B1B2
Full attention0.80760.850.95
Gen0 (PQCache)0.76810.350.80
Gen10.78790.600.50
Gen20.82000.850.85

Gen2 matches full attention on B1 and recovers B2 (0.50 → 0.85) at the same 2% density, while improving RULER-32K from 0.768 to 0.820, on par with full attention (0.808). As in the KV-compression setting, each new benchmark targets the latest generation.

Evaluation on independent "adversarial" benchmarks.

We perform this experiment in the KV compression setting. At the beginning, we generate multiple adversarial benchmark candidates and evaluate the candidates produced by Gen1 and Gen2 on these held-out adversarial benchmarks. In the table below, B1 and B2 are the adversarial benchmarks used in GAL rounds 1 and 2, respectively, while C1–C13 are adversarial candidates which were created at Base and that were never shown to the generator. As we can see, the improvements generally transfer to other held-out adversarial datasets.

AlgorithmB1B2C1C2C3C4C5C6C7C8C9C10C11C12C13
Base0.250.450.350.450.250.000.000.000.000.050.100.050.450.300.50
Gen10.850.250.350.350.050.100.000.050.100.100.100.050.651.001.00
Gen20.951.000.550.750.600.350.050.200.450.750.550.700.850.751.00

Note that, in practice, a generator may produce candidates that perform worse on unseen adversarial examples. However, in our experiments, the improvements generally transfer across the board to other held-out adversarial benchmarks.

The above new details along with those present in the paper addresses concerns raised by the reviewer. We answer those below.

  1. "Improvements on established benchmarks are mixed" "eval on broader set of standard benchmarks"

In the ideal GAL setting, established benchmarks are assumed to be saturated, making the discriminator the primary driver of further progress. Accordingly, we do not necessarily expect performance on standard benchmarks to improve. However, it is important to monitor these benchmarks to ensure that the observed gains reflect genuine progress rather than improvements arising from existing capabilities. The expanded evaluations on held-out standard benchmarks, presented above, demonstrate that the improvements are indeed new and generalize beyond the benchmarks used during the GAL iterations. In fact in some cases, we do see performance on standard benchmarks also improving.

  1. "How well do the evolved algorithms perform on held-out adversarial examples generated independently from those used during optimization"

As shown above, we generally observe improvements on held-out adversarial candidates. However, these improvements are not guaranteed to hold for every candidate outside the known adversarial universe; performance may occasionally stagnate or even regress. For example, C12 drops from 1.0 in Gen1 to 0.75 in Gen2. This is not unexpected. Nevertheless, the overall trend shows consistent improvements on average, suggesting that the gains generalize beyond the adversarial candidates encountered during GAL training, even if they do not transfer uniformly to every unseen candidate.

  1. "Only 2 GAL loops are shown."

We have extended to 5 loops for the two setups in the paper. The general cost of running GAL is dominated by evaluation cost. Since we want genuine improvements, we want the B0 to be representative and thus large. Evaluation cost for KV compression algorithm is shown below:

RunTotal timeDiscriminator timeDiscriminator search iterationsGenerator timeGenerator search iterations
1~2.4 h~1.7 h7~45 min8
2~23.2 h~5.3 h22~17.9 h62
3~18.0 h~10.3 h43~7.7 h46
4~20.6 h~1.9 h8~18.7 h31
5~5.7 h~1.2 h5~4.5 h9

Evaluating sparse video generation is particularly expensive, given the substantial time required to generate each video. This makes extensive, statistically significant evaluation across multiple GAL iterations challenging within our available academic compute budget. Nevertheless, we believe that the diversity and breadth of the experiments presented provide sufficient evidence to demonstrate the value and effectiveness of GALs.

  1. "Plain LLM Baseline / Coding Agent Baseline"

We already compare discriminator results with GEPA based evolution to Coding Agent based evolution in the paper. (Figure 6 left). We also compare with plain LLM generator under same model and cost budget below -

MethodMean best gapstd-dev
GEPA0.3550.229
Cursor agent0.2600.364
LLM-only (no evolution)0.1950.240

As we can see, the evolution approach used in Coding Agents and GEPA helps with getting to larger gaps with less cost

Comments on the paper

1 comment
AuthorsOpenReview ↗

Response to all reviewers - summary of additional experiments and rebuttal discussion

We thank all reviewers for their thoughtful feedback and constructive suggestions. The reviews highlighted opportunities to strengthen the empirical validation of GAL, particularly regarding generalization beyond in-loop adversarial benchmarks, the number of evolution rounds, preservation of standard benchmark performance, and the methodological novelty.

In response, we extended experiments to 5 GAL iterations for KV compression and context extension, evaluated evolved algorithms on independently generated adversarial examples and held-out standard benchmarks, and added a sparse attention setup. We also expanded baseline comparisons and clarified GAL's methodology, its distinction from prior work, and the role of the evolving discriminator in driving algorithm improvements.

These additional experiments and analyses are presented in the rebuttal and will be incorporated into the paper. We thank all reviewers for their constructive feedback, which helped strengthen the empirical evaluation, clarify the methodology, and better articulate GAL's contribution.

ConcernsRaised bySummary of response
Limited evolution rounds and evaluation coverageNBco, x79f, qKxbExtended KV compression and context extension experiments to 5 GAL iterations. Expanded held-out standard benchmark evaluations and increased KV compression evaluation from 20 to 50 examples per task.
Generalization to unseen adversarial benchmarksNBco, x79f, qKxbEvaluated evolved algorithms on independently generated adversarial examples (C1–C13), not encountered during evolution, to assess generalization beyond in-loop benchmarks.
Benchmark fluctuations and capability preservationNBco, qKxbClarified that B0 defines the performance requirements to preserve, while held-out benchmarks assess generalization. GAL targets newly discovered failure modes; it does not aim to monotonically improve every standard benchmark.
GAL methodology and evolution processx79f, qKxbClarified how the discriminator discovers adversarial benchmarks for the current algorithm and the generator evolves the algorithm against them, while preserving B0 performance.
Methodological noveltyNBco, qKxbClarified that GAL’s novelty lies in coupling adversarial benchmark generation with algorithm evolution, allowing newly discovered failure modes to drive successive improvements and enabling progress beyond fixed evaluation sets. Concurrent work on Hacker-Fixer Loops addresses evaluation hardening using iterative improvements.
Baseline comparisons and discriminator contributionNBco, qKxbAdded comparisons with GEPA, Cursor-agent-based search, and LLM-only benchmark generation without algorithm evolution. Explained why fixed-benchmark optimization cannot replace GAL's evolving discriminator, which continually discovers new weaknesses.
Discriminator effectiveness and search statisticsqKxbReported average best-gap and standard deviation across models and setups, results from 10 independent discriminator runs, and candidate counts across five rounds for KV compression and context extension.
Sparse attention evaluation (PQCache)x79fAdded a GAL evaluation using PQCache at 2% density with Qwen3-4B-Instruct-2507 at 32K context, covering B0 and adversarial benchmarks B1 and B2 over two GAL iterations. Also clarified the distinction between 2% and 5% density and the implications of evaluating at the more sparse 2% setting.
Sparse video generation evaluationx79f, qKxbExpanded evaluation to 725 search candidates and reported aggregate valid-failure rates and LPIPS/PSNR metrics across objectives, distinguishing genuine failures from cases where the dense output also fails.
Inference efficiencyx79fClarified that compression ratio and attention density do not directly establish inference speedups. Discussed latency, memory access, and FLOPs as possible optimization constraints, and explained that the current PyTorch implementation does not support meaningful efficiency measurements.
Cost accountingx79fClarified that the cost certificate measures LLM usage for discriminator-driven benchmark evolution, not the full cost of discriminator execution, including benchmark evaluation.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.