acceptodds
Under review as a conference paper at ICLR 2027

NextEval: An Agent-Based Solver and Benchmark for Derivative-Free Optimization

Abstract

Derivative-free optimization (DFO) addresses problems where derivatives are unavailable or costly to obtain. This setting often arises in simulation-based and experimental applications, where evaluating their black-box objective can itself be costly. Thus, it remains a central challenge in DFO to effectively exploit accumulated observations to select informative evaluation points under a limited budget. In this light, we introduce the NextEval solver, an agent-based DFO solver, which integrates the capabilities of the large language model (LLM) to guide the sequential selection of evaluation points. Specifically, we establish a system which combines an LLM agent with a numerical environment. The environment provides tools for analyzing past evaluations and executing numerical methods, while maintaining a shared evaluation history and method-specific state to support continuation across method switches. Using observations and tool feedback, the LLM agent selects tools, configures their parameters, and allocates the evaluation budget, while numerical methods compute and evaluate candidate points. Building on this system, we also introduce NextEval Bench, a benchmark protocol for comparing agent configurations on shared DFO tasks using the same numerical tools under matched evaluation budgets and information constraints. Numerical results on low-dimensional DFO problems demonstrate that the NextEval solver outperforms the state-of-the-art DFO baselines in function-evaluation efficiency.

Primary area:
optimization
Keywords:
derivative-free optimization, black-box optimization, large language models, agentic systems, benchmarking

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_mzDTOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

NextEval is an agent-controlled derivative-free optimization system. An LLM selects numerical tools, parameters, and evaluation allocations, while numerical software computes candidate points and maintains a shared evaluation history and method-specific continuation state. The agent receives oracle observations rather than the objective formula or benchmark identity. The paper also proposes a common environment for comparing LLM–harness configurations. Experiments use 92 unconstrained problems with at most five variables and a budget of 50n objective evaluations. The primary rotated, noiseless comparison uses ten repetitions and reports the highest normalized evaluation-efficiency score against COBYQA, NEWUOA, Powell, and finite-difference BFGS.

Critical strengths
  • The division between strategic control and numerical computation is sensible and reusable. The LLM decides which operations to perform, while numerical methods handle interpolation, trust-region steps, line search, and candidate evaluation. Maintaining method-specific state across switches is an important implementation detail: the system can combine methods without discarding all previous numerical work. This is a more substantive design than asking an LLM to produce numerical evaluation points directly.
Critical weaknesses
  • The key comparison needed to establish the value of the LLM controller has not been completed. The system combines an LLM with a substantial numerical toolset, shared history, continuation state, and restart capabilities. Comparison with standalone solvers cannot distinguish the contribution of agent decisions from these additional numerical capabilities. A deterministic controller or fixed strategy using the same environment would directly address this issue. Appendix E explicitly lists controller-replacement and numerical-support ablations as planned tests, not results, leaving the central mechanism insufficiently isolated.
  • The evidence is narrow relative to the broader promise of an optimization solver. All primary problems are public and have at most five variables, and there is no demonstrated generalization to unseen problem families. Rotations and perturbed starts do not resolve that concern. Moreover, performance is assessed through objective-evaluation counts rather than total runtime or LLM cost. The results therefore support a low-dimensional benchmark advantage, but leave both out-of-family robustness and the practical trade-off between saved objective calls and agent overhead unresolved.
Questions for authors
  • The reported improvements are obtained by the complete system, which combines an LLM controller with multiple numerical optimization tools, shared evaluation history, and persistent method states. Could the authors compare NextEval against a deterministic or heuristic controller with access to exactly the same numerical tools and information? Without this comparison, it is difficult to determine whether the improvements arise from LLM-based decision making or from the underlying numerical infrastructure.
  • The experiments compare NextEval against standalone classical DFO solvers. Could the authors include stronger adaptive numerical baselines, such as algorithm portfolios, restart strategies, or automated method-selection policies? These would provide a more direct comparison with NextEval's ability to switch between numerical methods.
  • All 92 benchmark problems are public, low-dimensional test functions, and the paper acknowledges that development feedback informed the tools and prompts. Could the authors evaluate NextEval on previously unseen problem families or independently constructed black-box optimization tasks? This would help establish whether the reported improvements generalize beyond the development benchmark.
  • The experiments are restricted to problems with at most five decision variables. How does NextEval perform on moderately higher-dimensional problems (e.g., 10, 20, or 50 variables)? Since the numerical methods and the effectiveness of their combinations can change substantially with dimension, it is unclear whether the current results extend beyond very small problems.
6 comments
AuthorsOpenReview ↗

Response to Reviewer mzDT (Part 1/2)

Response to Reviewer mzDT (Part 1/2)

Thank you for four concrete questions; each now has an experimental answer, in part for Q3 and Q4.

