Paper deep dive

Large Language Models as Optimization Controllers: Adaptive Continuation for SIMP Topology Optimization

Shaoliang Yang, Jun Wang, Yunsheng Wang

Year: 2026Venue: arXiv preprintArea: cs.CEType: PreprintEmbeddings: 107

Intelligence

Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 96%

Last extracted: 3/27/2026, 1:32:05 AM

Summary

The paper introduces a framework using Large Language Models (LLMs) as online adaptive controllers for SIMP topology optimization. By replacing fixed-schedule continuation with real-time, state-conditioned parameter decisions (penalization exponent, projection sharpness, filter radius, and move limit), the LLM agent achieves superior compliance and fully binary solutions across 2D and 3D benchmarks. The system includes a Direct Numeric Control interface, a hard grayness gate to prevent premature binarization, and a meta-optimization loop for tuning agent hyperparameters.

Entities (5)

Large Language Model · technology · 100%SIMP · methodology · 100%Direct Numeric Control · architecture · 95%Meta-optimization loop · process · 95%Three-field formulation · methodology · 95%

Relation Signals (3)

Large Language Model → controls → SIMP

confidence 98% · LLM acts as an online adaptive controller for SIMP topology optimization

Direct Numeric Control → implements → Large Language Model

confidence 95% · We design an LLM controller that operates in a direct numeric mode

Meta-optimization loop → tunes → Large Language Model

confidence 95% · a meta-optimization loop uses a second LLM pass to tune the agent's call frequency

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:We present a framework in which a large language model (LLM) acts as an online adaptive controller for SIMP topology optimization, replacing conventional fixed-schedule continuation with real-time, state-conditioned parameter decisions. At every $k$-th iteration, the LLM receives a structured observation$-$current compliance, grayness index, stagnation counter, checkerboard measure, volume fraction, and budget consumption$-$and outputs numerical values for the penalization exponent $p$, projection sharpness $\beta$, filter radius $r_{\min}$, and move limit $\delta$ via a Direct Numeric Control interface. A hard grayness gate prevents premature binarization, and a meta-optimization loop uses a second LLM pass to tune the agent's call frequency and gate threshold across runs. We benchmark the agent against four baselines$-$fixed (no-continuation), standard three-field continuation, an expert heuristic, and a schedule-only ablation$-$on three 2-D problems (cantilever, MBB beam, L-bracket) at $120\!\times\!60$ resolution and two 3-D problems (cantilever, MBB beam) at $40\!\times\!20\!\times\!10$ resolution, all run for 300 iterations. A standardized 40-iteration sharpening tail is applied from the best valid snapshot so that compliance differences reflect only the exploration phase. The LLM agent achieves the lowest final compliance on every benchmark: $-5.7\%$ to $-18.1\%$ relative to the fixed baseline, with all solutions fully binary. The schedule-only ablation underperforms the fixed baseline on two of three problems, confirming that the LLM's real-time intervention$-$not the schedule geometry$-$drives the gain. Code and reproduction scripts will be released upon publication.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

106,341 characters extracted from source content.

Expand or collapse full text

