Constrained Natural Language Interface: Enabling LLMs to Safely Assist in Finite Element Simulation Instead of Replacing Engineers

The study proposes a constrained architecture that limits LLMs to front-end parsing tasks (e.g., converting natural language to structured JSON, generating Gmsh mesh code), while the core numerical solving is handled by manually written deterministic templates. This maintains the convenience of natural language interaction while ensuring simulation reliability. The architecture aims to balance the convenience of LLMs with the high reliability requirements of engineering simulation, avoiding risks caused by unconstrained AI generation.

Finite Element Analysis (FEA) is the cornerstone of modern engineering design, but setting up simulations requires understanding mathematical formulations, writing complex code, etc.—a time-consuming and error-prone process. LLMs seem to solve this problem, but engineering simulation is on critical paths (e.g., aircraft component or medical device validation), and bugs in LLM-generated code could lead to catastrophic consequences, creating a reliability paradox.

The core of the constrained architecture is to clarify the responsibilities of LLMs and deterministic components:

• LLMs handle front-end tasks: parsing natural language into JSON specifications, generating Gmsh mesh code, retrying and correcting errors;
• Deterministic components handle critical paths: FEniCS solver templates (5 multi-physics scenario templates verified by experts), weak form derivation, core numerical solving;
• A deterministic scheduler selects and configures templates based on JSON parameters to ensure consistent input and output.

Solver Layer Validation

• Simple smooth problems: sub-1% accuracy;
• Difficult nonlinear problems: 2-5% accuracy;

Front-end Layer Validation

• 15 prompt parsing benchmarks: first-attempt success rate of 60%, 100% after retries; problem category recognition 100%, field extraction 97.1%;
• 10 custom geometry benchmarks: first-attempt and final success rate of 90%, 1 case of invalid geometry that could not be recovered.

User input: "Analyze the elastoplastic behavior of a 3D L-shaped bracket with rounded corners and bolt holes" System output:

• Identify problem type: 3D elastoplastic analysis;
• Generate Gmsh geometry code;
• Configure elastoplastic material parameters;
• Set boundary conditions;
• Call FEniCS solver;
• Output stress distribution and plastic zone results. No code writing is required from the user throughout the process, and the underlying solving code comes from verified templates.

• Constraint over freedom: Unconstrained AI generation in critical fields is dangerous; limiting LLM scope ensures reliability;
• Human-machine collaboration rather than replacement: LLMs handle tedious conversions, while engineers focus on problem definition and result interpretation;
• Progressive automation: Establish verifiable automation layers, each with clear validation mechanisms;
• Measurability: Each component has quantitative performance indicators, emphasizing validation and measurement.

Limitations

• Limited template coverage (only 5 physical scenarios);
• Extremely complex geometries (e.g., CAD industrial parts) require additional processing;
• Some cases (e.g., invalid geometry) cannot be automatically recovered;
• Users need to learn how to describe problems;

Future Directions

• Expand the template library to more physical scenarios;
• Integrate CAD import and geometry repair;
• Develop interactive problem clarification mechanisms;
• Establish a user feedback-driven improvement cycle.

Industry Insights

• Hybrid architectures are more reliable for critical path tasks;
• Constraints are an advantage (improving predictability);
• Validation needs to be done in layers;
• Progressive deployment is better than big bang;

Conclusion

The constrained interface demonstrates the safe application of LLMs in high-risk fields, balancing convenience and reliability. Its contribution is a "measured architecture" rather than unrestricted autonomous code generation, providing a reference paradigm for AI engineering applications: clear division of labor, constrained boundaries, layered validation, and progressive expansion.