Your pointWhat we didWhere
W1, Q1 Deterministic controller with the same tools and informationTextbook policy in the same decision space, head-to-head; random and trust-region-only controllers; same model without the environment§2.4, §4.4, Tables 1a, 1b, 15, App. D
Strength LLM does not produce evaluation points directlyChanged in Solver 1.0: the agent may also evaluate points of its own; their share is reported (Part 2)§2.4, Table 19, App. E, App. I
Q2 Portfolios, restarts, method selection12 model-free baselines, among them restarts, two portfolios, and NGOpt; against COBYQA and head-to-head§4.2, §4.4, Tables 1b, 16–17
Q3, W2 Unseen familiesAn n = 20 pool never used in development (six of its eight families occur at smaller n); independent tasks not yet (planned)§4.4, App. D, §6
Q4 n = 10, 20, 50Pools with n = 6–10, 15, and 20; n = 50 not yet§4.4, Tables 1, 12
W2 Runtime and LLM costCost, tokens, and time per case; cost–score front§4.4, Tables 12–13, Figs. 4a, 10

Verdicts (§4.1): two-level 90% intervals, margin δ = 0.025; S+ superior beyond the margin, S superior, E equivalent, ? inconclusive.

W1 / Q1. Deterministic controller with exactly the same tools and information. Done: the LLM and a deterministic textbook controller (the textbook autopilot, §2.4) act in the same decision space, and their head-to-head comparison was fixed before the corresponding model calls (§4.4). The textbook policy runs trust-region slices with library and textbook defaults and resets after a stall. Every call it makes passes the agent's schema, so it has no tool or information that the agent lacks (App. D). Head-to-head, three repetitions (Table 1a):

BenchDev. 2–5Dev. 6–10n = 15 †n = 20
Luna0.506 [0.487, 0.526] ?0.503 [0.468, 0.542] ?0.575 [0.551, 0.600] S+0.623 S+0.565 [0.477, 0.634] ?
Sol (medium)0.681 [0.659, 0.708] S+0.682 [0.647, 0.728] S+0.735 [0.714, 0.760] S+0.781 S+0.682 [0.624, 0.735] S+
Sol (high)0.711 [0.689, 0.738] S+0.706 [0.673, 0.751] S+0.764 [0.744, 0.791] S+0.798 S+0.701 [0.644, 0.761] S+

† Most optima at the origin, which Sol evaluates itself; not used as evidence (Part 2).

  • Without the problems in which the agent evaluated a simple point, the pre-specified primary comparison (Luna, n = 6–10) is unchanged (0.573) and Sol stays S+ on the Bench, both development pools, and n = 20 (0.649–0.768; Table 11).
  • Simpler controllers in the same space (Table 15): a random controller that mixes all seven campaigns and nine single-step actions is below COBYQA on every pool (0.245–0.442); a trust-region-only controller is equivalent to or inconclusive against the textbook policy (0.488–0.517). Both Sol settings are S+ against all three fixed policies on all five pools (0.681–0.841; n = 15 with the origin caveat).
  • Reduced numerical support, the second test planned in App. E of the submission, is the native agent (same model, only a budgeted evaluation interface and its own code). Against COBYQA on the Bench: Luna 0.394 without the environment, 0.602 with it; Sol 0.690 / 0.726 without, 0.719 / 0.738 with, intervals overlapping (Table 1b; execution settings: Part 2).

Q2. Stronger adaptive baselines. Added, each in a fixed configuration (App. F): restarted COBYQA and NEWUOA; COBYQA with a noise-aware final radius and restarts; Py-BOBYQA with noise handling and restarts; sequential and interleaved COBYQA–NEWUOA portfolios; NGOpt (automated algorithm selection); IPOP-CMA-ES; NOMAD; GP-EI; default Py-BOBYQA. With default NEWUOA from the submission, there are 12.

  • Head-to-head (Table 17): both Sol settings are S+ against all 12 on the Bench and both development pools. At n = 20, Sol (high) is superior to all 12 and Sol (medium) to 11 (inconclusive against the sequential portfolio, 0.593). Luna is never inferior; it is superior to 11, 11, 8, and 7 of the 12 on the four pools and inconclusive against the rest, among them the strongest restarted local solvers (0.467 against Py-BOBYQA with noise handling on the Bench).
  • Against COBYQA (Table 1b): the best baseline scores 0.607, 0.657, 0.577, and 0.557 on the Bench, Dev. 2–5, Dev. 6–10, and n = 20; Sol scores 0.719–0.754 at n ≤ 10 and 0.618–0.671 at n = 20 (inconclusive at n = 20 without simple-point problems; Table 11).
  • The textbook policy is a reference over the solver's own actions, not the strongest model-free method: at n ≥ 6 restarted local solvers are superior to it, among them COBYQA with restarts (0.547, 0.603, 0.599) and the sequential portfolio at n = 20 (0.629), and so is Py-BOBYQA with noise handling on Dev. 2–5 (0.579).
AuthorsOpenReview ↗

Response to Reviewer mzDT (Part 2/2)

Response to Reviewer mzDT (Part 2/2)