Large Language Models as Optimization Controllers: Adaptive Continuation for SIMP Topology Optimization Shaoliang Yang Santa Clara University, Santa Clara, CA Jun Wang Corresponding author. E-mail: jwang22@scu.edu Santa Clara University, Santa Clara, CA Yunsheng Wang Santa Clara University, Santa Clara, CA Abstract We present a framework in which a large language model (LLM) acts as an online adaptive controller for SIMP topology optimization, replacing conventional fixed-schedule continuation with real-time, state-conditioned parameter decisions. At every k-th iteration the LLM receives a structured observation—current compliance, grayness index, stagnation counter, checkerboard measure, volume fraction, and budget consumption—and outputs numerical values for the penalization exponent p, projection sharpness β, filter radius rminr_ , and move limit δ via a Direct Numeric Control interface. A hard grayness gate prevents premature binarization, and a meta-optimization loop uses a second LLM pass to tune the agent’s call frequency and gate threshold across runs. We benchmark the agent against four baselines—fixed (no-continuation), standard three-field continuation, an expert heuristic, and a schedule-only ablation—on three 2-D problems (cantilever, MBB beam, L-bracket) at 120×60120\!×\!60 resolution and two 3-D problems (cantilever, MBB beam) at 40×20×1040\!×\!20\!×\!10 resolution, all run for 300 iterations. A standardized 40-iteration sharpening tail is applied from the best valid snapshot so that compliance differences reflect only the exploration phase. The LLM agent achieves the lowest final compliance on every benchmark: −5.7%-5.7\% to −18.1%-18.1\% relative to the fixed baseline, with all solutions fully binary. The schedule-only ablation underperforms the fixed baseline on two of three problems, confirming that the LLM’s real-time intervention—not the schedule geometry—drives the gain. Code and reproduction scripts will be released upon publication. Keywords: Topology optimization, SIMP, Three-field formulation, Continuation methods, Large language models, Online parameter control, Heaviside projection, Meta-optimization, Structural compliance 1 Introduction 1.1 Topology Optimization and the Continuation Problem Topology optimization seeks a material distribution ρ()ρ(x) within a prescribed design domain Ω that minimizes a structural objective while satisfying equilibrium and a volume constraint. The SIMP method [9, 57] remains the dominant computational paradigm: element densities ρe∈[0,1] _e∈[0,1] serve as design variables, and the power-law stiffness interpolation E(ρe)=Emin+ρep(E0−Emin),p>1,E( _e)\;=\;E_ + _e^\,p (E_0-E_ ), p>1, (1) penalizes intermediate densities to promote solid-void solutions. In the basic SIMP formulation, ρe _e in Eq. (1) denotes the raw element density; in the three-field extension introduced below, the power law acts instead on the projected physical density ρ~e ρ_e (see Eq. (5) in section 3.1). In the three-field formulation of [64], the raw design field ρ passes through two successive projections before entering the finite-element solve: a linear density filter of radius rminr_ produces a smoothed field ρ¯ ρ, which is then mapped to a physical density ρ~ ρ by the Heaviside projection ρ~e=tanh⁡(βη)+tanh⁡(β(ρ¯e−η))tanh⁡(βη)+tanh⁡(β(1−η)), ρ_e\;=\; (β\,η)+ \! (β( ρ_e-η) ) (β\,η)+ \! (β(1-η) ), (2) where η∈(0,1)η∈(0,1) is a threshold parameter and β≥1β≥ 1 controls the sharpness of the projection. As β→∞β→∞, Eq. (2) approaches a step function and ρ~ ρ becomes binary; for β=1β=1 the mapping is nearly linear [64, 39]. This decoupling of the design space from the physical density is the key advantage of the three-field approach: the filter enforces a minimum length scale while the Heaviside projection drives binarization, and the two processes can be controlled independently through rminr_ and β, respectively. Despite the elegance of this formulation, practical performance is acutely sensitive to the continuation schedule: the trajectory along which p, β, rminr_ , and the Optimality Criteria (OC) move limit δ are varied over the course of the solve. Increasing β too early, before a coherent structural topology has formed, locks the design into a poor local minimum from which the gradient method cannot escape; conversely, deferring sharpening wastes computational budget on an excessively gray intermediate field [58, 39]. Standard practice relies on monotone schedules calibrated by the practitioner—typically a linear ramp for p and geometric doubling for β at fixed iteration intervals—that are tuned for a particular problem class, mesh resolution, and iteration budget and must be re-calibrated whenever any of these change [39, 64]. 1.2 Limitations of Fixed-Schedule Continuation The fundamental limitation of fixed-schedule continuation is that it is open-loop: the schedule commits to a progression of parameter values independent of what is actually occurring in the density field. Consider two runs initialized identically but perturbed by different random seeds: the grayness G (fraction of elements with intermediate density) may differ substantially at any given iteration, yet both runs receive the same β update regardless. If G is still declining rapidly—indicating that material is actively consolidating under penalization—a premature β increase interrupts this process and crystallizes a sub-optimal topology. Conversely, if G has plateaued while p is still low, the schedule may continue to invest iterations in a gray, under-penalized phase rather than advancing toward sharpening. This sensitivity is not a minor practical inconvenience. Our experiments confirm that a schedule-only controller that runs the same phase structure as an adaptive agent—but without observing actual solver state—achieves compliance worse than the fixed no-continuation baseline on two of three tested problems (cantilever: +0.43%+0.43\%; MBB beam: +1.09%+1.09\% versus fixed). The result is striking: blindly applying a structured schedule is not merely neutral but actively harmful, because each phase transition locks in parameter values that may be premature or delayed for the actual trajectory of the specific run. This motivates the need for a closed-loop, state-conditioned controller that can observe, reason about, and react to the evolving topology in real time. More broadly, this limitation exemplifies a recurring tension in computational mechanics: iterative numerical methods often depend on hyperparameter schedules that embed implicit assumptions about the solution trajectory, yet the optimal schedule cannot be known without first solving the problem. Continuation in SIMP is a particularly clean instance of this tension, because the four control parameters (p, β, rminr_ , δ) have direct physical interpretations and the feedback signal (grayness, compliance, volume) is rich and inexpensive to compute. This makes it an ideal testbed for investigating whether language-model-guided closed-loop control can replace hand-tuned open-loop schedules in physics-based solvers. 1.3 Large Language Models as Online Optimizers Recent advances in large language models (LLMs) have demonstrated structured reasoning capacity well beyond pattern matching: models such as Gemini [31], GPT-4 [45], and Claude [5] achieve expert-level performance on mathematics, scientific question answering, and multi-step planning tasks that require the integration of symbolic reasoning with domain knowledge [66, 70]. Of particular relevance is the paradigm of LLM-as-agent: the model observes a state representation, reasons about it in natural language, and emits a structured action [70, 46]. This paradigm has been applied to code generation [22], robotic control [25], materials discovery [15], and multi-objective optimization [41], but has not, to our knowledge, been applied to the online control of all four continuation parameters jointly in density-based topology optimization. Closest to our setting, [48] use convergence-triggered rules to adapt p alone, and [26] use a fixed grayness rule for β steps; neither employs a learned, state-conditioned policy over the full parameter set. The LLM-as-optimizer framing is attractive for this application for several reasons, and it can be situated within the Dynamic Algorithm Configuration (DAC) paradigm [13, 3]: rather than learning a policy via reinforcement learning, the LLM with SIMP domain knowledge acts directly as the policy, sidestepping the large number of environment interactions that RL-based DAC requires. Conceptually, the agent’s behaviour also echoes curriculum learning [11]: SIMP continuation is a form of gradually increasing difficulty, and the LLM reads the optimizer’s current state to pace this curriculum adaptively rather than following a predetermined schedule [10]. First, it requires no training or fine-tuning: domain knowledge about SIMP continuation—when to ramp p, how to interpret grayness stagnation, why premature binarization is harmful—can be encoded directly in the system prompt. Second, the output of the LLM is immediately interpretable: it emits (p,β,rmin,δ)(p,β,r_ ,δ) with a one-line rationale, providing a natural audit trail of every parameter decision. Third, the architecture generalizes trivially across problem geometries, boundary conditions, and mesh resolutions without re-calibration, since the model observes the actual state of the current run rather than pattern-matching to a stored problem type. These properties contrast sharply with black-box surrogate or Bayesian optimization approaches, which optimize over entire run trajectories and typically require either many historical runs or problem-specific parameterization [51, 35]. From a broader perspective, this work sits at the convergence of two trends that have developed largely in isolation. On one side, the computational mechanics community has accumulated decades of practitioner knowledge about continuation strategies—knowledge that is typically transmitted through tutorials, code comments, and trial-and-error rather than through formal algorithms. On the other side, the LLM community has demonstrated that language models can absorb and operationalise such informal domain knowledge when it is encoded as natural-language instructions [66, 70]. The present work connects these two lines by showing that the practitioner’s understanding of SIMP continuation—“do not raise β while the topology is still gray”—can be made into an executable, state-conditioned policy by encoding it in a system prompt and letting the model apply it adaptively to each run. The result is neither a replacement for the domain expert nor a black-box surrogate, but rather a mechanism for translating qualitative engineering judgement into quantitative solver control at a cost (under $1 1 USD for all experiments) that makes the approach accessible to any research group with API access. 1.4 Contributions This paper makes the following contributions: (1) Direct Numeric Control (DNC) architecture. We design an LLM controller that operates in a direct numeric mode: rather than selecting a discrete phase label that maps to preset values, the model outputs floating-point values for p, β, rminr_ , and δ at every k-th iteration. Safety rails clamp outputs to physically valid ranges; a hard grayness gate (β≤8β≤ 8 while >0.20G>0.20) enforces the empirically-derived constraint that Heaviside sharpening degrades solution quality when substantial gray material remains. (2) Meta-optimization loop. A second LLM pass reads post-run summary statistics and proposes updates to the primary agent’s own hyperparameters—grayness gate threshold, LLM call frequency, and phase timing constants—via regex patching of the source constants. This creates a two-level adaptive system: the inner agent adapts parameter values within a run; the outer loop adapts the agent’s own decision rules across runs. (3) Controlled comparison with standardized tail. We construct a rigorous experimental protocol in which all four continuation controllers (three-field continuation, expert heuristic, schedule-only ablation, and LLM agent) share an identical 4040-iteration sharpening tail (p=4.5p=4.5, β=32β=32, rmin=1.20r_ =1.20, δ=0.05δ=0.05) applied from the best valid snapshot stored during the main loop; the fixed controller serves as a no-intervention reference without a tail. This controlled protocol ensures that all compliance differences among continuation controllers at the termination of a run are attributable exclusively to the quality of the topology produced during the main exploration phase—the domain of the controller under comparison. (4) Ablation confirming LLM causality. The schedule-only ablation controller—which reproduces the LLM’s four-phase schedule structure without querying the LLM API— isolates the contribution of online adaptation from the contribution of the phase structure alone. Its consistent underperformance relative to the LLM agent, and its underperformance relative to the fixed baseline on two of three benchmarks, constitutes strong evidence that the LLM’s real-time decisions—not the phase structure—are the source of the observed compliance gains. 2 Related Work This section reviews prior work in four areas that directly motivate and contextualise the present contribution: SIMP topology optimization and continuation strategies (section 2.1), machine learning applied to topology optimization (section 2.2), Bayesian optimization and dynamic algorithm configuration for solver hyperparameters (section 2.3), and large language models as optimization agents (section 2.4). Throughout, we highlight the gap that the present work fills: no prior method has used a learned agent to jointly and adaptively control all four continuation parameters (p, β, rminr_ , δ) of the three-field SIMP formulation on a per-iteration basis. 2.1 SIMP Topology Optimization and Continuation Density-based topology optimization originates with the homogenization approach of [7] and the closely related SIMP material interpolation introduced independently by [8] and [73]. [9] and [57, 4] established the computational foundations and disseminated accessible reference implementations; [55] and [23] provide comprehensive surveys of the field. The three-field formulation—design variables ρ filtered through a density regularisation of radius rminr_ and then projected via a Heaviside function of sharpness β—was introduced by [64] following earlier filter work by [16] and [19] and projection work by [30]. The Helmholtz PDE-based filter of [38] provides a scalable implementation for large-scale problems. Length-scale and manufacturability constraints arising in this formulation are analysed comprehensively by [39]. The grayness index used throughout the present work as a gate criterion derives from the morphology-based filter of [58]. The core difficulty that motivates our approach is the sensitivity of three-field SIMP to its continuation schedule. [61] demonstrated theoretically that the trajectories traced by penalization continuation methods can be discontinuous, and that naive schedules may fail to converge to black-and-white designs. [29] proposed eliminating β-continuation altogether through formulation modifications, but this is not always applicable. The most directly related prior work on automatic continuation is [48], who propose convergence-based triggers for automatically incrementing the penalization exponent p in standard SIMP. Their method adapts p alone and uses a deterministic trigger rule; it does not adapt β, rminr_ , or δ jointly, nor does it use any learning-based controller. A very recent independent development by [26] proposes using the grayness indicator as an automatic stopping criterion for β steps in three-field SIMP, again via a fixed rule rather than a state-conditioned policy. The present work extends this line of research by replacing deterministic trigger rules with a language model that observes the full solver state and outputs all four continuation parameters simultaneously. The Optimality Criteria (OC) update method used throughout the paper was formalised by [62], with a more general globally convergent variant (GCMMA) in [63]. For large-scale 3-D problems the AMG-preconditioned solver from [6] is used, consistent with giga-voxel implementations such as [1]. A modern 99-line reference implementation including the three-field formulation is given by [28]. 2.2 Machine Learning for Topology Optimization A growing body of work applies machine learning to accelerate or supplement iterative topology optimization. The field is surveyed comprehensively by [67] and [53], who identify three main paradigms: (i) prediction of near-optimal topologies from boundary conditions using CNNs or U-Net-like architectures [60, 72, 37], (i) surrogate models for the finite-element solve that replace or reduce the number of FEA calls [20, 2], and (i) generative models that sample from a learned distribution of optimal topologies [44, 43]. Neural reparameterization offers a complementary perspective: [33] showed that optimizing neural network weights as implicit density representations instead of grid densities exploits the inductive bias of neural networks to regularize the design space. [21] made this practically competitive with standard SIMP while retaining mesh-independence. An important recent development is the self-directed online machine learning framework of [24] (Nature Communications), which integrates a DNN surrogate with FEM to dynamically generate training data near the predicted optimum, reducing computational cost by orders of magnitude. Reinforcement learning has been applied to gradient-free topology optimization via sequential element removal [17], and to truss TO under constraints [32]. A key distinction separates all of these methods from the present work. CNN and generative approaches learn a mapping from problem specification to topology, effectively replacing the optimizer. Surrogate approaches learn to approximate the forward model. None of these methods addresses the continuation scheduling problem: given a running iterative SIMP solver, how should the continuation parameters be adapted in real time to prevent premature binarization and local minima? The present work occupies this gap, using a language model not as a topology predictor or surrogate, but as a per-iteration parameter controller that observes solver state and adjusts continuation parameters accordingly. 2.3 Hyperparameter Optimization and Dynamic Algorithm Configuration Hyperparameter optimization (HPO) methods — including Bayesian optimization [51, 59], the Tree-structured Parzen Estimator [12], SMAC [34], and Hyperband [40] — treat algorithm hyperparameters as static quantities to be tuned before or between runs. Population-Based Training [36] extends this to learn hyperparameter schedules across a population of models during training. Comprehensive surveys of HPO methods are provided by [35] and [14]. These offline or between-run HPO methods are fundamentally different from what is needed for SIMP continuation, where the optimal parameter values depend on the current topology—information available only during the run. This motivates the Dynamic Algorithm Configuration (DAC) paradigm, formalised by [13] and surveyed comprehensively by [3]. In DAC, algorithm parameters are treated as an MDP policy to be learned via reinforcement learning, with the optimizer’s current state as observations. Concrete DAC applications include learning step-size policies for CMA-ES [52], and the DACBench benchmark library [27] provides standardised evaluation protocols. The present work can be viewed as a non-RL DAC agent: instead of learning a policy via trial-and-error, an LLM with SIMP domain knowledge embedded in its system prompt acts as the policy, observing solver state and emitting parameter actions every k iterations. This avoids the large number of environment interactions required by RL-based DAC methods while leveraging the pre-trained reasoning capabilities of frontier models. The meta-optimization outer loop—which tunes the agent’s own hyperparameters across runs using a second LLM pass—is related to algorithm configuration [34] and PBT [36], but operates at a higher level by adapting the controller’s decision rules rather than its policy parameters. 2.4 Large Language Models as Optimization Agents The paradigm of using large language models as agents that perceive structured observations and emit actions has developed rapidly since the introduction of GPT-3 [18] and chain-of-thought prompting [66]. The ReAct framework of [70] showed that interleaving reasoning traces with external tool calls substantially improves performance on multi-step decision tasks. Toolformer [50] demonstrated that LLMs can learn to invoke external computational tools—including calculators and solvers—via self-supervised training, establishing the paradigm of LLM-driven solver invocation that the present work instantiates in the SIMP setting. Embodied agents such as PaLM-E [25] and Voyager [65] have shown that LLMs can maintain and exploit long-term context about a changing environment—a capability directly exploited here through the agent’s running observation of grayness, compliance, and budget-consumed fraction. LLMs have been deployed as direct optimizers in several recent works. OPRO [69] treats the LLM as an optimizer over text prompts, using previous (solution, score) pairs in the context window as a few-shot surrogate gradient. FunSearch [49] combines evolutionary search with LLM code generation to discover new mathematical functions, achieving state-of-the-art results on the cap-set problem. ReEvo [71] uses LLM reflections as “verbal gradients” to evolve heuristics for combinatorial optimization, achieving competitive results across six benchmark problem classes. These methods treat the LLM as a batch optimizer that proposes new solutions in context. In contrast, the present work uses the LLM as an online per-iteration controller: rather than searching over a solution space, the agent observes the evolving physical state of a running solver and outputs exact floating-point parameter values that govern the solver’s next iteration. Iterative self-refinement frameworks such as Self-Refine [42] and Reflexion [54] show that LLMs improve their outputs when given structured feedback—a mechanism that the present system uses explicitly through the per-call compliance and grayness observations fed back to the model. LLM-driven scientific discovery has been demonstrated in chemistry by [15] and in mathematics by FunSearch [49], while autonomous research pipelines are reviewed by [68]. In structural and mechanical engineering, applications of LLMs remain nascent [47]; no prior work has applied an LLM to the online control of iterative numerical solvers in topology optimization. An important conceptual connection is to curriculum learning [11], which formalises the insight that gradual difficulty scheduling improves convergence in nonconvex problems. SIMP continuation is mathematically a form of curriculum learning: the optimization landscape is initially smooth (low p, low β) and progressively made harder (binary) as the algorithm matures. The LLM agent’s behaviour—holding β≤8β≤ 8 while >0.20G>0.20 and deferring sharpening by ≈70≈\!70–9090 iterations relative to fixed-schedule controllers—can be interpreted as adaptive curriculum pacing: the agent reads the learner’s (optimizer’s) current state to decide when to advance the difficulty rather than following a predetermined pace. This connection situates the approach within the broader literature on learned curriculum strategies [10] and dynamic algorithm configuration [3]. 3 Methodology This section describes the complete two-level adaptive architecture. Section 3.1 establishes the three-field SIMP formulation and the continuation parameter space. Section 3.2 presents the LLM agent and its Direct Numeric Control (DNC) interface. Section 3.3 describes the meta-optimization outer loop. Section 3.4 defines the four baseline controllers used for comparison. Section 3.5 specifies the experimental protocol, including the standardized sharpening tail that ensures fair comparison. The overall pipeline is illustrated in fig. 1. Figure 1: Overall two-level system pipeline. The inner loop executes the SIMP solver for up to N main-loop iterations; every kkth iteration the LLM agent observes the structured solver state and emits updated solver parameters. The outer meta-optimization loop reflects on completed-run summaries and patches the agent’s own hyperparameters for the next run. A standardized 4040-iteration sharpening tail, applied from the best valid intermediate snapshot, is shared identically across all four continuation controllers, ensuring that all compliance differences at run termination are attributable exclusively to main-loop behaviour. 3.1 Three-Field SIMP Formulation We adopt the three-field SIMP formulation of [64], in which the raw design field ρ passes through two successive transformations before entering the finite-element stiffness assembly (fig. 2). Figure 2: Three-field SIMP formulation. Raw design variables ρ∈[0,1]ρ∈[0,1] pass through a linear density filter of radius rminr_ to produce a smoothed field ρ¯ ρ, which is then mapped by the Heaviside projection (sharpness β, threshold η=0.5η=0.5) to the physical density ρ~ ρ entering stiffness assembly. The five LLM-controlled parameters (p, β, rminr_ , δ, restart flag) output by the Direct Numeric Control interface are listed in the lower panel with their admissible ranges. Density filter. A spatially weighted average of radius rminr_ maps the design field to the filtered field: ρ¯e=∑i∈eHeiρi∑i∈eHei,Hei=max⁡(0,rmin−‖e−i‖), ρ_e\;=\; _i _eH_ei\, _i _i _eH_ei, H_ei= \! (0,\,r_ -\|x_e-x_i\| ), (3) where eN_e is the neighbourhood of element e within radius rminr_ . The filter enforces a minimum length scale and eliminates checkerboard instabilities [56, 16]. Heaviside projection. The filtered field is projected to a near-binary physical density via the smooth Heaviside function [64, 30]: ρ~e=tanh⁡(βη)+tanh⁡(β(ρ¯e−η))tanh⁡(βη)+tanh⁡(β(1−η)), ρ_e\;=\; (β\,η)+ \! (β( ρ_e-η) ) (β\,η)+ \! (β(1-η) ), (4) with threshold η=0.5η=0.5. As β→∞β→∞, ρ~ ρ converges to a step function and the design becomes fully binary; at β=1β=1 the mapping is nearly linear. Stiffness interpolation. The physical density determines element stiffness via the SIMP power law [9]: E(ρ~e)=Emin+ρ~ep(E0−Emin),p>1,E( ρ_e)\;=\;E_ + ρ_e^\,p (E_0-E_ ), p>1, (5) where E0E_0 is the stiffness of solid material and Emin=10−9E0E_ =10^-9E_0 prevents singularity. Compliance minimization. The structural compliance objective is C==(ρ~),C\;=\;F TU\;=\;U TK( ρ)\,U, (6) where K is the assembled stiffness matrix and U satisfies =KU=F. Design updates are computed by the Optimality Criteria (OC) method with move limit δ; no additional optimizer (MMA, etc.) is used. Grayness index. Following [58], we quantify intermediate-density material by the grayness index =4Ne∑e=1Neρ~e(1−ρ~e)∈[0,1],G\;=\; 4N_e _e=1^N_e ρ_e\! (1- ρ_e )\;∈\;[0,1], (7) where NeN_e is the total number of elements. =0G=0 corresponds to a fully binary design; =1G=1 to a fully gray one. The LLM agent observes G at every call and uses it to pace the Heaviside sharpening schedule. 3.2 LLM Agent and Direct Numeric Control Interface Figure 3 illustrates the per-iteration decision loop of the LLM agent. Every kkth iteration (default k=5k=5), the solver state is serialised into a structured text prompt and submitted to the Gemini API (model gemini-3.1-flash-lite-preview111Model accessed in preview form, March 2026; the exact identifier reflects the version available at time of experimentation and may differ from any publicly released variant.). The model returns a JSON object with exact floating-point values for all four solver parameters plus a restart flag; a reasoning note is also requested for interpretability but does not affect the solver. Figure 3: LLMagent decision loop at iteration 147147 (49%49\% of budget consumed). Left — state observation: the solver’s current state is serialised into thirteen scalar quantities. The compliance C measures global structural flexibility (lower is stiffer and better); best_compliance C∗C^* is the lowest valid compliance seen so far. The grayness ∈[0,1]G∈[0,1] quantifies intermediate-density material: =0G=0 is a fully binary (solid/void) design; >0.20G>0.20 indicates substantial unresolved material that would degrade manufacturability. The grayness_slope approximates whether G is actively falling (topology consolidating) or stagnant (penalization insufficient); a value near zero signals that the current (p,β)(p,β) combination is no longer driving binarization. The stagnation_counter counts consecutive iterations without improvement in C∗C^*; high values prompt the agent to increase penalization. The checkerboard index detects non-physical alternating-density patterns that indicate numerical instability. Centre — reasoning: the model identifies the current budget phase (Stage 2, penalization), notes that the grayness gate is active (=0.224>0.20G=0.224>0.20), and decides to raise p while holding β to avoid premature binarization. Physically, increasing p steepens the stiffness–density curve E(ρ~)=Emin+ρ~p(E0−Emin)E( ρ)=E_ + ρ^p(E_0-E_ ), penalising intermediate densities more heavily and encouraging material to commit toward solid (ρ~=1 ρ=1) or void (ρ~=0 ρ=0) without yet forcing binary projection via β. In contrast, raising the Heaviside sharpness β in Eq. (2) compresses the smooth projection toward a step function, forcing all filtered densities ρ¯ ρ near the threshold η to snap to 0 or 11 simultaneously — a much more aggressive binarization that, if applied while G is still high, freezes the partially-formed topology into a poor local minimum from which the gradient-based OC update cannot escape. This is why the agent holds β=4.0β=4.0 (well below the gate cap of 8.08.0) and raises p instead: penalization steers material gradually, while premature β escalation locks it irreversibly. Reducing rminr_ tightens the density-filter length scale, permitting finer structural features to form; reducing δ limits the per-iteration density change, stabilising the optimality-criteria update as the topology matures. Right — safety rails: the JSON output is clamped to physically valid ranges (p∈[1,5]p∈[1,5], β∈[1,64]β∈[1,64], rmin∈[1.1,4.0]r_ ∈[1.1,4.0], δ∈[0.03,0.40]δ∈[0.03,0.40]); the grayness gate hard-caps β≤8β≤ 8 while >0.20G>0.20; rminr_ is enforced monotonically non-increasing; and restarts are permitted only when a valid best snapshot exists. Observation vector. The prompt is built from thirteen scalar quantities drawn from the state vector at each call: (1) Iteration indices: iteration number, budget consumed (% of N), iterations since best. (2) Compliance signals: current compliance C, best valid compliance C∗C^*, relative deviation (C−C∗)/C∗(C-C^*)/C^*, relative change over 1 and 5 steps, and objective slope. (3) Topology signals: grayness G, grayness slope (a proxy trend signal computed as s=−|ΔC5/C|⋅[stag<3]s_G=- | C_5/C |·1[stag<3], where ΔC5 C_5 is the relative compliance change over the last five iterations and stag is the stagnation counter; s_G is negative when compliance is still improving and near zero when the current (p,β)(p,β) combination is no longer driving binarization), checkerboard index, volume fraction. (4) Current parameters: p, β, rminr_ , δ, and a Boolean flag indicating whether the current best snapshot satisfies the validity gate. System prompt and advisory scaffold. The system prompt encodes domain knowledge in four parts: (i) a parameter description with physical bounds, (i) a four-stage advisory schedule (table 1) that acts as a pacing hint, (i) a set of critical timing rules for β advancement indexed to the budget-consumed fraction, and (iv) explicit guidance on when not to raise β. The advisory schedule is not enforced as a hard constraint; the LLM may deviate at any iteration, and in practice it does so when the observed grayness trajectory indicates the problem is not following the nominal pacing. Table 1: Four-stage advisory parameter schedule embedded in the LLM system prompt. All four parameters (p, β, rminr_ , δ) are advisory targets, not hard constraints; the agent outputs exact numeric values that may deviate based on observed solver state. Budget fractions are expressed as a percentage of the total main-loop iteration count N. Stage Budget p β r_ target δ 1. Exploration 0–8%8\% 1.01.0–2.02.0 1.01.0 1.501.50 0.200.20 2. Penalization 88–50%50\% 2.02.0–4.54.5 11–44 1.351.35 0.150.15 3. Sharpening 5050–75%75\% 4.54.5 44–1616 1.251.25 0.080.08 4. Converge 7575–100%100\% 4.54.5 3232 1.201.20 0.050.05 Tail (fixed) +40+40 iters 4.54.5 3232 1.201.20 0.050.05 Direct Numeric Control output. The LLM outputs a single JSON object at each call: at=pt,βt,rmint,δt,restartt,notet,a_t\;=\; \\,p_t,\; _t,\;r_ _t,\; _t,\;restart_t,\;note_t\, \, (8) where notetnote_t is a one-line rationale retained for auditing but not fed back to the solver. All numeric outputs are clamped to the ranges in table 2 by a deterministic safety layer before application. Additionally, rminr_ is enforced to be non-increasing across iterations (monotone constraint), and the restart flag is ignored unless the best snapshot is valid. Table 2: LLM-controlled solver parameters, admissible ranges, and the hard grayness gate applied by the safety layer before each action is committed to the solver. Parameter Symbol Range Physical role Penalization exponent p [1.0, 5.0][1.0,\;5.0] SIMP void penalty strength Heaviside sharpness β [1.0, 64.0][1.0,\;64.0] Binarization aggressiveness Filter radius rminr_ [1.1, 4.0][1.1,\;4.0] Minimum length scale (monotone ↓ ) OC move limit δ [0.03, 0.40][0.03,\;0.40] Density update step size Restart flag — T,F\ T, F\ Reload best valid snapshot Grayness gate (hard constraint, not overridable): β≤8.0β≤ 8.0 while >0.20G>0.20 Grayness gate. A key design decision is the hard grayness gate: the safety layer caps β≤8.0β≤ 8.0 whenever >0.20G>0.20, regardless of what the LLM requests. This gate encodes an empirically established principle: aggressive Heaviside sharpening while substantial intermediate-density material remains locks the topology into a poor local minimum that the OC method cannot escape [39, 58]. Note that the system prompt gives the LLM a softer advisory (β<16β<16 while >0.20G>0.20) to encourage patient behaviour, while the deterministic safety layer enforces the stricter hard cap (β≤8.0β≤ 8.0); the cap holds even if the model ignores or misinterprets the advisory. The gate threshold (0.200.20) is itself a meta-optimizable constant; the default value was tuned by the outer loop described in section 3.3. Fallback schedule. When the Gemini API is unavailable or returns an invalid response, the agent falls back to a smooth deterministic ramp that follows the advisory schedule in table 1. This fallback ensures the solver always advances; it is logged and excluded from the primary results. 3.3 Meta-Optimization: Outer Hyperparameter Loop The inner LLM agent adapts solver parameters within a single run. A second level of adaptation—the meta-optimization loop—adjusts the agent’s own constants across successive runs (fig. 4). Figure 4: Meta-optimization outer loop. After each completed comparison run, the meta-optimizer reads the performance summary and submits a second Gemini call that reflects on the relative performance of all five controllers. The model proposes bounded Δ -updates to the primary agent’s own constants — the grayness-gate threshold, API call frequency, and fallback β-doubling period (table 3) — which are bounds-checked and written back to the agent configuration via automated patching. The outer loop repeats for nitersn_iters iterations, converging on agent hyperparameters that generalise across problem geometries. Meta-optimizable constants. Table 3 lists the six constants exposed to the outer loop with their admissible bounds. Hard bounds are enforced before write-back to prevent the meta-loop from driving the agent into degenerate configurations (e.g., a call interval k=1k=1 would call the API at every iteration, incurring prohibitive cost; k=15k=15 would provide insufficient reactivity). Table 3: Constants exposed to the meta-optimization outer loop, with hard bounds enforced before write-back to the agent configuration. Default values are those obtained after convergence of the outer loop on the cantilever benchmark; they are used for all primary experiments in section 4. Constant Role Lower Upper Default GRAYNESS_GATE β-cap threshold 0.100.10 0.350.35 0.200.20 CALL_EVERY API call period 33 1515 55 PENAL_RAMP_ITERS Fallback ramp length 44 2020 1212 BETA_DOUBLE_EVERY Fallback β period 55 2020 1010 PHASE_MIN_ITERS.penalization Min iters in Stage 2 44 2525 2222 PHASE_MIN_ITERS.sharpening Min iters in Stage 3 44 2525 1616 Outer-loop protocol. Each outer iteration executes one full five-controller comparison run on a nominated benchmark problem and writes the compliance, grayness, and wall-clock time for all five controllers to a JSON summary file. The meta-LLM call receives this summary along with the current constant values and proposes a Δ -update as a second JSON object. To prevent overfitting to a single problem geometry, the outer loop is run jointly over all three 2-D benchmarks in the publication sweep (niters=5n_iters=5 per problem), cycling through cantilever, MBB beam, and L-bracket in sequence. 3.4 Baseline Controllers Four controllers are compared against the LLM agent: Fixed controller. Applies no continuation whatsoever. The solver runs with constant p=3p=3, β=1β=1, rmin=1.5r_ =1.5, and δ=0.2δ=0.2 for all N iterations. This is the true zero-intervention baseline; it reliably produces gray material (≈0.10G≈ 0.10–0.150.15) and higher compliance. Three-field continuation. The standard academic schedule [64, 39]: p ramps linearly from 1.01.0 to 4.54.5 over 3030 iterations; β doubles every 1010 iterations after the ramp; rminr_ is tightened in the late stage. No state-dependent decisions are made. Expert heuristic. A carefully hand-crafted schedule that mimics the decisions of an experienced SIMP practitioner: step-wise p ramp (+0.75+0.75 per 1010 iterations), β raised only once p≥3.0p≥ 3.0, and a safe restart triggered only when the current compliance exceeds the best valid compliance by more than 12%12\%. This controller represents the practical performance ceiling that a domain expert can achieve without run-time feedback. Schedule-only (ablation). A fixed four-stage schedule based on the LLM agent’s advisory scaffold (table 1), executed deterministically without any LLM API calls. The stage boundaries are expressed as fixed iteration counts approximating the same budget fractions as the advisory schedule; unlike the LLM agent, no solver state is observed and no deviation from the pre-specified progression is possible. This ablation is designed to isolate the contribution of the LLM’s online adaptive decisions from the contribution of the phase structure itself. If the LLM agent outperforms schedule-only, the gain is attributable to real-time state-conditioned adaptation; if not, the phase structure alone accounts for the improvement. 3.5 Experimental Protocol and Standardized Sharpening Tail Standardized tail. A central methodological design decision is the standardized sharpening tail: all four continuation controllers — three-field continuation, expert heuristic, schedule-only ablation, and LLM agent — receive an identical 4040-iteration sharpening phase after the main loop concludes. The tail restarts from the best valid intermediate snapshot ∗ ρ^* (the density field at the iteration achieving lowest compliance while satisfying the volume constraint) and applies p=4.5p=4.5, β=32β=32, rmin=1.20r_ =1.20, δ=0.05δ=0.05 for 4040 iterations. The length of 4040 iterations was chosen to provide sufficient sharpening budget for all controller types; pilot runs confirmed that compliance changes negligibly beyond 4040 tail iterations for every controller tested. The fixed (no-continuation) controller does not receive a tail and serves as the true zero-intervention reference; its final compliance reflects 300300 iterations of constant-parameter OC updates with no sharpening. Because the tail is a shared, fixed post-processing step applied identically to the four continuation controllers, any compliance difference among them at run termination must originate exclusively from the quality of the topology produced during the main exploration loop — which is the domain of each controller. This design eliminates the confound that a controller achieving a better topology during exploration could be reporting better results due to a more aggressive sharpening tail. Benchmark problems. Experiments are conducted on three canonical 2-D benchmarks widely used in the topology optimization literature: the cantilever beam (tip load, fixed left edge), the MBB beam (three-point bending), and the L-bracket (corner re-entrant geometry with stress concentration). All use volume fraction Vf=0.40V_f=0.40, Poisson’s ratio ν=0.3ν=0.3, and Young’s modulus ratio Emin/E0=10−9E_ /E_0=10^-9. Table 4 summarises the mesh configurations used in this study. Table 4: Benchmark configurations. The primary results reported in section 4 use the 120×60120×60 long preset. The fast preset is used during meta-optimization outer-loop iterations. 3-D experiments use AMG-preconditioned conjugate-gradient via pyamg for tractable solve times. Problem Preset Mesh N VfV_f Primary? Cantilever Fast 60×3060×30 100 0.40 Long 120×60120×60 300 0.40 ✓ Hard 180×90180×90 300 0.40 MBB beam Long 120×60120×60 300 0.40 ✓ L-bracket Long 120×60120×60 300 0.40 ✓ Cantilever (3-D) — 40×20×1040×20×10 300 0.40 ✓ MBB beam (3-D) — 40×20×1040×20×10 300 0.40 ✓ Linear solver. For 2-D problems the global stiffness system =KU=F is solved by direct sparse factorisation (SciPy sparse direct solver). For 3-D problems, where the degrees of freedom exceed 8 0008\,000, an algebraic multigrid (AMG) preconditioner (pyamg) with conjugate-gradient iteration is used [6]. The AMG hierarchy is rebuilt only when the relative change in element stiffness values exceeds 15%15\%; otherwise the existing preconditioner is reused, substantially reducing overhead. Evaluation metrics. The primary metric is the final compliance C after the standardized tail. Secondary metrics are the final grayness G (all continuation methods are expected to achieve =0.000G=0.000), wall-clock time, and the iteration at which the best valid snapshot ∗ ρ^* is found. Percentage improvements are quoted relative to the fixed baseline. All results are reported as mean ± standard deviation over n=5n=5 independent random seeds. Reproducibility. The complete implementation — the three-field SIMP solver, LLM agent with system prompt, all five baseline controllers, the meta-optimization outer loop, and the experiment runner with plotting scripts — will be released as open-source software upon acceptance for publication. The repository will include single-command reproduction scripts for every table and figure in this paper. Total API cost for reproducing all experiments is under $1 1 USD. 4 Results This section presents quantitative and qualitative results for all five controllers across three 2-D benchmark problems (section 4.1), a detailed trace of LLM agent decision-making illustrating what the model actually does during a run (section 4.2), an ablation study isolating the LLM contribution (section 4.3), 3-D benchmark experiments on the cantilever and MBB beam (section 4.4), and a tail-only ablation confirming the necessity of the exploration phase (section 4.5). All 2-D results are mean ± std over n=5n=5 independent random seeds; 3-D results are likewise n=5n=5 seeds. 4.1 Primary 2-D Benchmarks Table 5 summarises results on three benchmarks at 120×60120×60 resolution with N=300N=300 main-loop iterations. Final compliance is measured after the standardized 4040-iteration sharpening tail; percentage changes are relative to the fixed baseline mean. Table 5: Primary 2-D results: mean ± std final compliance C, grayness G, improvement versus the fixed baseline, wall-clock time, and mean iteration at which the best valid snapshot ∗ ρ^* entering the sharpening tail was found (the iteration at which the tail’s starting snapshot was found). Bold: best compliance per problem. All meshes: 120×60120×60, Vf=0.40V_f=0.40, N=300N=300, n=5n=5 seeds. Problem Controller C¯±σ C±σ ¯ G vs. Fixed Time (s) Best iter Cantilever Fixed 80.978±0.00080.978± 0.000 0.0980.098 — 384.9 300.0 Three-field cont. 76.786±0.00076.786± 0.000 0.0000.000 −5.18%-5.18\% 337.4 83.0 Expert heuristic 76.474±0.01476.474± 0.014 0.0000.000 −5.56%-5.56\% 348.1 82.4 Schedule only 81.330±0.00081.330± 0.000 0.0000.000 +0.43%+0.43\% 289.0 267.6 LLM agent 76.407±0.02176.407± 0.021 0.0000.000 −5.65%-5.65\% 445.2 167.6 MBB beam Fixed 102.281±0.000102.281± 0.000 0.1460.146 — 425.3 300.0 Three-field cont. 96.759±0.01096.759± 0.010 0.0000.000 −5.40%-5.40\% 396.4 75.2 Expert heuristic 96.500±0.00096.500± 0.000 0.0000.000 −5.65%-5.65\% 366.6 287.4 Schedule only 103.393±0.001103.393± 0.001 0.0000.000 +1.09%+1.09\% 344.8 67.0 LLM agent 94.646±0.05094.646± 0.050 0.0000.000 −7.46%-7.46\% 562.4 134.4 L-bracket Fixed 46.325±0.00046.325± 0.000 0.1130.113 — 343.3 300.0 Three-field cont. 43.799±0.00743.799± 0.007 0.0000.000 −5.45%-5.45\% 268.5 81.8 Expert heuristic 43.439±0.00143.439± 0.001 0.0000.000 −6.23%-6.23\% 282.9 93.0 Schedule only 44.872±0.00044.872± 0.000 0.0000.000 −3.14%-3.14\% 248.7 262.4 LLM agent 43.028±0.00043.028± 0.000 0.0000.000 −7.12%-7.12\% 150.1 112.0 Overall ranking. The LLM agent achieves the lowest mean compliance on all three benchmarks, outperforming the next-best controller (expert heuristic) by 0.0670.067 (0.09%0.09\%) on cantilever, 1.8541.854 (1.92%1.92\%) on the MBB beam, and 0.4110.411 (0.95%0.95\%) on the L-bracket. All continuation controllers and the LLM agent converge to fully binary topologies (=0.000G=0.000), while the fixed baseline retains substantial gray material (≈0.10G≈ 0.10–0.150.15), confirming that continuation is necessary for quality binarization. Representative final density fields and element-density histograms for all five controllers are shown in fig. 6. Statistical robustness. The LLM agent shows the smallest non-zero standard deviation (σ=0.021σ=0.021 on cantilever, σ=0.050σ=0.050 on MBB beam), indicating low run-to-run variance despite the stochastic nature of LLM sampling. Figure 5 shows the full compliance distribution across all five runs. The compliance convergence curves and parameter trajectories are presented in figs. 7, 9 and 8; the key mechanistic observation — that the LLM agent defers binarization substantially longer than fixed-schedule controllers — is directly visible in these traces. (a) Cantilever. LLM agent: C¯=76.407±0.021 C=76.407± 0.021. Schedule-only worst at 81.33081.330 (+0.43%+0.43\% vs. fixed). (b) MBB beam. LLM agent: C¯=94.646±0.050 C=94.646± 0.050. Schedule-only worst at 103.393103.393 (+1.09%+1.09\% vs. fixed). (c) L-bracket. LLM agent: C¯=43.028±0.000 C=43.028± 0.000, best on all five seeds. Figure 5: Final compliance distributions (n=5n=5 runs) for all five controllers. Each panel plots the mean (filled circle) and ±3σ± 3σ interval (horizontal bars). The LLM agent achieves the lowest mean on every problem with narrow spread, confirming that gains are reproducible across random seeds. The schedule-only controller underperforms the fixed no-continuation baseline on cantilever (+0.43%+0.43\%) and MBB beam (+1.09%+1.09\%), demonstrating that rigid phase-structure adherence without state observation is actively harmful. (a) Cantilever (120×60120×60, Vf=0.40V_f=0.40, representative run). Left to right: fixed (C=80.978C=80.978, =0.098G=0.098), three-field cont. (76.78676.786, 0.0000.000), expert heuristic (76.45876.458, 0.0000.000), schedule-only (81.33081.330, 0.0000.000), LLM agent (76.38176.381, 0.0000.000). The LLM topology shows finer cross-braces and more uniformly loaded members, consistent with its later binarization at iter. 167.6167.6 (vs. 82.482.4). (b) MBB beam (120×60120×60, Vf=0.40V_f=0.40, representative run). Left to right: fixed (102.281102.281), three-field cont. (96.74496.744), expert heuristic (96.50096.500), schedule-only (103.391103.391), LLM agent (94.54794.547). The LLM agent achieves −7.46%-7.46\% vs. fixed with a denser spoke-and-arch topology that distributes the mid-span load more efficiently. (c) L-bracket (120×60120×60, Vf=0.40V_f=0.40, representative run). Left to right: fixed (46.32546.325), three-field cont. (43.79243.792), expert heuristic (43.43843.438), schedule-only (44.87244.872), LLM agent (43.02843.028). −7.12%-7.12\% vs. fixed and −0.95%-0.95\% vs. expert, with a well-connected re-entrant corner (=0.000G=0.000). Figure 6: Final physical density fields ρ~ ρ and element-density histograms for all five controllers (120×60120×60, Vf=0.40V_f=0.40, representative run). The fixed controller retains substantial gray material (>0G>0), visible as blurred member boundaries and a non-bimodal histogram. All continuation controllers achieve =0.000G=0.000 with bimodal histograms concentrated at ρ~∈0,1 ρ∈\0,1\. Compliance and grayness convergence curves. Figure 7 shows full compliance histories for the cantilever benchmark. The left panel reveals the sharp compliance spikes that the LLM agent deliberately induces by triggering restarts to recover from local minima — behaviour that is visible as the large transient near iteration 160160 in the compliance curve. The right (late-stage zoom) panel confirms that after each restart the LLM agent recovers and drives compliance below all heuristic controllers. Figure 8 shows the grayness convergence; the LLM agent maintains >0.20G>0.20 (above the grayness gate, shown as a dashed line) until approximately iteration 150150, substantially later than the fixed-schedule controllers, which cross the gate threshold around iteration 5050–8080. This directly illustrates the mechanistic claim: the LLM agent does not prematurely binarize, instead allowing the topology to form freely under lower β before committing to sharpening. Figure 7: Compliance convergence curves for the cantilever benchmark (120×60120×60, n=5n=5 seeds, shaded band = ±1σ± 1σ). Left: full 340-iteration trace (300 main loop ++ 40 tail). The large compliance spike near iteration 160160 in the LLM agent trace (orange) corresponds to aggressive Heaviside sharpening; the subsequent restart (filled marker at iteration 300300, diamond at iteration 340340) recovers compliance well below the heuristic controllers. Right: late-stage zoom (iterations 100100–350350), confirming that the LLM agent’s final compliance is consistently lower than all alternatives despite the transient spike. Figure 8: Grayness convergence (t)G(t) for the cantilever benchmark (120×60120×60, representative run). The dashed horizontal line marks the grayness gate threshold (=0.20G=0.20). The fixed controller plateaus at ≈0.10G≈ 0.10 and never achieves full binarization. All continuation controllers eventually reach =0.000G=0.000; the LLM agent crosses the gate threshold around iteration 150150—substantially later than three-field continuation (∼50 50) and the expert heuristic (∼60 60)—confirming its more patient penalization strategy. 4.2 LLM Agent Decision Trace To make the LLM agent’s behaviour interpretable, we present a detailed trace of every API call during a representative cantilever run (run 4 of 5, final compliance C=76.381C=76.381). LABEL:tab:llm_trace excerpts representative calls from each stage, showing the parameter values output, the agent’s one-line rationale, and whether any safety constraint was active. Figure 9 shows the full hyperparameter trajectories for all five controllers. Table 6: Representative LLM agent calls during a cantilever run (run 4, N=300N=300, final C=76.381C=76.381). restart =✓= indicates a snapshot reload was requested and executed (the best snapshot was valid). The Gate column marks iterations where >0.20G>0.20, indicating that the grayness gate was active and would have capped β≤8β≤ 8 had the model requested a higher value. Iter. p β rminr_ δ Gate LLM rationale (verbatim) Stage 1 — Exploration (budget 0–8%) 5 1.2 1.0 1.50 0.20 — “Stage 1 exploration, slowly increasing penal.” 15 1.6 1.0 1.50 0.20 — “Stage 1: increasing penal slightly to encourage feature definition.” 20 1.9 1.0 1.50 0.20 — “Stage 1: increasing penal to encourage structural definition.” Stage 2 — Penalization (budget 8–50%): patient p ramp, β held low 25 2.2 1.0 1.50 0.20 — “Entering Stage 2: increasing penal to drive grayness reduction.” 40 3.0 1.0 1.50 0.20 — “Stage 2: increasing penal to address stagnation and high grayness.” 50 3.4 2.0 1.50 0.20 — “Stage 2: increasing penal and beta to drive binarization.” 80 5.0 2.0 1.50 0.15 — “Grayness is low; increasing penal to 5.0 to further drive binarization.” 85 5.0 4.0 1.50 0.15 — “Grayness is low; increasing β to 4.0 to continue sharpening.” Stage 2 hold (budget 28–45%): grayness gate active (>0.20G>0.20), β held at 4 by LLM 90 5.0 4.0 1.50 0.15 ✓ “Grayness is low; maintaining Stage 2 parameters to ensure stability.”† 120 5.0 4.0 1.50 0.15 ✓ “Grayness is low; maintaining p=5.0p=5.0, β=4.0β=4.0 to stabilize.”† 130 5.0 4.0 1.50 0.15 ✓ “Grayness is low; maintaining current parameters to ensure stability.”† Stage 3 — Sharpening (budget 45–55%): β ramp begins 135 5.0 4.0 1.45 0.12 — “Stage 2 complete, entering Stage 3: reducing rminr_ and move.” 145 5.0 8.0 1.40 0.08 — “Entering Stage 3: increasing β to 8.0, reducing rminr_ /move.” 155 4.5 16.0 1.30 0.06 — “Entering Stage 3 sharpening: increasing β and reducing rminr_ .” 160 4.5 16.0 1.25 0.06 — “Stage 3 sharpening: reducing rminr_ to 1.25, maintaining β.” 165 4.5 16.0 1.20 0.06 — “Stage 3: rminr_ reduced to 1.20; compliance spike detected — restart.” Stage 4 — Converge (budget 67–100%): β=32β=32, repeated restarts 200 4.5 32.0 1.20 0.04 — “Compliance spike detected; restarting to recover from local minimum.” 225 4.5 32.0 1.20 0.04 — “Compliance spike detected; restarting to recover best valid state.” 275 4.5 32.0 1.20 0.04 — “Compliance spike extreme; triggering restart to recover from local minimum.” 300 4.5 32.0 1.20 0.04 — “Compliance spike extreme; restarting to recover best valid state.” †Rationale strings are reproduced verbatim from the LLM output log. At iterations 90–130, G remained marginally above the gate threshold (0.20<≲0.240.20<G 0.24); the deterministic safety layer capped β≤8β≤ 8 accordingly (Gate =✓= ). The model’s characterisation of grayness as “low” reflects its own interpretation of the observation vector rather than a comparison against the gate threshold, which the model does not observe directly. LABEL:tab:llm_trace reveals four distinct behavioural phases that the agent navigates autonomously, without being told which phase it is in. Stage 1 (iterations 1–24). The agent issues slow, conservative p increments (1.2→1.91.2→ 1.9) while holding β=1β=1 and rmin=1.50r_ =1.50, allowing the optimizer to form topology freely with minimal binarization pressure. This mirrors the advisory scaffold but with finer granularity: the model raises p every 55 iterations rather than applying a scheduled jump. Stage 2 (iterations 25–134): patient penalization, β gated. The agent ramps p steadily from 2.22.2 to 5.05.0 while keeping β≤4.0β≤ 4.0. The grayness gate is active for approximately 4545 iterations (iterations 85–134), during which the model requests β advances that are silently capped. This long plateau—where the agent “waits” for the topology to consolidate under high penalization before permitting Heaviside sharpening—is the primary behavioural difference from fixed-schedule controllers. Three-field continuation and the expert heuristic cross their equivalent binarization threshold around iterations 50–60; the LLM agent defers this by ≈70≈\!70–9090 iterations, buying more exploration time in the penalization landscape. Stage 3 (iterations 135–199): controlled β escalation. Once grayness drops sufficiently, the agent escalates β from 4→8→164→ 8→ 16 over ≈20≈\!20 iterations, simultaneously reducing rminr_ (1.50→1.201.50→ 1.20) and δ (0.15→0.060.15→ 0.06) to sharpen features at finer length scale. The compliance spike visible near iteration 160160 in fig. 7 is a direct consequence of the β=16β=16 transition; the agent correctly identifies this as a local minimum escape event and immediately requests a snapshot restart. Stage 4 (iterations 200–300): final convergence with persistent restarts. With β=32β=32 and rmin=1.20r_ =1.20 locked in, the agent’s primary function becomes monitoring for compliance spikes and issuing restarts to reload the best valid snapshot. The call log shows restarts at nearly every 5-iteration call window during this phase, indicating that the binary topology is sensitive to OC step perturbations at full penalization; the restart mechanism is actively preventing compliance drift away from the best-found solution. Figure 9: Hyperparameter trajectories for all five controllers on the cantilever benchmark (120×60120×60, representative run). Four subpanels show p(t)p(t), rmin(t)r_ (t), δ(t)δ(t), and β(t)β(t) over the full 340-iteration run (300 main ++ 40 tail). The LLM agent (orange) maintains β=1β=1–44 for the first ≈145≈\!145 iterations before escalating to β=32β=32, compared to the schedule-only (purple) and three-field continuation (blue) which reach β≥16β≥ 16 by iteration 80. The agent’s p trajectory overshoots to 5.05.0 during Stage 2 before pulling back to 4.54.5 at Stage 3—a deviation from the advisory schedule that is driven by grayness stagnation signals rather than the iteration counter alone. 4.3 Ablation: Isolating the LLM Contribution The schedule-only controller runs the identical four-stage phase structure as the LLM agent—the same budget breakpoints and nominal parameter targets—but without any LLM API calls. If the agent’s advantage were attributable entirely to the phase structure, schedule-only should match or approach the LLM agent’s compliance. The data show the opposite. On cantilever, schedule-only achieves C¯=81.330 C=81.330, which is +0.43%+0.43\% above the fixed baseline (worse than doing nothing) and +6.45%+6.45\% above the LLM agent. On the MBB beam, schedule-only achieves C¯=103.393 C=103.393, +1.09%+1.09\% above fixed, and +8.67%+8.67\% above the LLM agent. On the L-bracket, schedule-only improves to −3.14%-3.14\% relative to fixed but remains +4.29%+4.29\% above the LLM agent and +3.24%+3.24\% above the expert heuristic. Inspecting the parameter trajectories (fig. 9) reveals why schedule-only underperforms. The schedule commits to β=32β=32 by iteration 80—the same point where the LLM agent is still holding β=2β=2. This premature binarization crystallizes a sub-optimal topology [61]: the best valid snapshot enters the tail at iteration 67.067.0 on MBB beam and 267.6267.6 on cantilever, meaning the tail sharpens from an inferior gray intermediate rather than the topology that the LLM agent would discover by deferring binarization. These results confirm two distinct findings: (i) the four-stage advisory schedule alone provides no consistent benefit over a fixed no-continuation controller—on two of three benchmarks it actively degrades compliance; and (i) the LLM’s online state-conditioned decisions, which deviate from the nominal schedule based on the observed grayness trajectory, are the direct cause of compliance improvements. The causal attribution is: the gain belongs to real-time adaptation, not to the schedule structure. 4.4 3-D Benchmarks To validate that the LLM agent’s advantage extends beyond 2-D, we evaluate all five controllers on two 3-D benchmarks—cantilever and MBB beam—at 40×20×1040×20×10 resolution (N=300N=300, Vf=0.40V_f=0.40, n=5n=5 seeds). The substantially larger degree-of-freedom count (≈110,000≈\!110,000) necessitates AMG-preconditioned conjugate-gradient [6]. Table 7: 3-D results (40×20×1040×20×10, Vf=0.40V_f=0.40, N=300N=300, n=5n=5 seeds). Bold: best compliance per problem. The LLM agent achieves the lowest compliance on both benchmarks. The total improvement from continuation is ≈15≈\!15–18%18\% in 3-D versus 55–7%7\% in 2-D, confirming that problems without an established optimal schedule benefit most from adaptive control. Problem Controller C¯±σ C±σ ¯ G vs. Fixed Time (s) Best iter Cantilever Fixed 4.860±0.0004.860± 0.000 0.2130.213 — 1044 255 Three-field cont. 3.998±0.0013.998± 0.001 0.0000.000 −17.74%-17.74\% 994 75 Expert heuristic 3.999±0.0013.999± 0.001 0.0000.000 −17.73%-17.73\% 933 94 Schedule only 4.030±0.0004.030± 0.000 0.0000.000 −17.09%-17.09\% 746 68 LLM agent 3.981±0.0003.981± 0.000 0.0000.000 −18.09%-18.09\% 1198 157 MBB beam Fixed 6.429±0.0006.429± 0.000 0.2600.260 — 1014 — Three-field cont. 5.480±0.0015.480± 0.001 0.0000.000 −14.77%-14.77\% 1059 75 Expert heuristic 5.442±0.0015.442± 0.001 0.0000.000 −15.35%-15.35\% 1173 81 Schedule only 5.517±0.0005.517± 0.000 0.0000.000 −14.18%-14.18\% 1136 167 LLM agent 5.430±0.0015.430± 0.001 0.0000.000 −15.55%-15.55\% 1685 149 3-D cantilever. The LLM agent achieves C¯=3.981 C=3.981 (−18.09%-18.09\% vs. fixed, −0.43%-0.43\% vs. the next-best continuation baseline at C¯≈3.998 C≈ 3.998) with standard deviation σ=0.0004σ=0.0004 across five seeds, confirming that the single-seed result reported in our earlier experiments was not a statistical artefact. The total improvement from any continuation over the fixed controller is ≈18%≈\!18\% in 3-D versus only 55–7%7\% in 2-D, consistent with the expectation that problems without an established optimal schedule benefit most from adaptive control. 3-D MBB beam. The LLM agent achieves C¯=5.430 C=5.430 (−15.55%-15.55\% vs. fixed, −0.22%-0.22\% vs. the expert heuristic at C¯=5.442 C=5.442). The fixed controller retains substantial gray material (=0.260G=0.260), while all continuation controllers converge to =0.000G=0.000. The ranking mirrors the 2-D MBB results: the LLM agent outperforms all baselines, with the expert heuristic second-best and schedule-only trailing. Notably, the LLM agent’s best valid snapshot is found at iteration 149149—roughly twice as late as the three-field continuation (iteration 7575)—again demonstrating the patient penalization mechanism. Figures 10 and 11 show the 3-D density projections for all controllers on each problem. The fixed controller shows pervasive diffuse shading across all projection views, while all continuation controllers produce binary structures. The LLM agent topologies exhibit more clearly defined internal voids and load paths compared to the heuristic controllers. Figure 10: 3-D density projections (X-ray view) for the 40×20×1040×20×10 cantilever (n=5n=5 seeds, representative run). Columns: fixed, tail-only, three-field continuation, expert heuristic, schedule-only, LLM agent. Rows: xyxy, xzxz, yzyz projection directions. The fixed controller shows pervasive diffuse shading (=0.213G=0.213); all continuation controllers produce binary structures. Figure 11: 3-D density projections (X-ray view) for the 40×20×1040×20×10 MBB beam (n=5n=5 seeds, representative run). The LLM agent (rightmost, C=5.428C=5.428) shows a more compact load-carrying core than the heuristic controllers. 4.5 Tail-Only Ablation: Necessity of the Exploration Phase A natural question is whether the standardized sharpening tail alone accounts for the compliance improvements, without any contribution from the main-loop exploration phase. To answer this, we introduce a tail-only controller that performs no exploration: the main loop runs with p=1.0p=1.0 and β=1.0β=1.0 (below the validity gate p≥3.0p≥ 3.0), so that no valid best snapshot is recorded. The tail then starts from uniform density and applies the identical 4040-iteration sharpening protocol used by all other continuation controllers. Table 8 reports results on the three 2-D benchmarks at 60×3060×30 resolution (N=100N=100, n=5n=5 seeds). The tail-only controller achieves compliance 115115–141%141\% worse than the fixed no-continuation baseline on all three problems, confirming that 4040 iterations of aggressive sharpening from a blank slate are entirely insufficient to form a competitive topology. This result establishes that the exploration phase—the domain in which each controller operates—is the primary determinant of final solution quality. The standardized tail amplifies the quality of the topology it receives but cannot substitute for the exploration that produces it. Note that at the reduced 60×3060×30 resolution with only N=100N=100 iterations, the LLM agent wins on cantilever but is narrowly outperformed by fixed-schedule controllers on the MBB beam and L-bracket. This is consistent with the primary 120×60120×60 results (table 5), where the LLM agent’s advantage emerges with sufficient iteration budget (N=300N=300): the patient penalization strategy requires enough iterations to defer binarization meaningfully, and at N=100N=100 the budget is too tight for the agent to exploit its adaptive pacing advantage. Table 8: Tail-only ablation (60×3060×30, Vf=0.40V_f=0.40, N=100N=100, n=5n=5 seeds). The tail-only controller receives the identical 4040-iteration sharpening tail but starts from uniform density (no exploration). Its extreme underperformance confirms that main-loop exploration is essential. Bold: best compliance per problem. Problem Controller C¯±σ C±σ ¯ G vs. Fixed Cantilever Fixed 88.047±0.00088.047± 0.000 0.1900.190 — Tail only 211.777±0.000211.777± 0.000 0.0000.000 +140.5%+140.5\% Three-field cont. 79.449±0.00079.449± 0.000 0.0000.000 −9.76%-9.76\% Expert heuristic 79.486±0.00079.486± 0.000 0.0000.000 −9.72%-9.72\% Schedule only 83.082±0.00083.082± 0.000 0.0000.000 −5.64%-5.64\% LLM agent 79.301±0.08679.301± 0.086 0.0000.000 −9.93%-9.93\% MBB beam Fixed 109.723±0.000109.723± 0.000 0.2030.203 — Tail only 246.560±0.000246.560± 0.000 0.0000.000 +124.7%+124.7\% Three-field cont. 96.323±0.00096.323± 0.000 0.0000.000 −12.21%-12.21\% Expert heuristic 96.695±0.00096.695± 0.000 0.0000.000 −11.87%-11.87\% Schedule only 99.638±0.00099.638± 0.000 0.0000.000 −9.19%-9.19\% LLM agent 96.980±0.00096.980± 0.000 0.0000.000 −11.61%-11.61\% L-bracket Fixed 49.221±0.00049.221± 0.000 0.1860.186 — Tail only 105.645±0.000105.645± 0.000 0.0000.000 +114.6%+114.6\% Three-field cont. 43.518±0.00043.518± 0.000 0.0000.000 −11.59%-11.59\% Expert heuristic 43.437±0.00043.437± 0.000 0.0000.000 −11.75%-11.75\% Schedule only 44.413±0.00044.413± 0.000 0.0000.000 −9.77%-9.77\% LLM agent 43.537±0.00043.537± 0.000 0.0000.000 −11.55%-11.55\% 5 Discussion 5.1 Why the LLM Outperforms Fixed Schedules: The Patient Penalization Mechanism The central empirical finding of this work is that the LLM agent consistently locates its best valid intermediate snapshot later in the run than any fixed-schedule controller—at iteration 167.6167.6 on cantilever versus 82.482.4 for the expert heuristic, and at iteration 134.4134.4 on the MBB beam versus 75.275.2 for three-field continuation. This timing difference is not incidental: it is the direct consequence of the grayness gate preventing premature β escalation. By holding β≤8β≤ 8 while >0.20G>0.20 (active for roughly 45–70 iterations in each run), the agent allows the OC optimizer to continue reshaping the density field under moderate penalization rather than crystallizing topology prematurely into a near-binary form [39, 58]. The superior intermediate topology found during this extended penalization phase—lower in compliance even before the sharpening tail—then becomes the starting point for the standardized tail, which sharpens whichever topology it receives. This behaviour is consistent with the curriculum learning insight that premature difficulty increases harm convergence [11]: by deferring the hardest constraint (full binarization) until the optimizer is ready, the agent avoids the local minima that fixed-schedule controllers fall into. Because the tail is identical for all controllers, the compliance ordering at run end directly reflects the quality of the exploration-phase topology: the agent’s patient approach finds a better gray-topology basin that the tail can sharpen to a lower final compliance. This mechanism also explains why the schedule-only ablation fails. The schedule-only controller applies the same budget-breakpoint logic but without observing actual (t)G(t), so it advances β at a fixed iteration count regardless of whether the topology is ready. On the MBB beam, schedule-only’s best snapshot enters the tail at iteration 67.067.0—a premature commitment made before the topology has consolidated—while the LLM agent waits until iteration 134.4134.4. The schedule-only final compliance of 103.393103.393 (+1.09%+1.09\% vs. the fixed no-intervention baseline) confirms that a pre-specified schedule is not merely ineffective but actively harmful when applied rigidly: the phase transitions lock in parameter progressions that do not match the actual grayness trajectory of the run. 5.2 Interpretability and Auditability A distinctive property of the DNC interface is that every parameter decision is accompanied by a one-line rationale emitted by the model (see LABEL:tab:llm_trace). Unlike neural surrogate controllers or reinforcement-learned policies [51, 35, 27], the LLM agent provides a natural-language account of each action: the rationale strings in LABEL:tab:llm_trace allow an engineer to audit the agent’s logic at any point in the run and to detect failure modes such as premature binarization or miscalibrated restart triggers without inspecting the underlying model weights. This interpretability is particularly valuable in structural design contexts where decisions must be justifiable and where unexpected topologies can carry safety implications. The call trace also reveals a limitation: during Stage 4 (iterations 200200–300300), the agent repeatedly emits “compliance spike detected; restarting” regardless of whether the actual compliance has spiked or whether a restart will help. Inspection of the compliance curves (fig. 7) shows that many of these restarts are genuine recoveries from OC perturbation, but some are redundant—the topology at that iteration was already binary and stable. This suggests that the system prompt’s spike-detection language is over-fitted to early-stage behavior and could be refined to reduce unnecessary API calls in the converge stage. A second interpretability concern is visible in LABEL:tab:llm_trace during the Stage 2 hold (iterations 90–130): the agent characterises grayness as “low” even though G remains above the gate threshold (0.20<≲0.240.20<G 0.24) and the deterministic safety layer is actively capping β≤8β≤ 8. The model does not observe the gate threshold directly; its assessment of “low” reflects a comparison against the full [0,1][0,1] range rather than against the engineered safety bound. In this case the mislabelling is harmless—the safety layer enforces the correct behaviour regardless of the rationale—but it illustrates that natural-language rationales can be misleading when the model lacks explicit access to the thresholds that govern its actions. Future iterations could mitigate this by including the gate threshold value in the observation vector or by post-hoc flagging rationales that conflict with active safety constraints. 5.3 Computational Overhead The LLM agent incurs a wall-clock overhead relative to deterministic controllers: 445.2445.2 s versus 337.4337.4 s for three-field continuation on cantilever, and 562.4562.4 s versus 396.4396.4 s on the MBB beam — a 3232–42%42\% increase. This overhead has two components: the API latency per call (≈1≈\!1–33 s per call at k=5k=5, for ≈60≈\!60 calls per 300-iter run) and any additional restart iterations triggered by the agent. The L-bracket result (150.1150.1 s for the LLM agent versus 282.9282.9 s for the expert heuristic) is anomalously fast: post-hoc analysis indicates that the agent converged to a stable binary topology early and triggered few restarts, reducing the effective run length. For production use, the API overhead could be substantially reduced by batching calls, using a locally-hosted model, or increasing the call interval k in the converge phase where the agent’s decisions are near-deterministic. API cost. The model used throughout is gemini-3.1-flash-lite-preview (Google, accessed March 2026), a lightweight variant of the Gemini family [31]. Each API call transmits ≈500≈\!500 input tokens (system prompt plus the serialised state observation) and receives ≈50≈\!50 output tokens (a single JSON object), with a 200-token output cap. A complete five-controller comparison on three 2-D benchmarks with n=5n=5 seeds generates ≈900≈\!900 inner-loop calls plus ≈60≈\!60 calls for the 3-D experiment; the meta-optimization outer loop adds ≈24≈\!24 calls. At current Gemini Flash Lite pricing, the total cost of all experiments reported in this paper — including all meta-optimization iterations — is under $1 1 USD. This negligible cost contrasts sharply with RL-based DAC approaches, which require thousands of full solver evaluations to train a policy, and demonstrates that LLM-based adaptive control is economically viable even for academic research budgets. The 3-D experiment demonstrates that the approach scales to larger degree-of-freedom problems: at 40×20×1040×20×10 (≈110,000≈\!110,000 DOFs), the LLM agent achieves the lowest compliance (3.9813.981, −18.09%-18.09\% vs. fixed) with a wall-clock time of 1,1981,198 s against 1,0441,044 s for the fixed controller. 5.4 Broader Implications for AI-Assisted Computational Mechanics The results in this paper point to a more general paradigm that extends beyond topology optimization. Many iterative numerical methods in computational mechanics—nonlinear finite-element solvers, mesh-adaptive schemes, time-integration methods—rely on hyperparameter schedules (load increments, mesh refinement thresholds, time-step sizes) that are calibrated offline and applied open-loop. The closed-loop architecture demonstrated here—observe solver state, reason about it in natural language, emit numerical actions, enforce physical safety rails—is transferable in principle to any setting where (i) the solver exposes a compact state representation, (i) domain knowledge about good schedules exists but is difficult to formalise as a deterministic rule, and (i) the cost of an API call is small relative to the cost of one solver iteration. Three conceptual insights from this work are worth highlighting for the computational mechanics community. First, informal domain knowledge is a deployable asset. The system prompt encodes advice that any experienced SIMP user would give a student—“do not sharpen while the topology is still gray,” “raise penalization before raising β”—but this advice has not previously been translated into a formal, adaptive algorithm. The LLM acts as a bridge between qualitative expertise and quantitative control, and the natural-language interface makes the encoding of new domain rules straightforward compared to designing reward functions for reinforcement learning or feature spaces for Bayesian optimisation. Second, interpretability is a structural advantage, not a convenience. In safety-critical structural design, the ability to audit every parameter decision in natural language—and to trace a compliance anomaly back to the specific rationale the agent gave at the iteration where it occurred—provides a form of accountability that opaque learned policies cannot match. The DNC architecture produces a human-readable call log that can be reviewed post-hoc by the engineer, enabling a collaborative workflow in which the LLM proposes and the human verifies. Third, the patient penalization principle is model-independent. Although it was discovered through LLM-guided exploration, the core finding—that deferring Heaviside sharpening until grayness falls below a threshold yields better topologies—is a deterministic rule that can be implemented without any LLM. This suggests a productive research pattern: use LLM agents to explore adaptive strategies in a new solver setting, then distill the successful strategies into lightweight deterministic rules for production deployment. Such a pattern combines the flexibility of LLM-guided search with the reproducibility and zero-cost execution of a hard-coded heuristic. 5.5 Limitations and Open Questions Several limitations qualify the current findings. LLM model dependency and reproducibility. All results use the gemini-3.1-flash-lite-preview model (Google) [31] at temperature 0 with structured JSON output mode. The LLM agent’s behaviour depends on the specific model version: a change in model weights could alter the parameter trajectories even with an identical system prompt. Reproducibility requires pinning the exact model version and documenting the prompt verbatim — both of which will be included in the public code release, along with the complete source code for the solver, agent, baselines, and meta-optimizer. Importantly, the model used is a lightweight, low-cost variant: total API expenditure for all experiments in this paper is under $1 1 USD, making independent replication economically trivial. Whether other frontier models (e.g., GPT-4 [45], Claude [5]) or open-weight models produce similar trajectories is an open question; preliminary experiments suggest qualitatively similar behaviour but quantitatively different p and β timings. Scope: compliance minimization only. This work focuses exclusively on single-load-case compliance minimization. The advisory schedule and grayness gate have been designed for this objective; extension to stress-constrained problems, multi-load cases, or manufacturing constraints (e.g., minimum member size, overhang angle) [39] would require modifications to the observation vector and system prompt that have not been validated. Meta-optimization convergence. The outer hyperparameter loop was run for niters=5n_iters=5 per problem, which is sufficient to tune the grayness-gate threshold and the call interval but may be insufficient to fully converge the phase timing constants. A more thorough meta-optimization sweep — or a Bayesian optimization over the meta-parameters [51] — could further improve the agent’s default hyperparameters. Confound: meta-loop vs. online adaptation. The current experiments cannot fully decouple the contribution of the meta-optimization loop from the online LLM decisions. Running the LLM agent with un-tuned hyperparameters (pre-meta-loop) would quantify how much of the observed improvement is attributable to the meta-loop versus the agent’s real-time adaptation within each run — a distinction analogous to the algorithm-configuration vs. online-policy split in the DAC literature [3, 13]. This ablation is planned for the journal revision. 6 Conclusion We have presented an LLM-guided online continuation controller for three-field SIMP topology optimization, in which a Gemini Flash Lite language model (gemini-3.1-flash-lite-preview) observes structured solver state at every k-th iteration and outputs exact numerical values for the penalization exponent p, Heaviside sharpness β, filter radius rminr_ , and OC move limit δ via a Direct Numeric Control interface. A two-level architecture is employed: the inner agent adapts solver parameters within each run guided by a grayness gate that prevents premature binarization; the outer meta-optimization loop uses a second LLM pass to tune the agent’s own hyperparameters across successive runs. Across all eight experimental conditions tested — three 2-D benchmarks at n=5n=5 seeds each, two 3-D benchmarks at n=5n=5 seeds each — the LLM agent achieves the lowest final compliance after a standardized sharpening tail that is shared identically across all four continuation controllers. The improvements are −5.65%-5.65\% (cantilever), −7.46%-7.46\% (MBB beam), −7.12%-7.12\% (L-bracket), −18.09%-18.09\% (3-D cantilever), and −15.55%-15.55\% (3-D MBB beam) relative to the fixed no-continuation baseline. The LLM agent outperforms the best manually-designed expert heuristic by 0.09%0.09\%, 1.92%1.92\%, and 0.95%0.95\% on the three 2-D benchmarks respectively — modest margins in 2-D that widen substantially in the 3-D setting where no established optimal schedule exists. A tail-only ablation—which applies the identical sharpening tail from uniform density without any exploration—achieves compliance 115115–141%141\% worse than the fixed baseline, confirming that the exploration phase is the primary determinant of final solution quality. The core finding is that these gains are not attributable to the four-stage schedule structure encoded in the system prompt. The schedule-only ablation — which applies the same phase structure deterministically without LLM calls — underperforms the fixed no-continuation baseline on two of three 2-D benchmarks, confirming that the LLM’s real-time state-conditioned decisions are the causal source of improvement. The mechanism is the patient penalization strategy: the grayness gate defers β escalation by ≈70≈\!70–9090 iterations relative to fixed-schedule controllers, allowing the optimizer to find a structurally superior gray topology before committing to binarization. These results establish three broader contributions that extend beyond the specific benchmarks reported. First, they demonstrate that LLM agents can function as effective, interpretable optimization controllers in a domain (SIMP topology optimization) that requires precise numerical reasoning and physical domain knowledge, without any fine-tuning on topology optimization data—establishing a new paradigm for zero-shot dynamic algorithm configuration in computational mechanics. Second, the Direct Numeric Control paradigm — outputting floating-point values with a natural-language rationale at each decision step — provides both better performance than phase-label architectures and a natural audit trail for engineering decision-making, offering a template for LLM-assisted control of other iterative numerical solvers. Third, the patient penalization principle discovered through LLM-guided exploration—defer Heaviside sharpening until grayness falls below a threshold—is a transferable insight for the SIMP community that can be implemented as a simple deterministic rule independently of any LLM, demonstrating that LLM agents can serve as a discovery tool for new solver heuristics. The agent’s behaviour generalizes from 2-D to 3-D without any modification to the system prompt, suggesting that the encoded domain knowledge transfers across problem dimensionality. Future work will pursue extension to stress-constrained and multi-load-case problems, cross-model comparison to establish whether the patient penalization strategy is a general property of frontier LLM reasoning or specific to the training data of the particular model used, and decoupled ablation of the meta-optimization loop to quantify its contribution independently of the agent’s real-time decisions. Code availability The complete source code for reproducing all results in this paper — including the three-field SIMP solver, LLM agent, all baseline controllers, the meta-optimization loop scripts — will be made publicly available upon acceptance for publication in a peer-reviewed venue. References [1] N. Aage, E. Andreassen, B. S. Lazarov, and O. Sigmund (2017) Giga-voxel computational morphogenesis for structural design. Nature 550 (7674), p. 84–86. External Links: Document Cited by: §2.1. [2] D. W. Abueidda, S. Koric, and N. A. Sobh (2020) Topology optimization of 2D structures with nonlinearities using deep learning. Computers & Structures 237, p. 106283. External Links: Document Cited by: §2.2. [3] S. Adriaensen, A. Biedenkapp, G. Shala, N. Awad, T. Eimer, M. Lindauer, and F. Hutter (2022) Automated dynamic algorithm configuration. Journal of Artificial Intelligence Research 75, p. 1633–1699. External Links: Document Cited by: §1.3, §2.3, §2.4, §5.5. [4] E. Andreassen, A. Clausen, M. Schevenels, B. S. Lazarov, and O. Sigmund (2011) Efficient topology optimization in MATLAB using 88 lines of code. Structural and Multidisciplinary Optimization 43 (1), p. 1–16. External Links: Document Cited by: §2.1. [5] Anthropic (2024) The Claude model card and evaluations. Note: Anthropic System Cardshttps://w.anthropic.com/system-cards Cited by: §1.3, §5.5. [6] N. Bell, L. N. Olson, J. Schroder, and B. Southworth (2023) PyAMG: algebraic multigrid solvers in Python. Journal of Open Source Software 8 (87), p. 5495. External Links: Document Cited by: §2.1, §3.5, §4.4. [7] M. P. Bendsøe and N. Kikuchi (1988) Generating optimal topologies in structural design using a homogenization based method. Computer Methods in Applied Mechanics and Engineering 71 (2), p. 197–224. External Links: Document Cited by: §2.1. [8] M. P. Bendsøe and O. Sigmund (1999) Material interpolation schemes in topology optimization. Archive of Applied Mechanics 69 (9–10), p. 635–654. External Links: Document Cited by: §2.1. [9] M. P. Bendsøe (1989) Optimal shape design as a material distribution problem. Structural Optimization 1 (4), p. 193–202. External Links: Document Cited by: §1.1, §2.1, §3.1. [10] Y. Bengio, A. Lodi, and A. Prouvost (2021) Machine learning for combinatorial optimization: a methodological tour d’horizon. European Journal of Operational Research 290 (2), p. 405–421. External Links: Document Cited by: §1.3, §2.4. [11] Y. Bengio, J. Louradour, R. Collobert, and J. Weston (2009) Curriculum learning. In Proceedings of the 26th Annual International Conference on Machine Learning (ICML), p. 41–48. External Links: Document Cited by: §1.3, §2.4, §5.1. [12] J. Bergstra, R. Bardenet, Y. Bengio, and B. Kégl (2011) Algorithms for hyper-parameter optimization. In Advances in Neural Information Processing Systems, Vol. 24, p. 2546–2554. Cited by: §2.3. [13] A. Biedenkapp, H. F. Bozkurt, T. Eimer, F. Hutter, and M. Lindauer (2020) Dynamic algorithm configuration: foundation of a new meta-algorithmic framework. In Proceedings of the 24th European Conference on Artificial Intelligence (ECAI 2020), p. 427–434. External Links: Document Cited by: §1.3, §2.3, §5.5. [14] B. Bischl, M. Binder, M. Lang, T. Pielok, J. Richter, S. Coors, J. Thomas, T. Ullmann, M. Becker, A. Boulesteix, D. Deng, and M. Lindauer (2023) Hyperparameter optimization: foundations, algorithms, best practices, and open challenges. WIREs Data Mining and Knowledge Discovery 13 (2), p. e1484. External Links: Document Cited by: §2.3. [15] D. A. Boiko, R. MacKnight, B. Kline, and G. Gomes (2023) Autonomous chemical research with large language models. Nature 624 (7992), p. 570–578. External Links: Document Cited by: §1.3, §2.4. [16] B. Bourdin (2001) Filters in topology optimization. International Journal for Numerical Methods in Engineering 50 (9), p. 2143–2158. External Links: Document Cited by: §2.1, §3.1. [17] N. K. Brown, A. P. Garland, G. M. Fadel, and G. Li (2022) Deep reinforcement learning for engineering design through topology optimization of elementally discretized design domains. Materials & Design 218, p. 110672. External Links: Document Cited by: §2.2. [18] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, S. Agarwal, A. Herbert-Voss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. M. Ziegler, J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner, S. McCandlish, A. Radford, I. Sutskever, and D. Amodei (2020) Language models are few-shot learners. Advances in Neural Information Processing Systems 33, p. 1877–1901. Cited by: §2.4. [19] T. E. Bruns and D. A. Tortorelli (2001) Topology optimization of non-linear elastic structures and compliant mechanisms. Computer Methods in Applied Mechanics and Engineering 190 (26–27), p. 3443–3459. External Links: Document Cited by: §2.1. [20] R. Cang, H. Yao, and Y. Ren (2019) One-shot generation of near-optimal topology through theory-driven machine learning. Computer-Aided Design 109, p. 12–21. External Links: Document Cited by: §2.2. [21] A. Chandrasekhar and K. Suresh (2021) TOuNN: topology optimization using neural networks. Structural and Multidisciplinary Optimization 63 (3), p. 1135–1149. External Links: Document Cited by: §2.2. [22] M. Chen, J. Tworek, H. Jun, Q. Yuan, H. P. de Oliveira Pinto, J. Kaplan, H. Edwards, Y. Burda, N. Joseph, G. Brockman, A. Ray, R. Puri, G. Krueger, M. Petrov, H. Khlaaf, G. Sastry, P. Mishkin, B. Chan, S. Gray, N. Ryder, M. Pavlov, A. Power, L. Kaiser, M. Bavarian, C. Winter, P. Tillet, F. P. Such, D. Cummings, M. Plappert, F. Chantzis, E. Barnes, A. Herbert-Voss, W. H. Guss, A. Nichol, A. Paino, N. Tezak, J. Tang, I. Babuschkin, S. Balaji, S. Jain, W. Saunders, C. Hesse, A. N. Carr, J. Leike, J. Achiam, V. Misra, E. Morikawa, A. Radford, M. Knight, M. Brundage, M. Murati, K. Mayer, P. Welinder, B. McGrew, D. Amodei, S. McCandlish, I. Sutskever, and W. Zaremba (2021) Evaluating large language models trained on code. Technical report Technical Report arXiv:2107.03374, OpenAI. Note: arXiv preprint Cited by: §1.3. [23] J. D. Deaton and R. V. Grandhi (2014) A survey of structural and multidisciplinary continuum topology optimization: post 2000. Structural and Multidisciplinary Optimization 49 (1), p. 1–38. External Links: Document Cited by: §2.1. [24] C. Deng, Y. Wang, C. Qin, Y. Fu, and W. Lu (2022) Self-directed online machine learning for topology optimization. Nature Communications 13 (1), p. 388. External Links: Document Cited by: §2.2. [25] D. Driess, F. Xia, M. S. M. Sajjadi, C. Lynch, A. Chowdhery, B. Ichter, A. Wahid, J. Tompson, Q. Vuong, T. Yu, W. Huang, Y. Chebotar, P. Sermanet, D. Duckworth, S. Levine, V. Vanhoucke, K. Hausman, M. Toussaint, K. Greff, A. Zeng, I. Mordatch, and P. Florence (2023) PaLM-E: an embodied multimodal language model. In International Conference on Machine Learning, p. 8469–8488. Cited by: §1.3, §2.4. [26] P. Dunning and F. Wein (2025) Automatic projection parameter increase for three-field density-based topology optimization. Structural and Multidisciplinary Optimization 68 (2), p. 33. External Links: Document Cited by: §1.3, §2.1. [27] T. Eimer, A. Biedenkapp, M. Reimer, S. Adriaensen, F. Hutter, and M. Lindauer (2021) DACBench: a benchmark library for dynamic algorithm configuration. In Proceedings of the 30th International Joint Conference on Artificial Intelligence (IJCAI-21), p. 1668–1674. External Links: Document Cited by: §2.3, §5.2. [28] F. Ferrari and O. Sigmund (2020) A new generation 99 line Matlab code for compliance topology optimization and its extension to 3D. Structural and Multidisciplinary Optimization 62, p. 2211–2228. External Links: Document Cited by: §2.1. [29] J. K. Guest, A. Asadpoure, and S. Ha (2011) Eliminating beta-continuation from Heaviside projection and density filter algorithms. Structural and Multidisciplinary Optimization 44 (4), p. 443–453. External Links: Document Cited by: §2.1. [30] J. K. Guest, J. H. Prévost, and T. Belytschko (2004) Achieving minimum length scale in topology optimization using nodal design variables and projection functions. International Journal for Numerical Methods in Engineering 61 (2), p. 238–254. External Links: Document Cited by: §2.1, §3.1. [31] D. Hassabis and K. Kavukcuoglu (2024-12) Introducing Gemini 2.0: our new AI model for the agentic era. Note: Google DeepMind Bloghttps://blog.google/technology/google-deepmind/google-gemini-ai-update-december-2024/ Cited by: §1.3, §5.3, §5.5. [32] K. Hayashi and M. Ohsaki (2020) Reinforcement learning and graph embedding for binary truss topology optimization under stress and displacement constraints. Frontiers in Built Environment 6, p. 59. External Links: Document Cited by: §2.2. [33] S. Hoyer, J. Sohl-Dickstein, and S. Greydanus (2019) Neural reparameterization improves structural optimization. Technical report Technical Report arXiv:1909.04240, arXiv. Note: arXiv preprint Cited by: §2.2. [34] F. Hutter, H. H. Hoos, and K. Leyton-Brown (2011) Sequential model-based optimization for general algorithm configuration. In Learning and Intelligent Optimization (LION 5), Lecture Notes in Computer Science, Vol. 6683, p. 507–523. External Links: Document Cited by: §2.3, §2.3. [35] F. Hutter, L. Kotthoff, and J. Vanschoren (Eds.) (2019) Automated machine learning: methods, systems, challenges. Springer, Cham. External Links: Document Cited by: §1.3, §2.3, §5.2. [36] M. Jaderberg, V. Dalibard, S. Osindero, W. M. Czarnecki, J. Donahue, A. Razavi, O. Vinyals, T. Green, I. Dunning, K. Simonyan, C. Fernando, and K. Kavukcuoglu (2017) Population based training of neural networks. Technical report Technical Report arXiv:1711.09846, arXiv. Note: arXiv preprint Cited by: §2.3, §2.3. [37] N. Ath. Kallioras, G. Kazakis, and N. D. Lagaros (2020) Accelerated topology optimization by means of deep learning. Structural and Multidisciplinary Optimization 62 (3), p. 1185–1212. External Links: Document Cited by: §2.2. [38] B. S. Lazarov and O. Sigmund (2011) Filters in topology optimization based on Helmholtz-type differential equations. International Journal for Numerical Methods in Engineering 86 (6), p. 765–781. External Links: Document Cited by: §2.1. [39] B. S. Lazarov, F. Wang, and O. Sigmund (2016) Length scale and manufacturability in density-based topology optimization. Archive of Applied Mechanics 86 (1), p. 189–218. External Links: Document Cited by: §1.1, §1.1, §2.1, §3.2, §3.4, §5.1, §5.5. [40] L. Li, K. Jamieson, G. DeSalvo, A. Rostamizadeh, and A. Talwalkar (2018) Hyperband: a novel bandit-based approach to hyperparameter optimization. Journal of Machine Learning Research 18 (185), p. 1–52. Cited by: §2.3. [41] S. Liu, C. Chen, X. Qu, K. Tang, and Y. Ong (2024) Large language models as evolutionary optimizers. In 2024 IEEE Congress on Evolutionary Computation (CEC), p. 1–8. External Links: Document Cited by: §1.3. [42] A. Madaan, N. Tandon, P. Gupta, S. Hallinan, L. Gao, S. Wiegreffe, U. Alon, N. Dziri, S. Prabhumoye, Y. Yang, S. Gupta, B. P. Majumder, K. Hermann, S. Welleck, A. Yazdanbakhsh, and P. Clark (2023) Self-Refine: iterative refinement with self-feedback. In Advances in Neural Information Processing Systems, Vol. 36, p. 1127–1148. Cited by: §2.4. [43] F. Mazé and F. Ahmed (2023) Diffusion models beat GANs on topology optimization. Proceedings of the AAAI Conference on Artificial Intelligence 37 (8), p. 9108–9116. External Links: Document Cited by: §2.2. [44] Z. Nie, T. Lin, H. Jiang, and L. B. Kara (2021) TopologyGAN: topology optimization using generative adversarial networks based on physical fields over the initial domain. ASME Journal of Mechanical Design 143 (3), p. 031715. External Links: Document Cited by: §2.2. [45] OpenAI (2023) GPT-4 technical report. Technical report Technical Report arXiv:2303.08774, OpenAI. Note: arXiv preprint Cited by: §1.3, §5.5. [46] J. S. Park, J. C. O’Brien, C. J. Cai, M. R. Morris, P. Liang, and M. S. Bernstein (2023) Generative agents: interactive simulacra of human behavior. In ACM Symposium on User Interface Software and Technology, p. 1–22. External Links: Document Cited by: §1.3. [47] T. Rios, S. Menzel, M. Wong, and Y. Ong (2024) Large language and text-to-3D models for engineering design optimization. In 2024 IEEE Congress on Evolutionary Computation (CEC), p. 1–8. External Links: Document Cited by: §2.4. [48] S. Rojas-Labanda and M. Stolpe (2015) Automatic penalty continuation in structural topology optimization. Structural and Multidisciplinary Optimization 52 (6), p. 1205–1221. External Links: Document Cited by: §1.3, §2.1. [49] B. Romera-Paredes, M. Barekatain, A. Novikov, M. Balog, M. P. Kumar, E. Dupont, F. J. Ruiz, J. S. Ellenberg, P. Wang, O. Fawzi, et al. (2024) Mathematical discoveries from program search with large language models. Nature 625 (7995), p. 468–475. External Links: Document Cited by: §2.4, §2.4. [50] T. Schick, J. Dwivedi-Yu, R. Dessì, R. Raileanu, M. Lomeli, L. Zettlemoyer, N. Cancedda, and T. Scialom (2023) Toolformer: language models can teach themselves to use tools. In Advances in Neural Information Processing Systems, Vol. 36, p. 2510–2544. Cited by: §2.4. [51] B. Shahriari, K. Swersky, Z. Wang, R. P. Adams, and N. de Freitas (2016) Taking the human out of the loop: A review of Bayesian optimization. Proceedings of the IEEE 104 (1), p. 148–175. External Links: Document Cited by: §1.3, §2.3, §5.2, §5.5. [52] G. Shala, A. Biedenkapp, N. Awad, S. Adriaensen, M. Lindauer, and F. Hutter (2020) Learning step-size adaptation in CMA-ES. In Parallel Problem Solving from Nature (PPSN XVI), Lecture Notes in Computer Science, Vol. 12269, p. 691–706. Cited by: §2.3. [53] S. Shin, D. Shin, and N. Kang (2023) Topology optimization via machine learning and deep learning: a review. Journal of Computational Design and Engineering 10 (4), p. 1736–1766. External Links: Document Cited by: §2.2. [54] N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao (2023) Reflexion: language agents with verbal reinforcement learning. In Advances in Neural Information Processing Systems, Vol. 36, p. 8634–8652. Cited by: §2.4. [55] O. Sigmund and K. Maute (2013) Topology optimization approaches. Structural and Multidisciplinary Optimization 48 (6), p. 1031–1055. External Links: Document Cited by: §2.1. [56] O. Sigmund and J. Petersson (1998) Numerical instabilities in topology optimization: a survey on procedures dealing with checkerboards, mesh-dependencies and local minima. Structural Optimization 16 (1), p. 68–75. External Links: Document Cited by: §3.1. [57] O. Sigmund (2001) A 99 line topology optimization code written in Matlab. Structural and Multidisciplinary Optimization 21 (2), p. 120–127. External Links: Document Cited by: §1.1, §2.1. [58] O. Sigmund (2007) Morphology-based black and white filters for topology optimization. Structural and Multidisciplinary Optimization 33 (4-5), p. 401–424. External Links: Document Cited by: §1.1, §2.1, §3.1, §3.2, §5.1. [59] J. Snoek, H. Larochelle, and R. P. Adams (2012) Practical Bayesian optimization of machine learning algorithms. In Advances in Neural Information Processing Systems, Vol. 25, p. 2951–2959. Cited by: §2.3. [60] I. Sosnovik and I. Oseledets (2019) Neural networks for topology optimization. Russian Journal of Numerical Analysis and Mathematical Modelling 34 (4), p. 215–223. External Links: Document Cited by: §2.2. [61] M. Stolpe and K. Svanberg (2001) On the trajectories of penalization methods for topology optimization. Structural and Multidisciplinary Optimization 21 (2), p. 128–139. External Links: Document Cited by: §2.1, §4.3. [62] K. Svanberg (1987) The method of moving asymptotes — a new method for structural optimization. International Journal for Numerical Methods in Engineering 24 (2), p. 359–373. External Links: Document Cited by: §2.1. [63] K. Svanberg (2002) A class of globally convergent optimization methods based on conservative convex separable approximations. SIAM Journal on Optimization 12 (2), p. 555–573. External Links: Document Cited by: §2.1. [64] F. Wang, B. S. Lazarov, and O. Sigmund (2011) On projection methods, convergence and robust formulations in topology optimization. Structural and Multidisciplinary Optimization 43 (6), p. 767–784. External Links: Document Cited by: §1.1, §1.1, §1.1, §2.1, §3.1, §3.1, §3.4. [65] G. Wang, Y. Xie, Y. Jiang, A. Mandlekar, C. Xiao, Y. Zhu, L. Fan, and A. Anandkumar (2024) Voyager: an open-ended embodied agent with large language models. Transactions on Machine Learning Research, p. 1–27. Note: https://openreview.net/forum?id=ehfRiF0R3a Cited by: §2.4. [66] J. Wei, X. Wang, D. Schuurmans, M. Bosma, B. Ichter, F. Xia, E. Chi, Q. Le, and D. Zhou (2022) Chain-of-thought prompting elicits reasoning in large language models. In Advances in Neural Information Processing Systems, Vol. 35, p. 24824–24837. Cited by: §1.3, §1.3, §2.4. [67] R. V. Woldseth, N. Aage, J. A. Bærentzen, and O. Sigmund (2022) On the use of artificial neural networks in topology optimisation. Structural and Multidisciplinary Optimization 65 (10), p. 294. External Links: Document Cited by: §2.2. [68] X. Wu, S. Wu, J. Wu, L. Feng, and K. C. Tan (2024) Evolutionary computation in the era of large language model: survey and roadmap. IEEE Transactions on Evolutionary Computation 29 (2), p. 534–554. External Links: Document Cited by: §2.4. [69] C. Yang, X. Wang, Y. Lu, H. Liu, Q. V. Le, D. Zhou, and X. Chen (2024) Large language models as optimizers. In The Twelfth International Conference on Learning Representations, Note: https://openreview.net/forum?id=Bb4VGOWELI Cited by: §2.4. [70] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao (2023) ReAct: synergizing reasoning and acting in language models. In International Conference on Learning Representations, Note: https://openreview.net/forum?id=WE_vluYUL-X Cited by: §1.3, §1.3, §2.4. [71] H. Ye, J. Wang, Z. Cao, F. Berto, C. Hua, H. Kim, J. Park, and G. Song (2024) ReEvo: large language models as hyper-heuristics with reflective evolution. In Advances in Neural Information Processing Systems, Note: https://proceedings.neurips.c/paper_files/paper/2024/hash/4ced59d480e07d290b6f29fc8798f195-Abstract-Conference.html Cited by: §2.4. [72] Y. Yu, T. Hur, J. Jung, and I. G. Jang (2019) Deep learning for determining a near-optimal topological design without any iteration. Structural and Multidisciplinary Optimization 59 (3), p. 787–799. External Links: Document Cited by: §2.2. [73] M. Zhou and G. I. N. Rozvany (1991) The COC algorithm, Part I: topological, geometrical and generalized shape optimization. Computer Methods in Applied Mechanics and Engineering 89 (1–3), p. 309–336. External Links: Document Cited by: §2.1.

Instant research discovery