Technical Summary: Self-Refining Topology Optimization via an LLM-Based Multi-Agent Framework

1. Problem Statement

Topology optimization is a computational design method used to determine optimal material distributions within a prescribed domain. While the numerical algorithms for solving these problems are well-established, the workflow traditionally relies heavily on continuous, expertise-intensive human intervention. Engineers must manually translate design requirements into mathematical specifications, adjust numerical parameters (e.g., filter radii, projection sharpness), resolve computational errors, and perform multimodal assessments of the converged design (checking for physical feasibility, checkerboard patterns, and convergence stability).

Current Large Language Models (LLMs) show promise in automating engineering tasks, but single-pass LLM approaches often fail in topology optimization. This is because the process is not a simple generation task; it requires iterative refinement across multiple stages (formulation, coding, execution, and post-convergence assessment). A single LLM often struggles with problems that deviate from its pre-training distribution, such as stress-driven formulations or specific boundary condition variations, leading to non-convergence, numerical instability, or designs that fail to meet user intent. Existing multi-agent systems in engineering have primarily focused on concept generation or runtime error correction, lacking robust mechanisms for assessing converged results against design-quality conventions and user intent.

2. Methodology: TopOptAgents

The authors propose TopOptAgents, a multi-agent framework designed to automate the entire topology optimization workflow, including decision-making and iterative self-refinement. The system utilizes six LLM-based agents that collaborate through three distinct refinement loops and a user-initiated feedback mechanism.

Agent Roles

The framework decomposes the workflow into observation, planning, action, and revision stages:

• Scientist Agent: Translates natural language user queries into structured mathematical problem formulations (Eq. 1), identifying design variables, constraints, governing equations, and dependencies. It can inject conditional context (e.g., stress-specific methodologies) if the problem falls outside standard training distributions.
• Validator Agent: Acts as a pre-execution checker, ensuring the Scientist's formulation is consistent with user requirements, checking for numerical instabilities (e.g., singularities, mesh aspect ratios), and correcting boundary condition errors.
• Planner Agent: Decomposes the verified problem into a step-by-step plan for code generation, specifying functions, parameters, and the iterative loop structure.
• Code Generation Team: Consists of three agents:
  • Coder: Writes the Python script (using libraries like FEniCS and pyOptSparse) based on the Planner's task list.
  • Executor: A non-LLM agent that runs the code in a subprocess.
  • Reviewer: Analyzes execution logs and error messages, sending corrections back to the Coder if runtime errors occur.
• Critic Agent: The core of the post-convergence assessment. It evaluates the final optimized design and convergence logs against a four-part rubric:
  1. Output Validity: Ensuring files are non-empty and non-trivial.
  2. Problem Formulation Consistency: Verifying the objective, constraints, and boundary conditions match the user's intent.
  3. Convergence: Assessing iteration counts and solver termination status.
  4. Design Quality: Visually inspecting the layout for issues like checkerboard patterns, gray regions, or disconnected members.

Refinement Loops

The framework employs three internal self-refinement loops to handle failures at different stages:

1. Validator–Scientist Loop: Operates before code generation. It corrects specification-level inconsistencies (e.g., load positions, missing parameters) either directly or by requesting reformulation from the Scientist.
2. Reviewer–Coder Loop: Operates during execution. It handles runtime errors, syntax issues, and missing library functions by iteratively correcting the code until execution is successful.
3. Critic-Driven Loop: Operates after a converged solution is produced. If the result fails the quality rubric (e.g., poor discreteness or mismatched constraints), the Critic identifies the specific failure, assigns it to the responsible upstream agent, and triggers a re-execution with refined parameters or formulations.
4. User-Initiated Loop: Allows users to provide feedback (e.g., "add a hole") after a successful run, triggering a new cycle that retains the shared memory state of previous iterations.

3. Key Contributions

• End-to-End Autonomous Workflow: The study presents a system that automates not just code generation, but the critical decision-making steps of topology optimization, including the assessment of converged designs against physical feasibility and user intent.
• Multi-Stage Self-Refinement: Unlike previous works that focus on generation-time errors, TopOptAgents introduces a post-convergence Critic agent capable of detecting "converged-but-wrong" outcomes (e.g., designs with checkerboard patterns or incorrect constraint formulations) and initiating targeted refinements.
• Conditional Context Injection: The framework addresses the limitation of LLMs on sparse problem classes (like stress minimization) by dynamically injecting relevant domain-specific context into the Scientist agent's prompt without modifying the underlying model.
• Multimodal Evaluation: The Critic agent utilizes both textual logs and visual design layouts to assess convergence and quality, mimicking the multimodal inspection performed by human engineers.

4. Results

The framework was evaluated on three benchmark problems selected to vary in their representation within the pre-trained LLM's training distribution:

1. Cantilever Beam Compliance Minimization: A canonical problem with high training coverage.
2. MBB Beam Compliance Minimization: A moderately covered problem with a specific load-position variant.
3. L-Shaped Beam Stress Minimization: A problem with sparse training coverage, involving stress aggregation and geometric singularities.

Performance Comparison:

• Single-Pass Baseline: A state-of-the-art single-pass LLM (GPT-5.4 Thinking) achieved an 80% success rate on the cantilever problem but dropped to 60% on the MBB variant and only 10% on the L-shaped stress problem.
• TopOptAgents: The multi-agent system achieved a 100% success rate on the cantilever and MBB problems. On the challenging L-shaped stress problem, the success rate improved from 10% (baseline) to 80%.
• Refinement Dynamics: The number of self-refinement iterations correlated with problem complexity. The cantilever problem required zero refinements. The MBB problem required modest refinement (mostly in the Validator-Scientist and Reviewer-Coder loops). The L-shaped problem required up to 12 iterations, heavily utilizing the Critic-driven loop to correct design quality issues (e.g., checkerboard patterns, gray regions) and formulation inconsistencies that the single-pass baseline missed.

5. Significance and Claims

The paper claims that self-refinement significantly broadens the range of topology optimization problems that LLM-based automation can reliably address.

• Recovery of Success Rates: The primary contribution is the demonstration that a multi-agent framework with iterative self-refinement can recover success rates on problems where single-pass LLMs fail, particularly for problem classes with limited prior exposure in the LLM's training data.
• Beyond Generation: The study highlights that successful automation requires more than just code synthesis; it necessitates a feedback loop that assesses the quality of the converged design against domain-specific conventions (e.g., absence of checkerboarding) and user intent.
• Modest Scope: The authors acknowledge that the framework's effectiveness is currently bounded by the pre-training corpus and the ability to inject context. Formulations that are neither well-documented in literature nor supplied as context remain outside the reliable scope. The paper suggests that future improvements could come from fine-tuning LLMs on topology optimization data or using retrieval-augmented generation (RAG) with a HyperGraph ontology of optimization knowledge.
• No Future Implications Invented: The paper does not claim to solve all engineering design problems or replace human engineers entirely. It positions the framework as a tool to reduce the manual burden of iterative decision-making and to make topology optimization more accessible and consistent, particularly for problems where standard LLMs struggle.