Q3 / W2. Unseen families or independently constructed tasks. Partly. Independently constructed tasks are not in this revision; they are a main extension of the next Bench version (§6). We agree that rotations and perturbed starts do not settle the concern: they reduce but do not exclude problem recognition (§6). The evidence we have now (§4.4; App. D):

  • n = 20, never used in development (8 problems, defined by a rule written before any run on it). Sol is S+ against the textbook policy (0.682, 0.701), also without simple-point problems (0.649, 0.685; four or five problems remain). Case by case, Sol (high) beats the textbook policy in 49 of the 96 cases and loses 6; Sol (medium) wins 43 and loses 9 (App. E). Six of its eight families also occur at smaller n in the Bench or Dev. 2–5 (§6).
  • n = 15, never used in development (18 problems). Sixteen are DIXMAAN variants with optimum at the origin, which Sol evaluates itself in 77% and 86% of the cases, so we do not use this pool as evidence of generalization.
  • Development pools share no problem with the Bench but were used in earlier development, so we do not call them held out.

Q4. Moderately higher dimensions (10, 20, 50). Up to n = 20 (§4.4, Tables 1a, 11): against the textbook policy, Sol (high) scores 0.711 on the Bench, 0.764 at n = 6–10, and 0.701 at n = 20, all S+, also without simple-point problems (0.718, 0.768, 0.685). Luna moves from inconclusive at n ≤ 5 to S+ at n = 6–10 (0.575). The textbook policy itself falls against COBYQA from 0.598 to 0.442 at n = 20. We have not run n = 50. At n = 20 a case already uses 2,012k (Sol medium) and 2,624k (Sol high) tokens on average (Table 12); larger dimensions are a main extension of the next Bench version (§6).

W2. Runtime and LLM cost. Evaluation counts remain the score, as is standard when evaluations are expensive; cost and time are now reported (§4.4; Tables 12–13; Fig. 4a; list prices of 2026-11-04).

  • Bench, per case: USD 0.011 and 104 s (Luna), 0.121 and 116 s (Sol medium), 0.186 and 199 s (Sol high). At n = 6–10: USD 0.029, 0.250, and 0.391; at n = 20: USD 0.069, 0.377, and 0.498. The textbook policy alone has no model cost and takes 1.0 to 21.5 s.
  • Solver 1.0 with Sol (high) costs about twice the best native agent (USD 0.186 vs. 0.099), and their scores against COBYQA have overlapping intervals (0.738 vs. 0.726). Solver 1.0 with Luna reaches 0.602 at USD 0.011; both join the cost–score front of the native agents (Fig. 4a).
  • Solver sessions ran as processes on a shared host, native agents in per-case containers (1 CPU, 2 GiB), so the times describe each setting and are not a matched comparison (App. D).

LLM control is meant for objectives whose evaluations are costly, where cents and minutes per problem are small against one evaluation.

On the strength you noted (the LLM does not produce evaluation points directly). Solver 1.0 differs from the submission here: numerical methods still compute most points, but the agent can now also evaluate points of its own, stated explicitly or returned by analysis code that it writes (§2.4, App. I). These are 20.9–35.1% of the evaluations of Sol outside n = 15 and 0.8–1.6% of those of Luna (Table 19). The comparison measures the LLM policy over the whole decision space; it does not separate the campaigns from these points (App. E). With Luna, which hardly uses them (1.3% at n = 6–10), the LLM policy is still S+ there (0.575).

Thank you for the substantial additional experiments.

Two key issues remain. First, Solver 1.0 now allows autonomous point generation, so the gains do not isolate the benefit of numerical-method orchestration. A strong-model ablation disabling autonomous point generation would help clarify this. Second, six of the eight 20-dimensional families overlap with earlier pools, leaving limited evidence of generalization to genuinely unseen objective structures. Separate results for the two non-overlapping families would be informative.

I appreciate the progress, but these remaining limitations leave me unconvinced that the evidence sufficiently supports the central contribution and generality claims. I therefore maintain my rating of 2.

Reviewer_kZTVOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces NextEval, an agent-based framework for derivative-free optimization that combines an LLM agent with a numerical environment. The agent uses evaluation histories and tool feedback to select numerical methods, configure their parameters, and allocate the objective-evaluation budget, while numerical tools compute and evaluate candidate points. The environment maintains a shared evaluation history and method-specific state to support continuation across method switches. The authors also introduce NextEval Bench, a protocol for comparing LLM–harness configurations under matched tasks, numerical tools, evaluation budgets, and information constraints. Experiments on 92 unconstrained problems with at most five variables show improved function-evaluation efficiency over the tested classical baselines in the primary rotated comparison. Additional experiments examine the effects of model choice, reasoning settings, and execution harnesses.

Critical strengths

NextEval gives the LLM a well-defined role in selecting numerical tools, adjusting parameters, and allocating evaluation budgets. The shared evaluation history and method-specific continuation state allow information and numerical work to be reused across method switches. This is a substantive system-design strength because it makes adaptive method composition practical while keeping candidate computation within established numerical routines.

