- Rating
- 3(+1)
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 3(+1)
Read review
Paper summary
This paper proposes CAP, an adaptive penalty method for handling constraints in LLM-guided evolutionary search. Rather than discarding infeasible programs, it retains them and adjusts penalty weights using their constraint violations and the best feasible solution found so far. Its practical implementation, CAP-Evolve, builds on AdaEvolve with violation normalization and relaxed penalty updates that encourage exploration early in search. The paper establishes convergence under idealized oracle assumptions and evaluates the method on four constrained optimization tasks, reporting the best mean performance in six of seven configurations.
Critical strengths
-
I think the paper addresses a meaningful problem with a clear and intuitive approach. The method uses the constraint violations of infeasible programs, together with the best feasible solution found so far, to adapt its penalty weights. I think another key strength is that the approach can be added to an existing evolutionary search system without requiring a major redesign.
-
I also appreciate the detail provided in the evaluation. Keeping the core experimental setup consistent makes the comparisons easier to interpret. The ablations and individual-run results are particularly helpful for judging which design choices matter and how consistent the improvements are.
Critical weaknesses
-
My main concern is the missing fixed-penalty baseline in the multi-constraint experiments, where CAP-Evolve shows some of its strongest results. I understand that tuning a separate weight for every constraint would be expensive. However, using one tuned scalar coefficient on the sum of the same normalized violations, , would only require a one-dimensional sweep. I think without this comparison, it is hard to tell how much the adaptive weights help compared with a simpler penalty using the same constraint information and normalization.
-
I am also not fully convinced that the reported gains over tuned fixed penalties are reliable across runs and parameter choices. In the single-constraint settings, several improvements are small compared with the reported standard deviations. For example, Circle Packing improves from to over five runs. CAP-Evolve also uses a task-specific , selected from , and it is unclear whether the reported evaluation runs were separate from those used to make this choice. Table H.2 suggests that the choice actually matters on Tokamak Control, and give mean errors of and , compared with for the fixed-penalty baseline. The fixed-penalty baseline is also tuned, so tuning itself is not unique to CAP-Evolve. Still, I would like to see how well the method works with a common default setting.
Questions for authors
-
Section 5.2 says that the methods share a task prompt and generation template. Could you clarify what changes in the instructions and feedback given to the LLM? In particular, do all methods show the model the raw objective and constraint violations? An example prompt for each method would help make the differences clear.
-
I noticed that violating an additional constraint can sometimes lead to a smaller penalty after normalization. For example, with the same objective value and weights of , violations of give a penalty of , while gives approximately . Is this intentional, and have you checked how it affects candidate selection in practice?
7 comments
Weakness 2
I am also not fully convinced that the reported gains over tuned fixed penalties are reliable across runs and parameter choices. In the single-constraint settings, several improvements are small compared with the reported standard deviations. For example, Circle Packing improves from (0.99598 \pm 0.00354) to (0.99647 \pm 0.00308) over five runs. CAP-Evolve also uses a task-specific (\alpha_0), selected from ({0.25,0.5,0.75}), and it is unclear whether the reported evaluation runs were separate from those used to make this choice. Table H.2 suggests that the choice actually matters on Tokamak Control, (\alpha_0=0.5) and (0.75) give mean errors of (0.06779) and (0.07170), compared with (0.06526) for the fixed-penalty baseline. The fixed-penalty baseline is also tuned, so tuning itself is not unique to CAP-Evolve. Still, I would like to see how well the method works with a common default setting.
Answer. Hard rejection is our primary comparison because it is the standard way existing LLM-ES systems handle feasibility. The main practical question is how much search improves when infeasible programs are retained and used to guide subsequent proposals. The tuned fixed-penalty comparison then asks whether adapting the penalty adds value when both methods can use those programs.
Circle Packing puts the gains in context. At , CAP-Evolve increases the mean radius sum by approximately over hard rejection and over the best tuned fixed penalty in the new sweep. On the same benchmark, AlphaEvolve reports improving the best radius sum from roughly to , and AdaEvolve reports a further best-construction gain of about . These published gains put the size of the improvement in perspective: the mean gain over hard rejection is substantial, and the gain over tuned fixed penalty is also appreciable on this benchmark. The comparison uses five independent runs per method, and CAP-Evolve also has a lower sample standard deviation than tuned fixed penalty ( versus in normalized score).
The two methods also differ in what tuning requires. CAP-Evolve searches three specified values of the initial relaxation fraction, . A fixed penalty has no prescribed search range: a useful coefficient depends on the relative magnitudes of objectives and violations. The best coefficients we found for Circle Packing and Trajectory Optimization were and , respectively. That two-order-of-magnitude difference shows why finding a useful range is itself part of tuning fixed penalty.
A default-to-default comparison therefore requires a cross-task fixed coefficient with no clear basis for choosing its scale. A single value could make the penalty too weak on one task and too strong on another. We instead use a common for CAP-Evolve in all three added settings and compare it with the best fixed coefficient found for each setting. The existing sensitivity results show how other choices affect CAP-Evolve, including the weaker Tokamak Control results at and .
For the configurations reported as tuned, we used the same runs to select and report both and fixed . The sensitivity analysis in the original submission and the fixed-penalty sweep above show how performance varies across the tested values. We have not independently estimated the effect of selection on the reported means.
Question 1
Section 5.2 says that the methods share a task prompt and generation template. Could you clarify what changes in the instructions and feedback given to the LLM? In particular, do all methods show the model the raw objective and constraint violations? An example prompt for each method would help make the differences clear.
Answer. The task description, evaluator-metric feedback format, and AdaEvolve generation template are shared. Method-specific instructions explain how constraints affect fitness and competition: hard rejection excludes infeasible candidates, fixed penalty uses fixed coefficients, and T–Y and CAP use their adaptive scores. The resulting scores guide the existing parent/context selection, so different methods can select different programs while exposing the same kinds of information.
The common structure is:
SYSTEM
Task description, program interface, constraints, and task guidance.
Method-specific constraint-handling instructions.
USER
# Current Solution Information
combined_score and evaluator metrics
# Program Generation History
previous attempts, where available
## Other Context Solutions
selected programs, scores, metric breakdowns, and code
# Current Solution
parent-selection context, parent metrics, and parent code
# Task
generation instructions and required edit format
For Circle Packing, objective quality is visible as sum_radii and target_ratio, the search score as combined_score, and constraint feedback as feasibility, geometric residuals, and violation-count summaries. The complete internal -component vector is used in constraint handling; prompt feedback displays its diagnostic summaries.
An actual CAP context entry illustrates how these information types are shown together, excerpted and line-broken for readability:
### Program 1 (combined_score: -2.5444)
Score breakdown:
sum_radii: 3.1768
target_ratio: 1.2056
constraint_satisfied: 0.0000
max_geometry_violation: 0.2500
boundary_violation: 0.2500
overlap_violation: -0.0000
violated_shape_count: 9.0000
[The candidate's Python source follows.]
The model can therefore distinguish a candidate's high objective from its infeasibility and penalized score. Hard rejection limits which candidates reach normal competition; both CAP and the new fixed control can retain infeasible programs through the same pipeline. The new comparison consequently tests adaptive calibration with this information access shared. Complete system and user prompts and further examples are available in the supplementary materials uploaded with the original submission.
Thank you for recognizing the motivation, modular integration, consistent evaluation setup, and individual-run reporting. We have completed 60 additional full runs for the normalized multi-constraint fixed scalar penalty you suggested. Below, we address the two main weaknesses and both questions.
Weakness 1
Answer. In the original K=1 experiments, the evaluator exposes the maximum of the underlying constraint residuals. The fixed penalty therefore already corresponds to an infinity-norm penalty, λ[maxkvk(x)]+=λ∥[v(x)]+∥∞, on the same underlying constraints.
We complemented this maximum-based baseline with the requested fixed scalar penalty on the sum of the same normalized violations used by CAP-Evolve:
=f(x)-\lambda \frac{\sum_{k=1}^{K}[v_k(x)]_+} {\sqrt{\max\{1,\#\{k:v_k(x)>0\}\}}}.$$ The initial program, evaluator, LLM, prompt/context pipeline, retention mechanism, and search budget match CAP-Evolve. Both methods thus have the same mechanisms for using infeasible candidates and constraint feedback. Holding these mechanisms and normalization consistent makes the comparison directly relevant to whether adaptive calibration adds value. We evaluated four coefficients in each setting, with five independent 100-iteration runs per coefficient, adding 60 full runs. CAP uses its existing $\alpha_0=0.5$ results throughout. Entries report search-stage best-feasible scores as mean $\pm$ sample standard deviation ($\mathrm{ddof}=1$). Higher is better. Circle scores are radius sums divided by $2.635$; trajectory scores are the normalized negative acceleration objective. | Method | Circle Packing $K=3$ | Circle Packing $K=26$ | | --- | ---: | ---: | | Fixed $\lambda=1$ | $0.995859 \pm 0.002017$ | $0.990698 \pm 0.009762$ | | Fixed $\lambda=10$ | $0.995669 \pm 0.002539$ | $0.991590 \pm 0.008532$ | | Fixed $\lambda=100$ | $0.996997 \pm 0.003953$ | $0.996297 \pm 0.003786$ | | Fixed $\lambda=1000$ | $0.996729 \pm 0.002429$ | $0.993480 \pm 0.005734$ | | CAP-Evolve, $\alpha_0=0.5$ | $0.995615 \pm 0.00451$ | $0.998478 \pm 0.00090$ | | Method | Trajectory Optimization $K=5$ | | --- | ---: | | Fixed $\lambda=100$ | $-1.359549 \pm 0.001207$ | | Fixed $\lambda=1000$ | $-1.357929 \pm 0.003890$ | | Fixed $\lambda=10000$ | $-1.356539 \pm 0.006375$ | | Fixed $\lambda=100000$ | $-1.360670 \pm 0.000227$ | | CAP-Evolve, $\alpha_0=0.5$ | $-1.354939 \pm 0.00583$ | The new control sharpens the empirical conclusion. CAP improves the mean over the best scanned fixed coefficient by $0.002181$ at Circle $K=26$, with substantially lower observed variability, and by $0.001600$ at Trajectory $K=5$. Circle $K=3$ favors fixed penalty by approximately $0.001382$. Adaptive calibration is therefore useful in the high-dimensional Circle representation and yields a smaller trajectory improvement, while a tuned fixed scalar works better in the lower-dimensional Circle setting.