AutoSiMP: Autonomous Topology Optimization from Natural Language via LLM-Driven Problem Configuration and Adaptive Solver Control

AutoSiMP is an autonomous pipeline that leverages large language models to translate natural language structural descriptions into validated binary topologies, achieving high configuration accuracy and end-to-end reliability through a closed-loop system of problem configuration, adaptive solver control, and rigorous structural evaluation.

The Gist

Imagine you want to build the strongest, lightest possible bridge using a specific amount of wood. In the past, to do this, you needed a team of highly trained engineers who could speak a very difficult, technical language (math and code) to tell a computer exactly how to arrange the wood. If they made a tiny mistake—like putting a support beam in the wrong spot or forgetting to mention a heavy truck—the computer would either crash or build a bridge that looked okay but would collapse under pressure.

AutoSiMP is like hiring a super-smart, bilingual architect who can listen to your casual description of the bridge and handle all the technical details for you.

Here is how it works, broken down into simple steps:

1. The Translator (The LLM Configurator)

Imagine you walk up to a robot and say: "I need a bridge that hangs from the left wall, holds a heavy weight on the right, has a hole in the middle for a pipe, and uses half the wood I have."

In the past, you'd have to translate that into complex code. AutoSiMP's first module is a Translator Robot. It listens to your English sentence and instantly writes down a perfect, error-free "construction blueprint" (a JSON file). It knows that "hangs from the left wall" means "fix the left side," and "hole for a pipe" means "leave a circular empty space." It even double-checks its own work to make sure the blueprint makes physical sense before handing it over.

2. The Foreman (The Boundary Condition Generator)

Once the blueprint is ready, a Foreman takes over. The blueprint says "fix the left wall," but the computer needs to know exactly which tiny pixels (or digital bricks) to glue down. The Foreman translates the human-friendly blueprint into the specific, rigid instructions the computer's brain understands. It marks exactly where the forces are pushing and where the material is allowed to exist.

3. The Sculptor (The SIMP Solver)

Now the Sculptor gets to work. This is the part that actually designs the bridge. It starts with a solid block of material and begins chipping away the unnecessary parts, iteration by iteration.

• The Twist: Usually, this sculptor needs a strict schedule to know how hard to chip away. AutoSiMP gives the sculptor a Smart Manager (a controller). This manager can either follow a strict, proven schedule (like a recipe) or use a second AI to dynamically adjust the chipping speed based on how the bridge is looking. This ensures the final result is sharp and clear, not blurry.

4. The Inspector (The Structural Evaluator)

When the sculptor finishes, the Inspector steps in. This isn't just a "looks good" check; it's a rigorous safety audit with eight different tests:

• Connectivity: Is the bridge actually one piece, or did it fall apart into floating islands?
• Strength: Is it strong enough?
• Clarity: Is the design sharp (solid wood or empty space), or is it a blurry mess of half-wood?
• Efficiency: Is the path for the weight to travel the shortest possible route?

If the bridge fails any of these tests, the system doesn't just give up.

5. The Safety Net (The Retry Loop)

If the Inspector finds a problem (e.g., "The bridge is too wobbly"), the system automatically says, "Okay, let's try again." It tweaks the settings—maybe giving the sculptor more time to work or adjusting the amount of wood allowed—and tries to build the bridge again. It keeps doing this until it gets a perfect result.

Why is this a big deal?

Think of topology optimization like a high-end video game. Before, only "hardcore players" (experts) knew how to configure the game settings to get the best results. If a casual player tried, they would likely crash the game or get a terrible score.

AutoSiMP is the "Easy Mode" that doesn't sacrifice quality.

• It removes the barrier: You don't need to know math or coding. You just need to speak English.
• It's reliable: The system tested it on 10 different problems. When using the "strict recipe" for the sculptor, every single time it built a perfect bridge on the very first try, with zero errors.
• It's visual: They even built a website where you can type your idea, watch the bridge being built in real-time, and even drag the weight around with your mouse to see how the design changes instantly.

The Bottom Line

AutoSiMP is the first system that takes a simple sentence like "Build me a strong, light bracket with a hole in it" and turns it into a mathematically perfect, ready-to-manufacture design without a human engineer needing to touch the code. It bridges the gap between human imagination and machine precision.

Technical Summary

1. Problem Statement

Topology Optimization (TO) is a computational method used to determine optimal material distribution within a design domain to minimize structural objectives (e.g., compliance) subject to constraints. Despite mature solvers like SIMP (Solid Isotropic Material with Penalization) being available, the method remains inaccessible to non-experts due to a high configuration barrier.

Users must manually:

• Discretize the domain into a finite-element mesh.
• Define complex boundary conditions (fixed, pinned, roller supports).
• Construct consistent force vectors for point and distributed loads.
• Define passive regions (voids/solids).
• Select numerical parameters (volume fraction, filter radius, continuation schedules).

Errors in any of these steps lead to solver failures or silently incorrect results. Existing Machine Learning (ML) approaches for TO typically focus on accelerating the solver or generating designs from pre-configured inputs, failing to address the upstream task of translating natural language descriptions into solver-ready specifications.

2. Methodology: The AutoSiMP Pipeline

AutoSiMP is an autonomous five-module pipeline that transforms a plain-English prompt into a validated binary topology. It separates configuration (what to optimize) from control (how to optimize).

Module 1: LLM Configurator