Critical weaknesses
  1. The contribution of LLM-based control is not adequately isolated. The main comparison evaluates the complete NextEval system against standalone solvers, so the observed gains may arise from numerical tools, method composition, shared history, or state reuse, as well as agent decisions. Crucial controls using the same numerical environment are explicitly left as planned experiments in Appendix E. Consequently, the results establish the effectiveness of the combined system but do not sufficiently demonstrate the added value of its central LLM-based control mechanism.
  2. Generalization beyond the development setting remains insufficiently validated. The evaluation is restricted to public problems with at most five variables, and the authors acknowledge that development feedback informed the tools, manuals, and prompts. No independent held-out problem families or higher-dimensional evaluations are provided. Although perturbed starts, noise, and coordinate rotations introduce useful variation, they do not establish generalization to unfamiliar objective structures. This limits the evidence supporting NextEval as a broadly useful optimization solver and benchmark, beyond the particular low-dimensional suite studied.
Questions for authors

The details are shown in the critical weakness part.

4 comments
AuthorsOpenReview ↗

Response to Reviewer kZTV (Part 1/2)

Response to Reviewer kZTV (Part 1/2)

Thank you for a precise review. We agree that comparing the full system with standalone solvers did not isolate the LLM's contribution. The revision isolates it by design: the LLM and a textbook policy (the textbook autopilot, §2.4) act in the same decision space, and the comparisons were fixed before the corresponding model calls.

Your pointWhat we didWhere
W1 Gains may come from tools, composition, shared history, or state reuseLLM vs. textbook policy through the same campaigns, parameters, state reads, and ledger, on five pools§2.4, §4.4, Table 1a, App. D
W1 Controls left as planned in App. E of the submissionReported: controller replaced (textbook, random, trust region only); model without the environment; 12 baselines§4.4, Tables 1b, 15–17
W2 Public problems; development feedbackData use per component; two pools never used in development; simple-point exclusion§2.4, §4.4, Tables 6, 11
W2 No held-out families or higher nPools with n = 6–10, 15, and 20; family overlap stated§4.4, App. D, §6

Verdicts (§4.1): two-level 90% intervals, margin δ = 0.025; S+ superior beyond the margin, S superior, E equivalent, ? inconclusive.

W1. Isolating LLM control. Every call of the textbook policy passes the agent's schema, so it can do nothing the agent cannot; the numerical tools, shared history, and method states are the same for both. Their head-to-head score therefore measures the policy (Table 1a):

BenchDev. 2–5Dev. 6–10n = 15 †n = 20
Luna0.506 ?0.503 ?0.575 S+0.623 S+0.565 ?
Sol (medium)0.681 S+0.682 S+0.735 S+0.781 S+0.682 S+
Sol (high)0.711 S+0.706 S+0.764 S+0.798 S+0.701 S+

† Not used as held-out evidence (optima at the origin; Part 2).

  • The tools need a policy. A random controller that mixes all seven campaigns and nine single-step actions is below COBYQA on every pool (0.245–0.442). A trust-region-only controller is equivalent to or inconclusive against the textbook policy (0.488–0.517). Both Sol settings are S+ against all three fixed policies on all five pools (0.681–0.841; Table 15; n = 15 with the origin caveat).
  • The reference on clean problems. On the noise-free features P and R, the textbook policy scores 0.508 against COBYQA on the Bench (both intervals contain 0.5), while Sol (high) scores 0.681 and 0.666 (App. D.1). The textbook policy is not the strongest model-free method: at n ≥ 6 restarted local solvers are superior to it, and at n = 6–10 Luna is inconclusive against four baselines (0.502–0.536); both Sol settings are S+ against all 12 baselines at n ≤ 10 (App. F, Table 17).
  • Shared history and state reuse. Both policies use them, so they are held fixed. We make no claim that they improve performance by themselves; they let the fallback and the agent's analysis code work on one episode.
  • What the policy includes. Numerical routines compute most points. Unlike in the submission, the agent of Solver 1.0 can also evaluate points of its own, stated explicitly or returned by analysis code that it writes (App. I): 20.9–35.1% of the evaluations of Sol outside n = 15, and 0.8–1.6% of those of Luna (Table 19). We do not separate, within the LLM policy, the campaigns from these points (App. E). With Luna, which hardly uses them (1.3% at n = 6–10), the LLM policy is still S+ there (0.575).
  • Robustness. Without the problems in which the agent evaluated a simple point, the primary comparison (Luna, n = 6–10) is unchanged (0.573 [0.551, 0.604]) and Sol stays S+ on the Bench, both development pools, and n = 20 (0.649–0.768; Table 11). Holm correction (α = 0.10) over the 30 comparisons with the textbook policy and COBYQA keeps 6 of 10 for Luna and all 10 for each Sol setting (§4.4).
  • Same model without the environment (score against COBYQA, Table 1b). Luna: Solver 1.0 0.602, native agent 0.394 on the Bench. Sol: 0.719 and 0.738 against 0.690 and 0.726; the two scores of each pair have overlapping intervals. Solver sessions ran as processes on a shared host, not in the per-case containers of the leaderboard, and their analysis code could not import SciPy, which native agents could (App. D).

