A Multi-AI-agent Framework Enabling End-to-end Finite Element Analysis for Solid Mechanics Problems

🕒 Published (v1): 2026-05-28 00:00 UTC · Source: HuggingFace · link

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

AbaqusAgent is a six-agent LLM-based framework that converts natural-language problem descriptions into fully executed Abaqus FEA simulations with post-processing visualizations. It combines a curated RAG database of 104 solid mechanics cases with iterative self-correction loops, achieving an 86% success rate across 50 benchmark problems. The system lowers FEA entry barriers while demonstrating how agent orchestration with domain-specific retrieval enables end-to-end simulation pipelines.

Problem

FEA with commercial packages like Abaqus requires deep interdisciplinary expertise to correctly specify geometry, boundary conditions, load cases, solver parameters, and post-processing — errors yield silent physics failures. API-based automation is rigid (fixed templates, hard-coded parameters) and cannot generalize to novel problem configurations. Existing LLM-FEA integrations target open-source solvers (FEniCS, MOOSE, Calculix) or lack systematic benchmarking across diverse problem types.

Method

AbaqusAgent orchestrates six specialized agents in a directed pipeline:

1. Interpreter Agent — validates and structures the five key modeling parameters (geometry, material, BCs, loads, outputs) from raw user text; rejects or clarifies underspecified prompts.
2. Architect Agent — performs a two-stage hybrid similarity search (Algorithm 1) over a FAISS-indexed RAG of 104 cases: (i) semantic top-\(k=15\) retrieval by embedding case metadata; (ii) hard domain filter + weighted re-ranking with weights \(w_\text{name}=0.60\), \(w_\text{cat}=0.30\), \(w_\text{mat}=0.10\).
3. Input Writer Agent — generates a syntactically correct Abaqus .inp file using the retrieved case as a template plus system-prompt formatting constraints.
4. Runner Agent — executes the .inp via Abaqus; routes .odb to the Visualizer on success or debug logs to the Reviewer on failure.
5. Reviewer Agent — diagnoses error files with LLM reasoning guided by an Abaqus expert system prompt; produces correction deltas \(\Delta F^i\) fed back to the Input Writer (Algorithm 2, up to \(M=15\) iterations).
6. Visualization Agent — scripted post-processing that exports displacement contour plots and CSV result files.

The RAG stores each case along three dimensions: structured metadata (name, domain, category, material), a natural-language problem description for semantic matching, and the full validated .inp file as a generation template. All fields are embedded with text-embedding-3-small and indexed in a single FAISS store.

Key Contributions

• Six-agent architecture with explicit inter-agent routing logic (success/failure branching between Runner, Reviewer, Input Writer, and Visualizer).
• Curated heterogeneous RAG of 104 solid mechanics cases (71 from Abaqus benchmark manual + 33 textbook-style problems) spanning static, dynamic, buckling, nonlinear materials, and composite categories.
• Hierarchical hybrid retrieval: FAISS semantic search + exact domain filtering + weighted multi-field scoring.
• Iterative self-correction loop (up to 15 cycles) with full error history passed to the Reviewer Agent.
• Systematic ablation covering agent architecture, RAG presence, self-correction, and prompt quality.
• Validated against 50 benchmark cases including 10 outside-RAG cases, with theoretical solution comparison on selected problems.

Results

• Overall success rate: 86% (43/50 cases); results accuracy: 86%.
• Inside-RAG cases (40): retrieval accuracy 85% (34/40 correct retrievals); simulation success 92.5% when a reference was retrieved.
• Outside-RAG cases (10): simulation success 60%.
• Token efficiency: inside-RAG successes average 28,761 tokens and 157 s; outside-RAG successes average 48,200 tokens and 312 s — RAG reduces both by ~40%.
• vs. baselines (Table 1):
• MooseAgent (MOOSE, DeepSeek-R1/-V3): 93% on 9 cases.
• ALL-FEM (FEniCS, fine-tuned GPT-OSS 120B): 71.79% on 39 cases.
• MechAgents (FEniCS, GPT-4): qualitative success on 2 cases.
• AbaqusAgent targets a substantially harder commercial solver with a larger and more diverse evaluation set than most prior work.

Limitations

• Maximum 15 self-correction iterations; the paper notes some complex problems may require up to 40, meaning those are marked failed.
• Evaluation set overlaps substantially with the RAG (40/50 cases are modified RAG cases), making outside-distribution generalization harder to assess.
• RAG coverage is limited (104 cases); novel analysis families (e.g., thermal-structural coupling, fluid-structure interaction) are absent.
• Relies on claude-opus-4-6 (closed-source, paid); cost and latency scale with iteration depth.
• Geometry building requires user-supplied meshing and partitioning hints for complex geometries — not fully automated.
• No formal comparison of retrieval strategy (hybrid vs. pure semantic) with ablation numbers in the provided text.

Relevance to Harnesses / Meta-Harnesses

AbaqusAgent is a concrete domain-specific meta-harness: it encodes a fixed simulation pipeline as a directed multi-agent graph with conditional branching, iterative self-repair loops, and a curated retrieval layer — exactly the control-flow patterns studied in general-purpose harness design. The iterative correction loop (Algorithm 2) with bounded retries and full history passing is a harness-level concern, not an agent-level one. The ablation on RAG, self-correction, and agent configuration is directly informative for harness designers asking which structural choices (retrieval, reflection, role decomposition) contribute most to end-to-end success. Compared to generic harnesses, it demonstrates how tight domain knowledge integration (validated .inp templates, expert-tuned system prompts) can substitute for larger models or more iterations.