• Function: Parses natural language prompts (e.g., "cantilever beam, left edge fixed, downward load at mid-right") into a structured ProblemSpec JSON.
• Mechanism: Uses an LLM (Gemini Flash Lite) with a domain-knowledge system prompt encoding interpretation rules (e.g., "MBB beam" $\rightarrow$ symmetry BC + roller).
• Safety Rails: Deterministic checks clamp physical ranges, inject missing constraints, and reject impossible configurations (e.g., loads on fixed DOFs). A regex fallback handles parsing failures.

Module 2: Boundary-Condition (BC) Generator

• Function: Converts the ProblemSpec into solver-ready arrays.
• Outputs:
  • Fixed DOFs: Maps edge/point supports to specific degrees of freedom.
  • Force Vectors: Assembles point loads and distributed loads using trapezoidal-rule tributary weighting to ensure exact force equilibrium.
  • Passive Masks: Generates masks for void/solid regions, freezing them during the Optimality Criteria (OC) update.

Module 3: SIMP Solver with Pluggable Controller

• Solver: A three-field SIMP implementation (density filter + Heaviside projection).
• Controller: A pluggable module that manages continuation parameters ($p, \beta, r_{min}, \delta$) during iterations.
  • LLM Controller: Adaptive, adjusting parameters per iteration based on solver state.
  • Deterministic Schedule: Pre-computed, fixed trajectory.
  • Tail Mechanism: All controllers share a "sharpening tail" (40 iterations) to force binary convergence.

Module 4: Structural Evaluator

• Function: Performs eight deterministic quality checks on the output.
• Pass/Fail Gates (5):
  1. Connectivity: Flood-fill from supports to loads (ensures load path).
  2. Compliance Ratio: Final vs. best compliance (detects degradation).
  3. Grayness: Measures intermediate densities ($G \le 0.15$).
  4. Volume Fraction: Deviation from target ($\le 2\%$).
  5. Convergence: Stability of compliance.
• Informational Metrics (3): Thin-member fraction, checkerboard index, and load-path efficiency.

Module 5: Retry Loop

• Function: If a gate fails, the evaluator diagnoses the issue (e.g., "insufficient iterations," "volume violation") and proposes parameter adjustments (e.g., increase iteration budget by 30%).
• Execution: Automatically re-runs the solve (up to 2 retries).

Module 6: Interactive Web Interface

• A browser-based demo allowing users to input prompts, visually verify parsed BCs (drag-and-drop loads), view live density fields, and inspect 3D isosurfaces. It supports both client-side JS solving and a Python backend.

3. Key Contributions

1. First End-to-End Autonomous TO System: AutoSiMP is the first system to close the loop from natural language to a validated binary topology, covering configuration, solving, evaluation, and recovery.
2. LLM-Based Configuration: Demonstrates that LLMs can accurately parse structural engineering terminology into solver-ready specifications with a median compliance penalty of only +0.3% compared to expert ground truth.
3. Automated BC Generation: A robust bridge converting high-level descriptions into consistent DOF arrays and force vectors, handling arbitrary combinations of supports and loads.
4. Systematic Evaluation: Comprehensive benchmarking across 19 problems (17 2D, 2 3D) evaluating configuration accuracy, controller performance, and end-to-end reliability.
5. Open-Source & Interactive: Release of the full codebase and an interactive web demo, a feature absent in all prior surveyed systems.

4. Experimental Results

Configuration Accuracy

• Performance: The LLM configurator produced valid specifications for 10/10 diverse test cases.
• Accuracy: 9/10 cases matched the expert ground truth in all 6 specification fields. The median compliance penalty was +0.3%.
• Outliers: One case (L-bracket) showed a +119% penalty due to a slight misinterpretation of load coordinates, highlighting the need for visual verification.

Controller Comparison (17 2D + 2 3D Problems)

• LLM Controller: Achieved the lowest median compliance (best performance) but had a 76.5% pass rate due to API-induced oscillations.
• Deterministic Schedule: Achieved 100% pass rate with only +1.5% higher median compliance than the LLM controller.
• Ablation Studies:
  • Tail-only (No exploration): Produced designs 2.8$\times$ worse in compliance, proving the exploration phase is critical.
  • Fixed (No continuation): Failed to produce binary designs (high grayness), proving the sharpening tail is essential.

End-to-End Reliability

• When pairing the LLM Configurator with the Deterministic Schedule Controller, the system achieved a 100% pass rate on the first attempt for all 10 pipeline test cases. No retries were needed, confirming the configurator is the critical enabler of autonomy.

3D Validation

• The system successfully generalized to 3D problems (30$\times$15$\times$8 mesh). The LLM controller showed an even larger advantage in 3D (23% lower compliance vs. fixed baseline) compared to 2D, likely due to the lack of established 3D continuation schedules.

5. Significance and Implications

• Democratization of TO: AutoSiMP removes the "configuration barrier," allowing non-experts to perform complex structural optimizations via natural language.
• Quality vs. Reliability Trade-off: The paper establishes a practical deployment strategy: use the LLM Configurator for accessibility and the Deterministic Schedule for reliability. This combination yields near-expert performance with 100% robustness.
• Architectural Innovation: The separation of configuration (LLM-driven) and control (pluggable) allows for independent optimization of each component.
• Interactive Verification: The inclusion of a visual interface addresses the "black box" nature of LLMs, allowing users to correct spatial ambiguities (e.g., load placement) before solving, effectively turning potential failures into routine checks.

In conclusion, AutoSiMP represents a significant leap toward fully autonomous engineering design, proving that Large Language Models can effectively bridge the gap between human intent and rigorous numerical simulation when paired with deterministic safety rails and robust evaluation loops.