Our claim (abstract, §4.4, §7) is accordingly specific: with a strong LLM, the agent outperforms a textbook policy over the same actions on every pool we use as evidence; with the low-cost Luna it does so at n = 6–10.

AuthorsOpenReview ↗

Response to Reviewer kZTV (Part 2/2)

Response to Reviewer kZTV (Part 2/2)

W2. Generalization beyond the development setting. We agree that public problems up to n = 5 and perturbations alone do not establish generalization. The revision adds the following (§4.4; App. D).

  • n = 20, never used in development (8 problems; pool defined by a rule written before any run on it). Sol is S+ against the textbook policy (0.682, 0.701), also without simple-point problems (0.649 [0.538, 0.730], 0.685 [0.594, 0.761]; four or five problems remain). Case by case, Sol (high) beats the textbook policy in 49 of the 96 cases and loses 6; Sol (medium) wins 43 and loses 9 (App. E). Luna is inconclusive (0.565). Six of the eight families also occur at smaller n in the Bench or Dev. 2–5, as §6 states.
  • n = 15, never used in development (18 problems). Sixteen are DIXMAAN variants with optimum at the origin, and Sol evaluates the origin itself in 77% and 86% of the cases, so we do not use these scores as held-out evidence. The next Bench version will shift optima randomly.
  • Development pools. Dev. 2–5 (26 problems) and Dev. 6–10 (88 problems) share no problem with the Bench, but earlier development used them, so we do not call them held out. Dev. 6–10 carries the pre-specified primary comparison: Luna 0.575 [0.551, 0.600].

Development feedback. Table 6 lists, per component, which pools informed it. Numerical defaults (initial radius, interpolation points, stall limit) are library and textbook values fixed before any run. Tool implementations and manuals come from earlier development with feedback from Bench instances and the development pools. The Solver 1.0 prompt was checked once on the first repetition of Dev. 2–5 against criteria written in advance; none was met, so no wording changed (App. D). All measurements use code fixed before the runs.

Problem recognition. Perturbations reduce but do not exclude recognition (§6), so we measured one route directly: the agent's own evaluations of the origin, the all-ones point, and the rounded start. Outside n = 15, Sol does this in 12.4–31.2% of the cases and Luna in 1.0–4.5% (Table 12). Removing those problems leaves every assessable verdict of Sol against the textbook policy unchanged. Some verdicts against COBYQA change; for example, both Sol settings become inconclusive against COBYQA at n = 20 (Table 11 lists all).

Higher dimensions. DFO practice is mostly small to moderate dimension (Conn et al., 2009, Section 1.3: "a few tens of variables"; median 7 in the Moré & Wild set; App. A), so we added n = 6–10, 15, and 20. The textbook policy itself falls against COBYQA from 0.598 on the Bench to 0.442 at n = 20, while the LLM's advantage is larger at n = 6–10 than at n ≤ 5 for every model. Larger n and independently constructed tasks are the main extensions of the next version (§6).

Thank you for your response. I have raised my score, but I do not think the paper merits a score of 3 yet.

AuthorsOpenReview ↗

Response to Reviewer kZTV

Thank you for reconsidering and raising your score. Your two concerns coincide with the follow-up of Reviewer mzDT, and we have just posted new results in our response there:

  1. Isolating LLM control. With autonomous point generation disabled, so that the agent only orchestrates the same numerical methods, Sol (medium and high) is superior beyond the margin to the fixed textbook policy in the same environment on Dev. 6–10 (Sol medium 0.591 [0.568, 0.616], the pre-specified primary comparison) and at n = 15. At n = 20 it is superior without correction but not significant after Holm correction; at n <= 5 it is equivalent or inconclusive.

  2. Held-out structure and dimension. On the two 20-dimensional families that occur in no earlier pool, the full solver with Sol scores 0.639 and 0.624 (CYCLOOCFLS) and 0.623 and 0.662 (VAREIGVL) against the textbook policy; each family is one problem with 12 cases. The n = 15 and n = 20 pools were never used in development.

If a specific concern still stands between the paper and a score of 3, we would be grateful to know it, so that we can address it before the discussion closes.

Reviewer_TqATOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes an agent-based solver for derivative-free optimization. An LLM agent controls an existing numerical environment by selecting methods, setting parameters, and allocating evaluation budgets. The environment executes evaluations and retains method state. The paper also introduces NextEval Bench to compare LLM–harness configurations on matched optimization tasks. Experimental results show that NextEval outperforms baselines on low-dimension problems.

Critical strengths
  1. This work does not use LLMs to generate candidate solutions or optimization algorithm codes, and instead treats the agent as a controller of numerical methods, which broadens the design space for LLM-assisted optimization.

  2. NextEval Bench formalizes tasks, shared budgets, records, and suite-level profiles, contributing for a field that currently lacks standardized agent-level evaluation.

Critical weaknesses
  1. Using LLM agents to select or generate optimization methods to solve black-box optimization problems is not a new idea. The contribution of the work is relatively weak.

  2. The experiment is conducted on low-dimensional problems, the optimization performance and generalization ability across problem dimensions and distributions of NextEval is not comprehensively evaluated.

  3. The baseline set only includes classical DFO solvers, LLM-based black-box optimization methods are not included for comparison.

  4. NextEval needs to frequent interaction with LLMs, it may bring higher computational and runtime overhead.

Questions for authors
  1. For the ablation study, could NextEval dominate random decisions (e.g., randomly select tools and corresponding parameters) or fixed search tool methods (e.g., only use trust-region campaign without LLM intervention).

  2. Will NextEval higher large runtime overhead?

4 comments
AuthorsOpenReview ↗

Response to Reviewer TqAT (Part 1/2)

Response to Reviewer TqAT (Part 1/2)

Thank you. The revision adds the two controls you asked for (random decisions; trust region only) next to a textbook policy (the textbook autopilot, §2.4) that acts in the same decision space as the LLM. All compared conditions were fixed before the corresponding runs.

Your pointWhat we didWhere
Q1 Random / trust-region-onlyBoth controls, model-free, in the same decision space§4.4, Table 15
W1 NoveltyNovelty stated; one decision space shared by the LLM and a fixed policy; controlled evidence§1, §2.4, Fig. 2, §5
Strength 1 No LLM-generated candidates or codeChanged in Solver 1.0: the agent may also evaluate points of its own; their share is reported§2.4, Table 19, App. E, App. I
W2 Dimensions, distributionsFour further pools up to n = 20; four features on every pool§4.4, Table 1, App. D–E
W3 LLM-based baselines45 native LLM agents that may propose points and run their own code; the same model with and without the environment§3, §4.3, §4.4, Tables 1b, 3
W4, Q2 OverheadCost, tokens, and time per case; cost–score front§4.4, Tables 12–13, Figs. 4a, 10

Verdicts (§4.1): two-level 90% intervals, margin δ = 0.025; S+ superior beyond the margin, S superior, E equivalent, ? inconclusive.

Q1. Can NextEval dominate random decisions or a fixed trust-region method? Yes with GPT-6.1 Sol on all five pools. With GPT-5.6 Luna, yes against random decisions on all five pools, and against trust region only at n = 6–10 and n = 15 (Table 15; n = 15 with the origin caveat of §4.4).

  • Random controller (campaigns and single-step actions chosen uniformly, parameters drawn from the tool schemas; no explicit points or analysis code): below COBYQA on every pool (0.245–0.442). Sol scores 0.772–0.841 against it and Luna 0.671–0.794, all S+ (n = 15 with the same caveat).
  • Trust region only (manual defaults, restarts): equivalent to the textbook policy on the Bench and Dev. 6–10 (0.503, 0.499) and inconclusive elsewhere, since the textbook policy is itself a restarted trust region. Sol scores 0.681–0.798 against it, S+ on every pool (n = 15 with the same caveat). Luna scores 0.568 and 0.628 at n = 6–10 and n = 15 (S+; n = 15 with the same caveat) and is inconclusive elsewhere (0.508–0.565).
  • Textbook policy (Table 1a): Sol is S+ on the Bench, both development pools, and n = 20 (0.681–0.764); Luna is S+ at n = 6–10 (0.575).

W1. Novelty. The solver idea is new. Within one solve, a general-purpose LLM agent selects among several implemented numerical methods, sets their parameters, continues or switches them while the environment keeps the state of each method, and allocates the budget (it may also evaluate points of its own; see below). To our knowledge, no earlier DFO solver gives an LLM agent this role (§1). Earlier work differs (§5, App. H): OPRO, EvoLLM, and LLAMBO use the LLM mainly to propose candidates or surrogate quantities; FunSearch and ReEvo search for programs across tasks; Code-to-Harness fixes a text strategy before the solve; multi-agent BO lets an LLM agent weight the search criteria of one BO method; algorithm configuration and selection learn their policies across instances, whereas NextEval uses a general-purpose LLM without optimization-specific training. The revision adds what makes the idea testable:

  1. a textbook policy in the same decision space, a fixed policy of the algorithm-configuration kind, so that the contribution of the LLM is measured directly (§2.4, Fig. 2);
  2. controlled evidence across model capability and dimension (§4.4);
  3. for the benchmark protocol, an evidence rule (one selected attempt per case, never chosen by objective value) and a pair score that other participants cannot change (§3, §4.1).

On your Strength 1. You welcomed that the LLM does not generate candidate solutions or algorithm code. Solver 1.0 differs from the submission here: numerical methods still compute most points, but the agent can now also evaluate points of its own, stated explicitly or returned by analysis code that it writes (§2.4, App. I). These are 20.9–35.1% of the evaluations of Sol outside n = 15 and 0.8–1.6% of those of Luna (Table 19; App. E). The comparison measures the LLM policy over the whole decision space; it does not separate the campaigns from these points (App. E). With Luna, which hardly uses them (1.3% at n = 6–10), the LLM policy is still S+ there (0.575).

AuthorsOpenReview ↗

Response to Reviewer TqAT (Part 2/2)

Response to Reviewer TqAT (Part 2/2)

W2. Dimensions and distributions. The solver is now evaluated up to n = 20. Bench 1.0 keeps n ≤ 5 so that 45 configurations × 1,104 sessions are affordable; tokens per case grow with n (Solver 1.0 with Luna: 247k on the Bench, 2.24M at n = 20). We therefore evaluated the solver on four further pools (§4.4; Table 1a, score against the textbook policy):

BenchDev. 2–5Dev. 6–10n = 15 †n = 20
Luna0.506 ?0.503 ?0.575 S+0.623 S+0.565 ?
Sol (high)0.711 S+0.706 S+0.764 S+0.798 S+0.701 S+

† 16 of the 18 problems have their optimum at the origin, which Sol evaluates itself in most cases; we do not use this pool as held-out evidence.

  • The n = 20 pool (8 problems) was never used in development; six of its eight families occur at smaller n in the Bench or Dev. 2–5 (§6). Sol stays S+ there without simple-point problems (0.649, 0.685; four or five problems remain). Case by case, Sol (high) beats the textbook policy in 49 of the 96 cases and loses 6 (App. E).
  • For every model the advantage is larger at n = 6–10 than at n ≤ 5, while the textbook policy itself falls against COBYQA from 0.598 (Bench) to 0.442 (n = 20).
  • Every pool has four features: perturbed start, noise, rotation, and random NaN failures. For Sol, the score against the textbook policy exceeds 0.63 on every feature of every pool.

Larger n is a main extension of the next Bench version, which will also shift optima randomly (§6).

W3. LLM-based black-box baselines. Added in the form of LLM agents; we did not run OPRO, EvoLLM, or LLAMBO themselves. The leaderboard runs 45 native LLM agents under one protocol. Each observes every evaluation, may propose points directly, and may write and run code with numerical libraries (§3), so it can follow a propose-and-evaluate strategy such as OPRO's and can do more. As on the leaderboard, every configuration is scored against COBYQA (§4.3, Table 1b):

  • Luna: native agent 0.394, Solver 1.0 0.602 on the Bench; on the one repetition the native agent ran at n = 6–10 and n = 20, 0.284 vs 0.568 and 0.283 vs 0.452.
  • Sol: native agents 0.690 (medium) and 0.726 (high), Solver 1.0 0.719 and 0.738 on the Bench; the two scores of each pair have overlapping intervals.

Instances, budgets, scoring code, and evidence rules are the same for both; Solver sessions ran as processes on a shared host, not in the per-case containers of the leaderboard, and their analysis code could not import SciPy, while native agents could use every installed package (App. D).

W4 / Q2. Overhead. LLM control adds cents and minutes per case. Per case on the Bench at list prices (§4.4, Table 13):

Cost (USD)TimeTokens
Textbook policy alone01.0 s0
Solver 1.0 + Luna0.011104 s247k
Solver 1.0 + Sol (medium)0.121116 s368k
Solver 1.0 + Sol (high)0.186199 s586k

At n = 20 a case costs USD 0.069 to 0.498 (Table 12). Cents and minutes per problem are small when one evaluation is an expensive simulation, the setting DFO targets. Where they are not, the results show what to choose: with Luna at n ≤ 5 the LLM policy is not superior to the textbook policy, so the textbook policy, which has no model cost, is the economical choice there.

Thanks for your response and additional experimental results. I have raised my score.

AuthorsOpenReview ↗

Response to Reviewer TqAT

Thank you for reading our responses and for raising your score. Your questions on random and trust-region-only controls, higher dimensions, and runtime overhead shaped the revised evaluation.

Comments on the paper

4 comments
AuthorsOpenReview ↗

General response to all reviewers and the AC

General response to all reviewers and the AC

We thank the reviewers. The three reviews ask two questions: does LLM control add value beyond the numerical environment, and does the evidence reach beyond small public problems? The revision answers both with new experiments.

1. The policy is separated from the environment. In NextEval Solver 1.0 the LLM and a textbook-default policy (the textbook autopilot) act through the same decision space (method campaigns with explicit parameters, explicit points, the agent's analysis code, and finalize) on one evaluation ledger, so their head-to-head score measures the policy (§2.4, Fig. 2). The compared conditions were fixed before the corresponding model calls. GPT-6.1 Sol is superior beyond the margin on the Bench, both development pools, and an n = 20 pool never used in development (0.681–0.764; Table 1a), also without the problems in which it evaluated simple points. The low-cost GPT-5.6 Luna is superior beyond the margin at n = 6–10 (0.575) and inconclusive at n ≤ 5 and n = 20.

2. What the agent decides, and what is new. Numerical methods compute most points. Unlike in the submission, the agent of Solver 1.0 can also evaluate points of its own, stated explicitly or returned by analysis code that it writes (§2.4, App. I). Their share is 20.9–35.1% of the evaluations of Sol outside n = 15, and 0.8–1.6% of those of Luna (Table 19; App. E). The comparison measures the LLM policy over this whole decision space. With Luna, which hardly uses them (1.3% at n = 6–10), the LLM policy is still S+ there (0.575).

3. Controls, baselines, cost. A random controller over the same tools scores below COBYQA on every pool (0.245–0.442). Twelve model-free baselines include restarts, two portfolios, and NGOpt. Cost, tokens, and time per case are reported (§4.4; Tables 12–13, 15–17).

4. Dimension. Bench 1.0 keeps n ≤ 5 (92 problems, budget 50n); the solver is also evaluated with n = 6–10, 15, and 20 (§4.4). Most optima of the n = 15 pool are at the origin, so we do not use it as held-out evidence. Six of the eight n = 20 families also occur at smaller n in the Bench or a development pool (§6).

What changed in the PDF. The revision keeps the section structure and most of the wording of the submission. The abstract and §1 add the novelty statement and the new findings. §2.1–2.3 are unchanged apart from one added term; §2.4 is new (the decision space of Solver 1.0, with the agent's own points, and the textbook policy), and Fig. 2 now shows it. In §3 the Bench leaderboard runs native agents, which receive no NextEval tools, next to the solver; §3 also adds a fourth feature (random failures) and a stricter evidence rule. §4 keeps its outline: the setup (§4.1, now with start perturbation 0.03, three repetitions, GPT-5.6 Luna and GPT-6.1 Sol as LLMs, the pair score, and the decision standard), the comparison with classical solvers (§4.2), and the configuration studies (§4.3) report new runs, and §4.4 collects the experiments the reviews asked for. The case study and two baselines of the submission, Powell's method and finite-difference BFGS, were not rerun; the twelve baselines follow the reviews' requests (restarts, portfolios, method selection). §5–§7 and Appendices G–I are updated accordingly (App. I: the decision space of Solver 1.0), and Appendices A–F are new. The main text uses the tenth page allowed for revisions.

Why all solver results are new. The submission's solver comparison normalized scores jointly over the compared solvers and could not separate the policy from the environment. We rebuilt the comparison around a shared decision space and replaced every solver experiment of the submission by new runs with the instances, budgets, scoring code, and evidence rules of the Bench, in which each configuration is scored against COBYQA and other participants cannot change its score (§3, §4.1).

Material. The supplementary material contains the released NextEval Solver 1.0, the run histories of every reported run (for the leaderboard and the classical baselines, as running best values), and one command that recomputes every table of results. The reported LLM runs were made before seven edits to text that the model receives: two labels in the task message, a scope label in the tool manuals, and two manual passages, one parameter description and one knowledge card that now describe how an invalid call is handled (all listed in its README). Tool names, parameters, behaviour and numerical defaults did not change, and no experiment was rerun. On the platform of the experiments (Linux x86_64) the released solver regenerates the model-free histories of the textbook autopilot and of the two fixed controls bit for bit, and the supplementary scripts regenerate those of COBYQA.

AuthorsOpenReview ↗

General response to all reviewers and the AC — Second Turn

We sincerely thank all reviewers for their constructive feedback and for raising their ratings after considering our responses and additional experiments. We also thank the AC for their time and consideration. The discussion has helped us substantially strengthen both the experimental evidence and the presentation. We summarize the main improvements below.

  • Clarified contribution and novelty. To our knowledge, NextEval is the first DFO solver in which an LLM selects, configures, and switches among stateful numerical methods within a single solve, preserving their accumulated numerical work. NextEval Bench additionally provides a common protocol for evaluating optimization agents.
  • Directly tested the contribution of LLM control. We added fixed and random controllers using the same numerical environment. Following the discussion, we further disabled autonomous point generation: the resulting agent still improves over the fixed textbook controller on 6–10-dimensional problems. This directly addresses the shared concern about whether numerical-method orchestration itself contributes to performance.
  • Expanded evaluation and transparency. We added stronger baselines, including restarts, portfolios, and automated method selection; extended solver evaluation to 20 dimensions; and reported results on problems never used in development, alongside runtime and LLM costs. The latest revision incorporates the follow-up ablation, separate results for non-overlapping families, and clarification of the rerun rules in Appendix J. We also explicitly qualify the remaining generalization limitations.

We believe these revisions have substantially addressed the main concerns raised across the reviews. We remain grateful for further feedback from Reviewer kZTV and would welcome clarification of any remaining concerns so that we can continue improving the paper.

We respectfully ask the AC to consider the revised evidence, the methodological contribution, and the benchmark contribution together in the final assessment.

Dear Reviewers,

Please note that the author rebuttal is now available. We kindly ask you to read it, join the discussion, and update the review as soon as possible. Your prompt action will help us proceed to the final decision. Thanks.

Best regards

AC

AuthorsOpenReview ↗

Closing remarks

We thank the Area Chair and the reviewers for their time and thoughtful feedback.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.