Paper deep dive
From Perception to Autonomous Computational Modeling: A Multi-Agent Approach
Daniel N. Wilke
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 95%
Last extracted: 4/10/2026, 1:59:42 AM
Summary
The paper introduces a solver-agnostic, multi-agent framework that automates the computational mechanics workflow—from perceptual data (images/text) to engineering reports—using coordinated LLM agents. The system employs a three-layer architecture (perception, analysis, assessment) with quality gates and an orchestrator to ensure traceability, uncertainty quantification, and code-compliant structural assessment, demonstrated via a finite element analysis of a steel L-bracket.
Entities (4)
Relation Signals (3)
Multi-agent Framework → utilizes → Claude Opus 4.6
confidence 98% · Each agent is instantiated on Claude Opus 4.6
Daniel N. Wilke → developed → Multi-agent Framework
confidence 95% · We present a solver-agnostic framework in which coordinated large language model (LLM) agents autonomously execute the complete computational mechanics workflow
Multi-agent Framework → performs → Finite Element Analysis
confidence 95% · The framework is demonstrated through a finite element analysis pipeline
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:We present a solver-agnostic framework in which coordinated large language model (LLM) agents autonomously execute the complete computational mechanics workflow, from perceptual data of an engineering component through geometry extraction, material inference, discretisation, solver execution, uncertainty quantification, and code-compliant assessment, to an engineering report with actionable recommendations. Agents are formalised as conditioned operators on a shared context space with quality gates that introduce conditional iteration between pipeline layers. We introduce a mathematical framework for extracting engineering information from perceptual data under uncertainty using interval bounds, probability densities, and fuzzy membership functions, and introduce task-dependent conservatism to resolve the ambiguity of what `conservative' means when different limit states are governed by opposing parameter trends. The framework is demonstrated through a finite element analysis pipeline applied to a photograph of a steel L-bracket, producing a 171,504-node tetrahedral mesh, seven analyses across three boundary condition hypotheses, and a code-compliant assessment revealing structural failure with a quantified redesign. All results are presented as generated in the first autonomous iteration without manual correction, reinforcing that a professional engineer must review and sign off on any such analysis.
Tags
Links
- Source: https://arxiv.org/abs/2604.06788v1
- Canonical: https://arxiv.org/abs/2604.06788v1
Trouble viewing inline? Open PDF directly →
Full Text
97,296 characters extracted from source content.
Expand or collapse full text
From Perception to Autonomous Computational Modeling: A Multi-Agent Approach Daniel N. Wilke Corresponding author. Email: daniel.wilke@wits.ac.za School of Mechanical, Industrial and Aeronautical Engineering, University of the Witwatersrand, Johannesburg, South Africa Abstract We present a solver-agnostic framework in which coordinated large language model (LLM) agents autonomously execute the complete computational mechanics workflow, from perceptual data of an engineering component through geometry extraction, material inference, discretisation, solver execution, uncertainty quantification, and code-compliant assessment, to an engineering report with actionable recommendations. Agents are formalised as conditioned operators on a shared context space with quality gates that introduce conditional iteration between pipeline layers. We introduce a mathematical framework for extracting engineering information from perceptual data under uncertainty using interval bounds, probability densities, and fuzzy membership functions, and introduce task-dependent conservatism to resolve the ambiguity of what “conservative” means when different limit states are governed by opposing parameter trends. The framework is demonstrated through a finite element analysis pipeline applied to a photograph of a steel L-bracket, producing a 171,504-node tetrahedral mesh, seven analyses across three boundary condition hypotheses, and a code-compliant assessment revealing structural failure with a quantified redesign. All results are presented as generated in the first autonomous iteration without manual correction, reinforcing that a professional engineer must review and sign off on any such analysis. Keywords: Multi-agent systems; Large language models; Computational mechanics; Autonomous simulation; Uncertainty quantification; Perceptual data uncertainty quantification; Professional engineer oversight; Solver-agnostic workflows; Finite element method; Smoothed particle hydrodynamics; Material point method; Peridynamics Highlights: • Agents infer engineering context from images to reduce uncertainty at every stage • Qualitative and quantitative judgement applied to all decisions autonomously • Results interpreted with engineering judgement for actionable recommendations • Task-dependent conservatism resolves parametric safety ambiguity • Professional engineer role made explicit through first-iteration results 1 Motivation Autonomous computational modelling from perceptual data We define autonomous computational modelling from perceptual data as the capacity of a computational system to execute the complete modelling workflow, from multimodal perceptual data (image, video, audio, text) through inference, modelling, simulation, verification, interpretation, and recommendation, without human intervention at intermediate steps, while maintaining full traceability and requiring professional sign-off on the final output. It is distinct from both automated simulation (which executes pre-defined workflows without judgement) and AI-assisted design (which augments human decisions on individual steps): the system must infer missing information, apply engineering judgement to resolve ambiguity, and recommend actionable outcomes, not merely compute. This work sits at the intersection of three converging capabilities: multi-modal large language models that interpret perceptual data and reason about engineering context, multi-agent architectures that decompose complex workflows into specialised communicating roles, and computational mechanics solvers. The contribution is the orchestration layer that connects these into a coherent autonomous modelling pipeline. The bottleneck The bottleneck in modern computational mechanics is rarely the solver (whether finite element, finite volume, particle, or lattice method) but the human workflow surrounding it: extracting geometry, selecting boundary conditions, identifying design codes, choosing discretisation strategies, performing verification calculations, interpreting results, and making recommendations based on those results. This workflow requires both qualitative judgement (what material is this? what are the likely loading conditions?) and quantitative reasoning (what stress concentration factor is appropriate? which boundary condition variant is conservative for which limit state?). At every stage, the engineer infers as much as possible from the available information to reduce uncertainty, and the framework presented here aims to replicate this inference process autonomously, while making every decision transparent and traceable. Large language models (LLMs) now demonstrate code generation [1, 2], scientific reasoning [3, 4], and multi-modal understanding [5]. In computational mechanics specifically: constitutive discovery [6], finite element analysis (FEA) code generation [7], next-generation computer-aided engineering (CAE) [8], end-to-end FEA [9, 10]. Physics-informed neural networks (PINNs) [11, 12], neural operators [13, 14], and constitutive artificial neural networks (CANNs) [6] engage with the mathematical structure of mechanics, while image-based FE modelling [15, 16] reconstructs geometry from structured imaging. But each addresses individual pipeline components. None orchestrates the entire workflow, from observation through inference, simulation, verification, interpretation, and recommendation, which requires engineering judgement under uncertainty. Multi-agent systems [17, 18] decompose this orchestration into specialised agents mirroring engineering consultancy practice. MetaGPT [19], AutoGen [20], ReAct [21], and Reflexion [22] show coordinated LLM agents solving complex tasks; in science, agents have run chemical experiments [23] and designed syntheses [24]. We extend this to computational mechanics, where stakes are governed by safety codes and professional liability. The key contributions are: (i) a solver-agnostic multi-agent architecture in which agents apply both qualitative and quantitative engineering judgement at every stage, inferring material properties, boundary conditions, and design codes from visual and contextual evidence to maximally reduce uncertainty (Section˜2); (i) a layered information extraction and encoding framework with multiple geometry reconstruction pathways and uncertainty quantification, including detection of secondary features such as countersinks from visual cues (Section˜3); (i) unified mathematical foundations for the finite element method (FEM), smoothed particle hydrodynamics (SPH), material point method (MPM), peridynamics, discrete element method (DEM), and finite volume method (FVM) (Section˜4); (iv) task-dependent conservatism resolving the ambiguity of parametric safety analysis (Section˜5); (v) an FEA demonstration where agents not only analyse but interpret results and provide actionable engineering recommendations, including autonomous redesign when the component fails (Sections˜6 and 7); and (vi) a complete reproducible orchestrator prompt (supplied as supplementary material upon acceptance). 2 General framework 2.1 Architecture overview The framework consists of three layers operating in an iterative loop (Figure˜1). The perception layer extracts structured engineering information from unstructured inputs (images, videos, text descriptions). The analysis layer executes the computational mechanics workflow: discretisation (meshing, particle seeding, or lattice generation), solver execution, and verification. The assessment layer interprets results in the context of design codes and delivers actionable engineering output. Critically, information flows not only forward but also backward: the assessment layer may flag issues requiring re-analysis with modified assumptions, and the analysis layer may request updated geometry or boundary conditions from the perception layer. Quality gates at layer boundaries enforce this iterative refinement. Figure 1: Three-layer architecture with orchestrator and iterative feedback. The input (perceptual data: image, video, audio, or text, plus user metadata) feeds into three processing layers: the perception layer extracts structured data from the perceptual input; the analysis layer handles discretisation, solving, and verification; the assessment layer interprets results against design codes and emits actionable recommendations and proposed design modifications as outputs. An overarching orchestrator (right) coordinates the entire process, maintaining a dynamic checklist of tasks, dispatching agents, monitoring quality gate outcomes, and routing feedback between layers. The agent evolver (top right) processes engineer corrections after each completed analysis, updating agent definitions and shared memory for future runs. Dashed arrows indicate iterative feedback: assessment findings can trigger re-analysis with modified assumptions, and analysis-layer quality gates can request updated perception-layer outputs. The orchestrator decides which agent to invoke next based on the current state of the shared context, the pending checklist items, and any gate failures. The architecture is solver-agnostic (FEA, computational fluid dynamics (CFD), DEM, SPH, MPM, lattice Boltzmann method (LBM)). Each agent within the framework is characterised by four properties. First, a scope definition that precisely delimits what the agent is responsible for. Second, a tool set specifying which computational tools the agent may invoke. Third, a critic protocol requiring the agent to self-validate its outputs. Fourth, a memory interface allowing the agent to read lessons from previous runs and write new lessons for future improvement. Agents communicate through structured JSON via a shared context protocol, not natural language, reducing the risk of information loss or misinterpretation across the pipeline. Two additional meta-agents sit outside the pipeline layers. The orchestrator O coordinates the entire process: it maintains a dynamic checklist ℒ=(ℓk,statusk)L=\( _k,status_k)\ of pending tasks, dispatches agents in the correct order, monitors quality gate outcomes, and routes corrective feedback between layers when a gate fails. When a discretisation reviewer returns j=0G_j=0, for example, the orchestrator appends corrective instructions to the context and re-invokes the discretisation generator with the updated context. The orchestrator also handles conditional logic: if the problem formulator determines that dynamic analysis is required, the orchestrator inserts the appropriate solver invocations into the execution plan. The number of agents n is not fixed: Figure˜1 shows the full catalogue of 12 specialised agent types across the three layers (4 perception, 5 analysis, 3 assessment), but the orchestrator instantiates and may merge roles as needed based on the problem type. For example, in the FEA demonstration (Section˜6), the four perception-layer roles (geometry analyst, context interpreter, scale & material estimator, uncertainty identifier) are handled by a single geometry analyst agent, and the convergence assessor and bound verifier roles are absorbed by the uncertainty analyst, yielding nine instantiated agents from the twelve defined types. The agent evolver ℱF (Equation˜7) operates after pipeline completion, processing engineer feedback to update agent definitions for future runs. The same framework orchestrates FEA stress analysis, CFD flow simulation, or DEM granular flow, with only the discretisation and solver agents requiring specialisation. 2.2 Mathematical formalisation Each agent is instantiated on Claude Opus 4.6 [39], a multimodal autoregressive language model (LM) with context window C≈106C≈ 10^6 tokens, defining pLM(y1:T∣x1:S)=∏t=1TpLM(yt∣x1:S,y1:t−1).p_LM(y_1:T x_1:S)= _t=1^Tp_LM(y_t x_1:S,y_1:t-1). (1) An agent iA_i is defined by four components: a system prompt si∈∗s_i ^* encoding its scope, responsibilities, and domain knowledge; a tool set i=t1,…,tKiT_i=\t_1,…,t_K_i\ of functions (file I/O, shell commands, solvers, or other agents) the agent may invoke; each tool may be deterministic, stochastic, or a hybrid combination (e.g., a deterministic solver wrapped by an LLM-driven input generator), so the agent-tool system is in general a hybrid stochastic-deterministic one; a persistent memory mi∈ℳm_i storing lessons from previous runs; and the underlying language model pLMp_LM. The agent operator is i≡(si,i,mi,pLM):i×→i×,A_i (s_i,T_i,m_i,p_LM):X_i×C _i×C, (2) where iX_i is the input space, C the shared context space, and iY_i the output space. The system prompt sis_i conditions pLMp_LM to behave as a domain specialist, analogous to boundary conditions in a partial differential equation (PDE): the same model produces fundamentally different behaviour depending on sis_i. When pLMp_LM generates a tool-call token sequence, the framework executes the corresponding t∈it _i and feeds the result back as additional context, creating a hybrid stochastic-deterministic system. At completion, the agent may update its memory: mi←mi⊕Δmim_i← m_i m_i, where ⊕ denotes the append operator (concatenation of structured records; it is not modular addition; memory and context are monotonically non-decreasing). Two families of maps mediate between the physical space P (perceptual data: images, video frames, audio, text), token space ∗V^* (LM native), and engineering space ℰE (structured numerical data): enc _P :→∗,encℰ:ℰ→∗, :P ^*, _E:E ^*, (3) decℰ _E :∗→ℰ,decℛ:∗→ℛ. :V^* , _R:V^* . (4) The physical encoder encenc_P is the physical data transformer (for images, the vision transformer component; analogous modality-specific encoders handle video, audio, or text) of the multimodal LM; the engineering encoder encℰenc_E serialises structured data (JSON, solver output) into tokens. The decoder decℰdec_E parses structured output from token sequences; this is where many agent errors originate (malformed JSON, unit mismatches, hallucinated values), motivating the quality gates of Section˜2.3. The orchestrator O manages the pipeline execution. It maintains a checklist ℒ=(ℓk,statusk)k=1KL=\( _k,status_k)\_k=1^K and selects the next agent to invoke based on the current context cic_i and gate outcomes. The nominal pipeline is Π=(1,…,n,1,…,n−1), =O\! (A_1,…,A_n,G_1,…,G_n-1 ), (5) where j:j×→0,1G_j:Y_j×C→\0,1\ are quality gates that either pass (j=1G_j=1) or reject (j=0G_j=0, triggering corrective iteration). When j=0G_j=0, O appends corrective instructions to cjc_j and re-invokes jA_j (or an earlier agent if the failure requires upstream changes). Context evolves as ci=ci−1⊕i(xi,ci−1)|,i=1,…,n,c_i=c_i-1 _i(x_i,c_i-1) |_C, i=1,…,n, (6) with ⊕ the append operator introduced above, ensuring the context is monotonically non-decreasing and hence fully traceable. Each agent sees the outputs of all predecessors through ci−1c_i-1, enabling long-range dependencies (e.g., the uncertainty analyst references assumptions made by the geometry analyst). The self-improving architecture is formalised as a feedback operator ℱ:(r,δr,si,i,mii=1n)↦si′,mi′i=1n,F:(r,δ r,\s_i,T_i,m_i\_i=1^n) \s_i ,m_i \_i=1^n, (7) mapping engineer corrections δrδ r on report r to updated system prompts and memories, operating at the prompt/memory level without modifying model weights pLMp_LM. Over K analysis-review cycles, agent definitions evolve as si(k+1),mi(k+1)=ℱ(r(k),δr(k),si(k),mi(k))\s_i^(k+1),m_i^(k+1)\=F(r^(k),δ r^(k),\s_i^(k),m_i^(k)\), reducing the correction residual with each cycle. Unlike fine-tuning or reinforcement learning from human feedback (RLHF), this refinement is lightweight, interpretable, and reversible. The computational cost is dominated by LLM inference: Cost(Π)=∑i=1n(Tiin⋅cin+Tiout⋅cout+∑j=1JiCost(ti,j)),Cost( )= _i=1^n (T_i^in· c_in+T_i^out· c_out+ _j=1^J_iCost(t_i,j) ), (8) where Tiin/outT_i^in/out are token counts, cin/outc_in/out per-token costs, and Cost(ti,j)Cost(t_i,j) the wall-clock cost of executing tool j (e.g., running a solver). 2.3 Quality gates and verification No agent trusts its predecessor unconditionally. The architecture pairs each generative agent with an independent reviewing agent, forming generator-critic dyads reminiscent of the generator-discriminator pairing in generative adversarial networks [61]: one agent produces a candidate artefact (mesh, bound estimate, code check), and a second agent, conditioned by a different system prompt and with access to the same evidence, audits it and either accepts or rejects. Unlike a GAN, the two agents are not trained against each other; they share the same underlying pLMp_LM, but the prompt-level separation of roles is sufficient to expose errors that a single agent would miss. Four such gates enforce verification [33, 34]: The first gate is discretisation review. An independent reviewer agent analyses the generated computational domain against the original image, counting geometric features independently rather than simply checking the modeller’s claimed counts. The reviewer agent also performs junction connectivity verification, ensuring that at each feature junction (arm-bend, arm-arm), the mesh is continuous with shared nodes at interfaces, and profile tracing, tracing the outside and inside profiles through the mesh node coordinates to check for steps, gaps, or reversals that indicate geometry construction errors. The second gate is mesh-convergence assessment. A convergence agent re-runs the critical load case on a coarsened mesh, compares peak stress and tip deflection against the fine-mesh solution, and rejects the discretisation when the relative change exceeds a configurable tolerance; it also screens FEA response quantities against the analytical envelopes produced in the next step as a sanity check before assessment. The third gate is analytical bound verification. Before accepting solver results downstream, the framework requires that all computed response quantities fall within analytically derived upper and lower bounds [35]. The fourth gate is code-compliance assessment. The design assessment explicitly checks each limit state against the applicable code clause, using the appropriate conservative bound for each check type. A gate failure triggers iteration back to the responsible agent with corrective context appended, implementing the inter-layer feedback arrows in Figure˜1. The maximum number of iterations per gate before escalation to human review is a configurable parameter NmaxN_ (set to Nmax=5N_ =5 for the demonstration in Section˜6). The agents within each layer are not fixed; they are instantiated by the orchestrator based on the problem type. The perception layer contains agents for geometry extraction (with manufacturing-step descriptions and junction connectivity specifications), material inference, and context interpretation. The analysis layer contains agents for problem formulation, discretisation method selection, discretisation generation (with feature-relative placement and junction verification), discretisation review (quality gate), boundary/initial condition specification, analytical bounding, solver execution, and convergence assessment. The assessment layer contains agents for uncertainty analysis, bound verification (quality gate), design assessment / code compliance (quality gate), and report writing. Section˜6 demonstrates the framework with an FEA instantiation. 3 Information extraction and encoding across pipeline layers The pipeline transforms unstructured multi-modal perception data into a verified engineering report through successive encoding stages. Each layer in Figure˜1 receives information from its predecessor, extracts and encodes domain-specific content, and passes structured output downstream. We formalise the encoding at each stage. 3.1 Input: image and context acquisition The pipeline accepts multi-modal perceptual input: images, video frames, audio clips, or textual descriptions, together with optional contextual metadata ℳctxM_ctx (user-provided descriptions, application domain, geographic region). In this work we focus on the image modality as the primary use case; the generalisation to video (temporal stacks), audio (e.g., impact or modal signatures), and text is direct through modality-specific encoders of the multimodal LM. For the image case, the input is a pixel array ∈ℝH×W×3I ^H× W× 3, which may be a clean engineering drawing, a photograph of an installed component, or a hand-sketch. The framework supports multiple pathways from image to 3D geometry, automatically selecting the most appropriate: (i) VLM direct interpretation. A vision-language model interprets the image and generates a parametric geometry description as structured JSON. This is the most general pathway, handling arbitrary real-world photographs, but is the most lossy. (i) VLM → script → CAD. The VLM generates a Python script (using Gmsh, OpenCASCADE, or CadQuery) that programmatically constructs the 3D geometry. This combines the VLM’s interpretation ability with exact parametric geometry. (i) Edge detection → 2D profile → extrusion. Canny/Hough transforms extract 2D geometric primitives (lines, arcs, circles), which are extruded or revolved to create 3D geometry. Effective for prismatic or axisymmetric components. (iv) Segmentation → point cloud → surface reconstruction. Segment Anything Model or Mask R-CNN isolates the component, depth estimation (monocular or stereo) produces a point cloud, and Poisson surface reconstruction generates a watertight mesh. (v) Multi-view → structure from motion (SfM) → mesh. When multiple views are available, SfM algorithms (e.g., COLMAP [54]) produce a dense 3D point cloud that is meshed directly. (vi) Text description → parametric CAD. When the image is supplemented by textual specifications, the framework bypasses image geometry extraction and constructs the CAD model from the specification directly. The orchestrator selects the pathway based on image quality, component complexity, and available metadata. 3.2 Perception layer: geometry and material encoding under uncertainty The perception layer encodes the input into structured engineering parameters. The geometry agent produces a manufacturing-step description: base stock definition, sequential operations (bends with inner/outer radii, holes with edge features, cuts), each located in an explicit coordinate system with junction connectivity requirements specifying which surfaces of adjacent features must be flush. Dimensions carry uncertainty bounds [θ−,θ+][θ^-,θ^+], hot-spots are predicted with KtK_t estimates, and iterative sanity checks verify geometric consistency (bend radius ≥ thickness, holes within members, developed length). Full agent instructions will be released with the supplementary material. Let img=(θ1,…,θq)∈ℝq θ_img=( _1,…, _q) ^q denote the geometric and material parameters to be extracted. The image extraction operator maps the input to a set-valued estimate: ℐ:(,ℳctx)↦(θ^j,θj−,θj+,pj,κj)j=1q,I:(I,M_ctx) \( θ_j, _j^-, _j^+,p_j, _j) \_j=1^q, (9) where θ^j θ_j is the point estimate, [θj−,θj+][ _j^-, _j^+] the plausible interval, pj(θj∣)p_j( _j ) a conditional density, and κj∈[0,1] _j∈[0,1] a confidence score. Geometric parameters For dimensions without calibration: L=L^±δL,H=H^±δH,t=t^±δt,L= L±δ L, H= H±δ H, t= t±δ t, (10) with δ depending on scale reference quality (±5%± 5\% with calibration object, ±10± 10 to 20%20\% from contextual references). The density representation enables richer modelling: θj∼(θ^j,σj2),measurement-derived,(θj−,θj+),only bounds known,Tri(θj−,θ^j,θj+),educated guess with best estimate. _j casesN( θ_j, _j^2),&measurement-derived,\\ U( _j^-, _j^+),&only bounds known,\\ Tri( _j^-, θ_j, _j^+),&educated guess with best estimate. cases (11) The triangular distribution is appropriate for image-inferred parameters, encoding bounds and mode without spurious tails. Material identification For qualitative parameters (material type, surface finish, connection type), the extraction produces fuzzy membership functions μj:Θj→[0,1] _j: _j→[0,1]: μmaterial(θ)=μ1,θ=hypothesis 1,μ2,θ=hypothesis 2,μ3,θ=hypothesis 3, _material(θ)= cases _1,&θ=hypothesis 1,\\ _2,&θ=hypothesis 2,\\ _3,&θ=hypothesis 3, cases (12) where ∑kμk=1 _k _k=1 and the values are inferred from visual cues (surface texture, colour, reflectivity), section profile, and application context. When the dominant hypothesis exceeds μmin≈0.6 _ ≈ 0.6, the framework proceeds and flags the assumption; otherwise it analyses multiple hypotheses. Material properties are marginalised over this uncertainty: p(E∣)=∑kμkp(E∣θk),p(E )= _k _k\,p(E _k), (13) yielding mixture distributions that propagate compounded identification and property variability. Information content The information gain quantifies extraction quality: ΔH=H(img)−H(img∣)≥0, H=H( θ_img)-H( θ_img )≥ 0, (14) where H denotes Shannon entropy. Parameters with high residual entropy H(θj∣)H( _j ) are candidates for targeted physical measurement, providing a principled basis for requesting additional data. 3.3 Analysis layer: encoding into computational models The analysis layer receives the structured perception output and encodes it into computational models. This involves three encoding decisions: Problem formulation encoding The problem formulator determines the governing physics (structural, fluid, thermal, coupled), selects the strong form PDE (Section˜4), and classifies the loading type (load-controlled vs. displacement-controlled), which governs the conservatism framework (Section˜5). Discretisation encoding The discretisation selector chooses the method based on problem type: structural problems without fracture use FEM (CalculiX or FEniCS); fracture problems use peridynamics (Peridigm); large-deformation problems with history-dependent materials use MPM (CB-Geo); granular flows use DEM (YADE, MercuryDPM, or LIGGGHTS); free-surface fluids use SPH (DualSPHysics); enclosed fluids use FVM (OpenFOAM); thermal problems use FEM or FVM; and coupled problems use partitioned solvers with preCICE. The generator constructs geometry using feature-relative placement: computing junction coordinates analytically from the bend geometry, placing each arm flush with the fillet endpoints, and verifying a single connected solid after boolean fuse. This prevents the most common error of placing features at absolute coordinates without verifying surface coincidence. Visual comparison images are generated for the reviewer. Boundary condition and loading encoding Boundary conditions (BCs), initial conditions (ICs), and loads are encoded from the image and context. The applicable design code is inferred (not prescribed) from geographic clues, material type, and application. Multiple BC variants are generated, each tagged with conservatism direction per limit state. 3.4 Assessment layer: encoding into engineering judgement The assessment layer encodes numerical results into engineering decisions: the uncertainty analyst applies task-dependent conservatism (Section˜5) producing separate FoS ranges per limit state; the bound verifier (quality gate) checks results against analytical bounds, diagnosing exceedances; the design assessor performs code-compliant checks and, critically, interprets results to provide actionable recommendations, invoking a redesign loop when the component fails; and the report writer produces a professional simulation qualification report with full reproducibility. 4 Mathematical foundations for solver-agnostic discretisation 4.1 The forward problem: continuum fields and what must be known Engineering simulation is a forward problem: given geometry Ω , material constitutive law =^(,˙,,T,…) σ= σ( , , α,T,…), boundary conditions on ∂Ω∂ , initial conditions at t=0t=0 (for dynamic problems), and applied loads, find the response fields (displacements, stresses, velocities, pressures, temperatures). Table˜1 enumerates the continuum field equations for the three classical domains (solid, fluid, and granular), identifying the unknown fields, the number of scalar equations, the constitutive closure required, and the additional information that must be supplied to render the problem complete. Table 1: Continuum physics: fields, equations, and required inputs. This table is not exhaustive; many other physics models (piezoelectric, magnetohydrodynamic, phase-field fracture, etc.) follow the same pattern. For each row, agents must determine all listed quantities before a solver can be invoked. Physics Fields Scalar eqns PDE type ICs? State? Constitutive + additional inputs Solid mechanics Static elastic u d Elliptic No No E,νE,ν (or ℂC); BCs (¯,¯ u, t); b Dynamic elastic u, ˙ u d Hyperbolic Yes No† E,ν,ρE,ν,ρ; BCs; 0,˙0u_0, u_0 Elastoplastic u, α d+nαd+n_α Hyp. + evol. Yes Yes E,νE,ν, yield f, hardening H; 0 α_0 Hyperelastic (large def.) u, F d Elliptic (NL) No No W()W(F) strain energy; BCs; b Fluid mechanics Incompressible v, p d+1d+1 Parabolic+constr. Yes No ρ,μρ,μ; BCs (¯,p¯ v, p); 0v_0 Compressible ρ, v, E d+2d+2 Hyperbolic Yes No EOS p(ρ,E)p(ρ,E), μ, k; BCs; ICs Thermal Heat conduction T 1 Parabolic Yes‡ No k,ρ,cpk,ρ,c_p; BCs (T¯,q¯ T, q); T0T_0 Granular / particulate Granular flow v, σ, ϕφ d+6+1d+6+1 Hyp. + evol. Yes Yes μs,ϕmax _s, _ , dilation; ϕ0 _0 Coupled Thermo-mechanical u, T d+1d+1 Elliptic+parabolic Yes Depends E(T),ν,αT,k,cpE(T),ν, _T,k,c_p; BCs; T0T_0 Fluid-structure (FSI) su_s, fv_f, p 2d+12d+1 Mixed Yes Depends Solid+fluid props; interface conditions Thermofluid v, p, T d+2d+2 Parabolic Yes No ρ,μ,k,cp,βρ,μ,k,c_p,β; BCs; 0,T0v_0,T_0 †For path-dependent materials (viscoelastic, damage), add state variables α with evolution equations. ‡Steady-state heat conduction is elliptic (no ICs); transient is parabolic (requires T0T_0). Notation: u displacement, v velocity, p pressure, T temperature, F deformation gradient, σ stress, d spatial dimension, E Young’s modulus, ν Poisson’s ratio, ρ density, μ dynamic viscosity, k thermal conductivity, cpc_p specific heat, b body force, ¯ u/¯ t prescribed displacement/traction, ϕφ solid fraction, αT _T thermal expansion, β buoyancy coefficient. Every entry in Table˜1 represents information that the agents must either extract from the image (geometry, material appearance), infer from engineering judgement (BCs, loads, whether the problem is static or dynamic, whether thermal effects matter), or select from domain knowledge (constitutive model, need for initial conditions, presence of internal state). Dynamic problems always require initial conditions; path-dependent materials always carry internal state variables α that must be initialised and evolved; coupled problems require interface conditions between domains. The table is not exhaustive; piezoelectric, magnetohydrodynamic, phase-field fracture, chemically reactive, and many other physics models follow the same pattern of fields, equations, constitutive closure, and boundary/initial data. Coupled multi-physics Many engineering problems involve coupling between two or more physics from Table˜1. Thermo-mechanical coupling requires temperature-dependent material properties and thermal expansion; fluid-structure interaction (FSI) requires kinematic and dynamic conditions at the fluid-solid interface; thermofluid problems couple the Navier-Stokes equations with energy transport. Coupled solvers may handle all physics in a single code (monolithic), or separate solvers may be coupled via libraries such as preCICE [51] using message-passing interface (MPI) data exchange at shared interfaces. The discretisation selector agent must identify whether coupling is required and, if so, whether a monolithic or partitioned approach is appropriate. 4.2 The inverse problem: agents as conditioned operators Before the forward problem can be solved, the agents must address what is fundamentally an inverse problem: given a photograph I and optional context ℳctxM_ctx, determine the geometry Ω , material parameters mat θ_mat, boundary conditions, and loading that define the forward problem. This is precisely the image extraction operator of Equation˜9. Framing it as an inverse problem clarifies why the agents are effective: each agent i=(si,i,mi,pLM)A_i=A(s_i,T_i,m_i,p_LM) from Equation˜2 is a conditioned operator, conditioned by its system prompt sis_i and memory mim_i on the accumulated knowledge of engineering practice. The language model pLMp_LM, trained on engineering textbooks, design codes, and solver documentation, provides a strong prior for this inverse problem. The agent’s output is not a blind guess but a maximum a posteriori estimate conditioned on both the image evidence and the engineering prior, with uncertainty bounds that propagate through the pipeline. This inverse-problem perspective explains the three-layer architecture. The perception layer solves the geometric and material inverse: what component is this, and what is it made of? The analysis layer solves the forward problem: given the inferred inputs, what are the response fields? The assessment layer solves the design inverse: given the response, does the component satisfy the code requirements, and if not, what changes would make it adequate? 4.3 From continuum to algebra: discretisation and solvers The continuum PDEs of Table˜1 define fields over infinite-dimensional function spaces. Discretisation transforms them into finite-dimensional algebraic systems (=KU=F for static problems, ¨+˙+=M U+C U+KU=F for dynamics) that can be solved by linear algebra routines. The choice of discretisation method determines the structure of these algebraic systems, and the choice of solver software determines the available element types, constitutive models, contact formulations, and output formats. Solvers may be commercial (ABAQUS, ANSYS, COMSOL), open-source (CalculiX [26], OpenFOAM, FEniCS [49], deal.I [50]), or in-house research codes. Each solver encodes specific physics capabilities, constitutive model libraries, and input/output formats in its documentation. The solver agent must consult this documentation to assemble valid input files, a task for which LLMs are particularly well-suited, as they can parse and reason about technical documentation. The strong and weak forms presented below are the mathematical content that every solver implements internally; the agent’s role is to select the appropriate solver and provide it with the correct inputs, not to re-derive the discretisation. 4.4 Strong and weak forms Whether a method works from the strong form (pointwise PDE satisfied at collocation points or particles, as in SPH, classical DEM, and finite difference / collocation schemes) or from the weak form (integral statement tested against admissible variations, as in FEM, FVM, and MPM) is itself part of the discretisation choice. We state both forms below; individual solvers implement the one appropriate to their method. For solid mechanics, consider a body Ω⊂ℝd ^d with ∂Ω=ΓD∪ΓN∂ = _D∪ _N. The strong form (momentum balance): ∇⋅+=ρ¨in Ω,∇· σ+b=ρ u , (15) with constitutive =^(,˙,) σ= σ( , , α), BCs =¯u= u on ΓD _D, ⋅=¯ σ·n= t on ΓN _N, and ICs (,0)=0u(x,0)=u_0, ˙(,0)=˙0 u(x,0)= u_0 for dynamics. The weak form: find ∈u such that ∀∈0 _0: ∫Ω:()dΩ=∫Ω⋅dΩ+∫ΓN¯⋅dΓ+∫Ωρ¨⋅dΩ. _ σ: (v)\,d = _ b·v\,d + _ _N t·v\,d + _ ρ u·v\,d . (16) For statics with linear elasticity, this reduces to minimising Π()=12∫Ω:ℂ:dΩ−∫Ω⋅dΩ−∫ΓN¯⋅dΓ (u)= 12 _ :C: \,d - _ b·u\,d - _ _N t·u\,d . Analogous strong/weak forms exist for each physics in Table˜1; the key point is that every solver implements one or more of these forms internally, and the agent’s task is to provide the correct inputs from the rows of Table˜1. 4.5 Discretisation methods Each method transforms the weak form into an algebraic system differently: Finite element method (mesh-based) Decompose Ω=⋃eΩe = _e _e, approximate h=∑aNaau^h= _aN_au_a, yielding =KU=F with element stiffness e=∫ΩeTdΩK_e= _ _eB^TDB\,d . Available in CalculiX [26], FEniCS [49], deal.I [50], and commercial codes. Smoothed particle hydrodynamics (meshfree) Kernel approximation ⟨f()⟩≈∑b(mb/ρb)f(b)W(−b,h) f(x) ≈ _b(m_b/ _b)f(x_b)W(x-x_b,h) transforms PDEs into ODE systems on particles [45, 46]. Available in DualSPHysics [55], LAMMPS [56]. Material point method (hybrid) Material points carry state through a background grid [41, 47]. Grid quantities assembled as mIL=∑pNI(p)mpm_I^L= _pN_I(x_p)m_p. Available in CB-Geo, Taichi MPM. Peridynamics (nonlocal) Replaces ∇⋅∇· σ with an integral ∫ℋδ((′)−(),′−)dV′ _H_δf(u(x )-u(x),x -x)\,dV_x [43, 44], naturally handling fracture. Available in Peridigm. Discrete element method (particle-based, explicit) Models granular and particulate materials as collections of rigid or deformable particles interacting through contact forces. Newton’s second law is integrated for each particle i: mi¨i=∑jijcontact+mim_i x_i= _jf_ij^contact+m_ig, where contact forces ijf_ij are computed from overlap, relative velocity, and friction models (Hertz-Mindlin, linear spring-dashpot). Naturally handles granular flow, crushing, mixing, and segregation. Available in YADE [52], MercuryDPM [53], LIGGGHTS [57], BlazeDEM [58], and LAMMPS [56]. Finite volume method (conservation-form) Cell-centred discretisation of ∂t∫VidV+∮∂Vi⋅dS=∫VidV _t _V_iQ\,dV+ _∂ V_iF·n\,dS= _V_iS\,dV using numerical fluxes. Available in OpenFOAM [59], SU2 [60]. 4.6 Discretisation selection and solver documentation The preceding subsections focused on structural mechanics because the demonstration in Section˜6 is a structural problem. The same philosophy applies directly to fluids (FVM discretisation, OpenFOAM solver), heat transfer (FEM with thermal elements, or FVM), granular flows (DEM or MPM), and coupled problems (partitioned or monolithic solvers). In every case, the agent’s task is the same: identify the physics from Table˜1, select the appropriate discretisation, consult the solver documentation to assemble valid input files, and provide the correct fields, constitutive parameters, and boundary/initial conditions. The discretisation selection logic takes problem type P, material model ℳM, expected deformation magnitude δmax _ , and a fracture flag f as inputs, and returns a discretisation method D and solver C. The selection proceeds as follows. For structural problems: if fracture is expected, peridynamics (Peridigm) is selected; if large deformations exceed a threshold δmax>δthr _ > _thr and the material is history-dependent, MPM (CB-Geo) is selected; otherwise FEM (CalculiX or FEniCS) is used. For granular flows, DEM (YADE, MercuryDPM, or LIGGGHTS) is selected. For fluid problems, SPH (DualSPHysics) is chosen when free surfaces are present, and FVM (OpenFOAM) otherwise. Thermal problems use FEM or FVM, and coupled problems use partitioned solvers with preCICE for inter-solver communication. 5 Task-dependent conservatism “What does ‘conservative’ mean?” The answer depends on the loading type, the limit state, and the parameter being varied. Although we illustrate with structural examples (because the demonstration in Section˜6 is structural), the principle is general: in CFD, a conservative inlet velocity estimate differs for drag assessment vs. lift assessment; in heat transfer, a conservative thermal conductivity differs for maximum-temperature vs. thermal-stress predictions. The core issue For any response function fk()f_k( θ) depending on uncertain parameters ∈Θ θ∈ , the conservative value is maxfk _ θf_k if the limit state is exceeded when fkf_k is large (e.g., stress exceeding yield), or minfk _ θf_k if the limit state is exceeded when fkf_k is small (e.g., buckling load falling below applied load). Different limit states k may have different maximising/minimising ∗ θ^*, making a single “conservative” parameter set logically impossible. Structural example In load-controlled problems (constant applied force), flexible BCs increase both peak stress and deflection, conservative for both strength and stiffness. In displacement-controlled problems (prescribed displacement), stiffer structures generate higher internal forces; the conservatism direction reverses. Stress concentrations at geometric discontinuities (KtK_t) further complicate the picture, as stiffer structures cannot redistribute load around these features. Formal framework Let ∈Θ⊂ℝp θ∈ ^p with intervals θj∈[θj−,θj+] _j∈[ _j^-, _j^+]. The task-dependent conservative values are: fk,cons=max∈Θfk(),if limit state triggered by large fk,min∈Θfk(),if limit state triggered by small fk.f_k,cons= cases _ θ∈ f_k( θ),&if limit state triggered by large f_k,\\ _ θ∈ f_k( θ),&if limit state triggered by small f_k. cases (17) Adequacy requires simultaneous satisfaction across all limit states: PASS⇔⋀kgk(fk,cons)≤0.PASS _kg_k(f_k,cons)≤ 0. (18) In practice, Θ is explored through N discrete variants, reporting the factor of safety (FoS) range: FoSminstrength=minifyfs(i),FoSmaxstrength=maxifyfs(i),FoS_ ^strength= _i f_yf_s( θ_i), _ ^strength= _i f_yf_s( θ_i), (19) appropriately representing the uncertainty range rather than a single misleading value. 6 Demonstration: Steel L-bracket analysis We demonstrate the framework applied to a zinc-plated steel L-bracket. The complete input to the pipeline is a single photograph of the component held against a wall in its intended installation orientation (Figure˜2(a)); no CAD files, engineering drawings, material certificates, dimensional measurements, or user text are supplied. Every engineering parameter (geometry, material grade, design code, boundary conditions, load magnitudes, and safety factors) is inferred by the agents from the image alone. In particular, the service load is inferred by the BC/load-specifier agent from visual cues (shelf-bracket geometry, zinc plating, wall-mount hole pattern) combined with engineering practice for domestic wall-mounted shelving. The orchestrator instantiates nine agents from the twelve types defined in Section˜2: the four perception-layer roles are merged into a single geometry analyst (Agent 1), the five analysis-layer roles map to Agents 2 to 6 (mesh modeller, mesh reviewer, BC/load specifier, analytical bounder, FEA solver), and the three assessment-layer roles map to Agents 7 to 9 (uncertainty analyst, which also absorbs the convergence assessor and bound verifier roles, design recommender, and report writer). For this structural FEA problem, the discretisation selector chooses FEM with Gmsh meshing and CalculiX solving. Each subsection describes the responsible agent’s role, the qualitative and quantitative judgements it makes, and its output. 6.1 Agent 1 (Perception): Geometry analyst Role. Receives a photograph and produces a manufacturing-step description: base stock definition, sequential operations (bends, holes) with explicit coordinate system, inner-bend/outer-bend radius identification, and junction connectivity requirements specifying which surfaces of adjacent features must be flush. L-bracket output. From the photograph (Figure˜2(a)), the agent extracts: L-bracket corner brace, AISI 1008/DC01 cold-rolled mild steel (inferred from zinc electroplating and hardware-store product class), 25×2.525× 2.5 m flat bar bent 90° with equal leg length 125 m125\,m, inner-bend radius 3 m3\,m and outer-bend radius 5.5 m5.5\,m, six 5 m5\,m through-holes (three per arm at 25, 62.5, and 100 m100\,m from the bend), each with a detected 10 m10\,m countersink on the visible face (modelled conservatively as a stepped two-diameter hole, a larger shallow cylindrical pocket intersecting the through-hole, which captures the dominant net-section reduction and rim stress concentration). Conservative yield strength σy=200 MPa _y=$200\,MPa$ is adopted. The geometry is established from a consensus of three independent estimation methods (hand-scale reference, proportional reasoning, and standard product matching), all agreeing within 25%. All dimensions carry ±15%± 15\% uncertainty following Section˜3. Table˜2 compares the autonomously extracted values against ground-truth measurements obtained by physical inspection of the component. Table 2: Comparison of autonomously extracted geometry (from photograph) against ground-truth physical measurements, together with the derived bracket self-weight. The extracted uncertainty interval [θ−,θ+][θ^-,θ^+] should contain the true value. Five geometric parameters and the derived self-weight fall outside bounds. The agent correctly identifies the bar width (25 m) and inner-bend radius (3 m) but under-estimates arm length by 17% and thickness by 17%. The self-weight underestimate compounds the length and thickness errors but does not materially affect the analysis because the self-weight G is negligible compared to the applied design load (G≈1.2 NG≈$1.2\,N$ vs P=200 NP=$200\,N$). Parameter Extracted Interval True In bounds? Arm length (m) 125 [106.3, 143.8] 150 No (−17%-17\%) Width (m) 25 [21.3, 28.8] 25 Yes Thickness (m) 2.5 [2.13, 2.88] 3.0 No (−17%-17\%) RinnerR_inner (m) 3.0 [2.55, 3.45] 3.0 Yes RouterR_outer (m) 5.5 [4.68, 6.33] 6.0 Yes Hole diameter (m) 5.0 [4.25, 5.75] 6.0 No (−17%-17\%) Countersink dia. (m) 10.0 [8.5, 11.5] 10.0 Yes Hole 1 from edge (m) 25 [21.3, 28.8] 12.5 No (+100%+100\%) Hole 2 from edge (m) 62.5 [53.1, 71.9] 68.5 Yes Hole 3 from edge (m) 100 [85.0, 115.0] 119.5 No (−16%-16\%) Derived: bracket self-weight (from extracted geometry + steel density) Bracket mass (g) 118 [94, 142] 170 No (−31%-31\%) Self-weight G (N) 1.16 [0.93, 1.39] 1.68 No (−31%-31\%) Five geometric parameters fall outside the extracted bounds, and the derived self-weight (G=1.16 NG=$1.16\,N$ vs measured 1.68 N1.68\,N for the 170 g bracket) is under-estimated by 31% as a compound consequence of the arm-length and thickness errors. The arm length is under-estimated by 17% (true 150 m vs extracted 125 m). The thickness is under-estimated by 17% (true 3.0 m vs extracted 2.5 m). The width is correctly identified (25 m), and the inner-bend radius is correctly identified (3.0 m). The nearest hole position is over-estimated by 100%, and the furthest hole position falls just outside the ±15%± 15\% bounds. The hole diameter is under-estimated (true 6 m vs extracted 5 m). The agent detects the 10 m10\,m countersink on each hole from the visible ring/depression pattern, and its diameter estimate (10 m) matches ground truth. These discrepancies illustrate both the capability and limitations of image-based extraction, a field that is evolving rapidly as multimodal vision-language models improve: the agent correctly identifies the component type, material grade, width, bend radius, most hole positions, and the countersink feature, but struggles with the arm length and thickness, both difficult to resolve precisely from a single photograph without a calibrated reference. The arm-length and thickness errors are particularly consequential: arm length enters the bending moment linearly and deflection cubically (δ∼L3δ L^3), while thickness enters the section modulus as t2t^2 and stiffness as t3t^3. These are precisely the parameters that a reviewing engineer (Section˜7) should verify by physical measurement before relying on the analysis results. (a) Input photograph. The geometry analyst uses the hand as scale reference and identifies six holes, the 90∘90 bend, and zinc plating to infer material grade. (b) 3D mesh (isometric view): 171,504 nodes, 102,466 C3D10 elements. Hierarchical three-zone refinement: 0.5 m at the bend region, 0.8 m at hole/countersink features, 3.0 m global background. The discretisation generator agent places the finest elements at the inner-bend corner and the holes, the expected stress hot-spots. Figure 2: From photograph to finite element mesh. (a) Input image with visual cues used for geometry extraction and material identification. (b) Resulting tetrahedral mesh with graded refinement. 6.2 Agents 2 and 3 (Analysis): Mesh generation and review (Gate 1) Role. The discretisation generator agent (Agent 2) decided on a feature-relative placement approach for the geometry construction, after considering alternatives (absolute-coordinate construction, sketch-and-extrude, CSG primitives). Concretely, its chosen approach is: the fillet is created first, then arm positions are computed analytically from the fillet’s endpoint coordinates at each junction angle, guaranteeing that arm faces are mathematically flush with fillet surfaces. For each hole where the perception agent detected edge features (countersinks, chamfers), the generator models these as additional boolean-subtracted geometry: countersinks as larger-diameter shallow cylindrical pockets on the detected surface. After boolean fuse and feature subtraction, junction verification confirms a single connected solid. Mesh refinement is applied at countersink rims as additional hot-spots. The reviewer agent (Agent 3) independently verifies the mesh against the photograph, checks junction connectivity, and traces the outside profile for continuity; this constitutes Gate 1 (mesh review, GCS audit, feature placement checklist). L-bracket output. The resulting mesh (Figures˜2(b) and 3) comprises 171,504 nodes and 102,466 C3D10 elements with hierarchical three-zone refinement (0.5 m at the bend, 0.8 m at hole/countersink features, 3.0 m global) and countersink features modelled at each hole as boolean-subtracted cones on the front (+Z) face. A coarse mesh (35,591 nodes, 18,727 elements) is also generated for convergence checking. The reviewer agent confirms the outside profile traces smoothly through the outer-bend surface connecting both arms’ outer faces. Figure 3: Autonomous mesh feature audit. The discretisation reviewer agent scans the generated mesh to confirm hole count, identifies each hole with an index, and reports diameters, positions, and countersink presence. The inner-bend region carries the finest element size (0.5 m), with secondary refinement at hole/countersink features (0.8 m), selected automatically by the discretisation generator agent. 6.3 Agents 4 and 5 (Analysis): Loading, BCs, and analytical bounds Agent 4: BC and load specifier. Identifies the applicable design code (e.g. AS/NZS 4600 [32] for cold-formed steel, EN 1993-1-1 [28], EN 1990 [29], or international equivalents [30, 31]). Produces ≥3≥ 3 BC variants, each tagged for conservatism direction (Section˜5). Generates code-compliant load combinations with explicit clause references and partial safety factors. Agent 5: Analytical bounder. Establishes upper and lower bounds with full working shown: section properties (I, Z, ZnetZ_net), stress bounds with stress concentration factors (SCF) [35], deflection bounds from beam theory, and Euler buckling. L-bracket output. Agent 4 identifies the bracket as a cold-formed steel corner brace and selects AS/NZS 4600:2018 [32] (cold-formed steel structures) with supplementary reference to EN 1993-1-3 [28] for resistance checks. The agent infers the design load directly from the image: the component is identified as a domestic wall-mounted shelf bracket, and a design cantilever load of P=200 NP=$200\,N$ (20 kg20\,kg) is adopted from typical domestic shelving practice. The safety factor γ=1.5γ=1.5 is applied at the resistance side (allowable stress =σy/γ=200/1.5=133 MPa= _y/γ=200/1.5=$133\,MPa$), and the deflection limit is set at L/50=2.5 mmL/50=$2.5\,m$ for a secondary bracket element. Loading (agent-inferred design load, P=200 NP=$200\,N$). Two load cases are defined: • LC1: 200 N200\,N uniformly distributed load (UDL) on the horizontal arm top surface, direction −Y-Y (gravity). Represents distributed shelf loading. • LC2: 200 N200\,N concentrated at the horizontal arm tip. Represents worst-case point loading. An upper load variant (P=300 NP=$300\,N$, 1.5×1.5× baseline) and a lower Young’s modulus variant (E=190 GPaE=$190\,GPa$) are included for sensitivity checking. Boundary conditions (three variants spanning physical uncertainty) The agent reasons that the bracket is mounted to a wall via screws through the vertical arm holes. The uncertainty in wall substrate and fastener quality motivates three hypotheses: • Nominal: displacement DOFs (ux=uy=uz=0u_x=u_y=u_z=0) fixed at all three vertical-arm hole annular surfaces. Represents: screws in solid masonry providing full displacement restraint at each fastener. • Stiff (over-constrained): entire back face (−Z-Z) of the vertical leg fixed. Represents: full face clamping providing both displacement and rotational restraint. Strength-conservative (concentrates stress at the bend). • Flexible (under-constrained): only the topmost vertical-arm hole (V3) fully fixed (ux=uy=uz=0u_x=u_y=u_z=0); lower holes V1 and V2 constrained in ux,uzu_x,u_z only (allowing vertical sliding). Represents: screws in plasterboard with limited pull-out resistance. Stiffness-conservative (maximises deflection). This is a load-controlled problem (constant applied force regardless of structural stiffness), which governs the conservatism interpretation (Section˜5). Analytical bounds (Agent 5) Full working: I=bt3/12=25×2.53/12=32.55 m4I=bt^3/12=25× 2.5^3/12=$32.55\,mm^4$, S=bt2/6=26.04 m3S=bt^2/6=$26.04\,mm^3$, Z=bt2/4=39.06 m3Z=bt^2/4=$39.06\,mm^3$. For LC1 (200 N UDL, effective moment arm L/2L/2): M=PL/2=200×125/2=12 500 N mmM=PL/2=200× 125/2=$12\,500\,N\,m$, σ=M/S=480 MPaσ=M/S=$480\,MPa$ (gross section, no SCF), exceeding yield by 2.4×2.4×. Deflection: δ=PL3/(8EI)=7.5 mδ=PL^3/(8EI)=$7.5\,m$. For LC2 (200 N concentrated tip): M=PL=25 000 N mmM=PL=$25\,000\,N\,m$, σ=960 MPaσ=$960\,MPa$ (4.8×4.8× yield). Stress bounds: 300 to 1000 MPa; deflection bounds: 3 to 25 m. Scaling laws: σ∼1/t2σ 1/t^2, δ∼1/t3δ 1/t^3; thickness is the most powerful geometric lever. 6.4 Agent 6 (Analysis): Finite element results Role. Assembles CalculiX [26] input files with reproducibility headers, executes analyses, parses output, generates stress contour images via PyVista, verifies all results against Agent 5 bounds. L-bracket output. Agent 6 executes seven CalculiX analyses spanning 3 BC variants, 2 load cases, a 1.5×1.5× load variant, a lower-E material variant, and a coarse-mesh convergence check. Table˜3 summarises results. Peak stresses occur at the outer surface of the vertical leg near hole V1 at the BC fixation boundary, a stress singularity, not a physical stress concentration. The engineering bending stress at the bend (from hand calculation) is 480 MPa480\,MPa for LC1, which is consistent with the FEA average stress at the bend cross-section. The BC variants produce meaningfully different results: the stiff variant reduces peak stress by 52% (799 vs 1651 MPa), while the flexible variant increases deflection by 4% (11.15 vs 10.77 m). The concentrated tip load (LC2, R4) produces the worst case: 4153 MPa4153\,MPa peak stress and 33.75 m33.75\,m deflection. Linear scaling is confirmed by R5 (1.5×1.5× load producing exactly 1.5×1.5× stress and deflection). Figure˜4 shows the von Mises stress distribution across all three BC variants, and Figure˜5 shows the corresponding deformed shapes. Table 3: FEA simulation matrix (t=2.5t=2.5 m baseline with countersinks). Peak VM stress is at the BC singularity; the engineering bending stress at the bend is 480 MPa480\,MPa for LC1. R7 is the coarse-mesh convergence check. Run BC Load Variant σmax _ (MPa) δmax _ (m) Cons. for R1 Nominal LC1 (UDL) Baseline 1651 10.77 Baseline R2 Stiff LC1 (UDL) Baseline 799 6.59 - R3 Flexible LC1 (UDL) Baseline 2024 11.15 Stiffness R4 Nominal LC2 (Tip) Baseline 4153 33.75 Strength R5 Nominal LC1 (UDL) 300 N 2477 16.15 Scaling R6 Nominal LC1 (UDL) E=190E=190 1651 11.34 E-sens. R7 Nominal LC1 (UDL) Coarse 1166 11.06 Convergence Figure 4: Von Mises stress across all three BC variants (LC1, 200 N UDL). Left column: full bracket view; right column: zoom into the inner-bend region at the two nearest holes. Nominal (top): peak σVM=1651 MPa _VM=$1651\,MPa$ at BC singularity. Flexible (middle): peak σVM=2024 MPa _VM=$2024\,MPa$, highest stress. Stiff (bottom): peak σVM=799 MPa _VM=$799\,MPa$, lowest stress due to back-face clamping distributing load. The inner-bend is autonomously identified as the critical hot-spot; the engineering bending stress at the bend cross-section (480 MPa480\,MPa) is consistent with the hand calculation. Figure 5: Deformed shapes (front view, warp ×0.5× 0.5, common colour scale) for all three BC variants under LC1 (200 N UDL). Nominal: δmax=10.77 m _ =$10.77\,m$; flexible: δmax=11.15 m _ =$11.15\,m$ (stiffness-conservative); stiff: δmax=6.59 m _ =$6.59\,m$. The flexible variant produces the largest deflection, confirming it is conservative for stiffness under load-controlled conditions (Section˜5). 6.5 Agent 7 (Analysis): Uncertainty quantification (Gates 2 and 3) Role. Categorises and quantifies geometric, material, BC, loading, and discretisation uncertainties. Produces separate conservative envelopes per limit state following Section˜5. This agent also executes Gate 2 (mesh convergence assessment, comparing fine and coarse mesh results) and Gate 3 (analytical bound verification, checking that FEA results are consistent with the hand-calculation bounds from Agent 5). L-bracket output. The uncertainty analyst categorises six uncertainty sources and ranks them by impact. Thickness (range 2.0 to 3.0 m) and load distribution type (UDL vs concentrated) are jointly Rank 1: thickness drives ±57%± 57\% stress variation (σ∼1/t2σ 1/t^2) and ±95%± 95\% deflection variation (δ∼1/t3δ 1/t^3), while load type produces a 2.52×2.52× stress variation and 3.13×3.13× deflection variation between R1 and R4. BC stiffness is Rank 2, with peak stress ranging from 799 MPa799\,MPa (stiff, R2) to 2024 MPa2024\,MPa (flexible, R3), a factor of 2.5×2.5×. Material yield strength (200 to 280 MPa due to possible work hardening) is Rank 2 for strength (affecting FoS range 0.42 to 0.58), while Young’s modulus (190 to 210 GPa) is Rank 5 with only 5.3% deflection impact and no stress impact (confirmed by R6). Figure˜6 shows the stress results across all variants. Mesh convergence (Gate 2) yields a conditional pass: displacement converges to 2.7% (R1 fine: 10.77 m vs R7 coarse: 11.06 m, marginal at the 2% threshold), while peak stress shows 29% non-convergence at the BC singularity, expected and acceptable since the singularity stress is not used for the design check. Analytical bound verification (Gate 3) confirms the FEA average bend stress is consistent with the 480 MPa480\,MPa hand calculation; the FEA tip deflection (10.77 m) exceeds the simple cantilever prediction (7.5 m) due to compliance at the bend and BC hole fixation. The strength-conservative envelope is R4 (concentrated tip load): engineering bend stress 960 MPa960\,MPa, FoS=0.21FoS=0.21 (peak VM stress at BC singularity is 4153 MPa4153\,MPa, but this is not used for the design check). The stiffness-conservative envelope is also R4: δ=33.75 mδ=$33.75\,m$ (L/3.7L/3.7). The total stress range factor across all seven runs is 5.2×5.2× (4153/799) and the deflection range factor is 5.1×5.1× (33.75/6.59), quantifying the analysis uncertainty arising from modelling choices. Figure 6: FEA simulation matrix results across all seven runs. Top: peak von Mises stress with yield (σy=200 MPa _y=$200\,MPa$), allowable (σy/1.5=133 MPa _y/1.5=$133\,MPa$), and analytical bounds [300 to 1000] MPa shown as references. Bottom: maximum displacement with the L/50=2.5 mmL/50=$2.5\,m$ serviceability limit. R4 (concentrated tip load, red) produces the worst case for both stress and deflection; R2 (stiff BC, green) produces the lowest stress. All runs exceed both yield and deflection limits. Colour coding: blue = baseline, green = best case, red = worst case, grey = sensitivity variants. 6.6 Agents 8 and 9 (Assessment): Design assessment and report (Gate 4) Agent 8: Design recommender (Gate 4). This agent does not merely check pass/fail; it interprets the results with engineering judgement to provide actionable recommendations. It identifies which limit state governs, which BC variant is critical, what physical measurements would most reduce uncertainty, and proposes specific, quantified redesign options ranked by feasibility and impact. When the component fails, the orchestrator invokes the redesign loop: the most promising option is executed autonomously and the improvement demonstrated quantitatively. The redesign loop is itself subject to a configurable iteration budget; for this study, we cap it at a single redesign iteration to keep the demonstration compact. Agent 9: Report writer. Assembles a self-contained HTML engineering report following professional simulation qualification standards, including not only results but their interpretation, explaining why the component fails, what drives the failure, and how to fix it. L-bracket output. All baseline limit states fail (Table˜4). Agent 8 interprets the results: the engineering bending stress at the bend (480 MPa480\,MPa) exceeds the allowable stress (σy/γ=200/1.5=133 MPa _y/γ=200/1.5=$133\,MPa$) by 261%, giving FoS=0.42FoS=0.42 against yield. The tip deflection (10.77 m) exceeds the L/50=2.5 mmL/50=$2.5\,m$ limit by 331%. Bearing at the screw holes passes with large margin (5.4 MPa vs 1417 MPa allowable). The maximum safe cantilever load is 46 N46\,N (4.7 kg), governed by stiffness (L/50L/50 deflection limit) rather than strength. The agent identifies thickness as the most effective redesign lever (σ∼t−2σ t^-2, δ∼t−3δ t^-3) and proposes four options: increase to 4 m (3×3× capacity), increase to 5 m (5×5× capacity), add a diagonal gusset (>10×>10×), or reclassify as a light-duty 5 kg bracket. The orchestrator invokes the redesign loop: thickness increase from 2.5 to 5.0 m (countersinks retained, 147,765-node redesign mesh). Three redesign runs are executed (R1_rd: nominal LC1, R3_rd: flexible LC1, R4_rd: concentrated LC2). Figure˜7 shows the improvement: the engineering bend stress drops from 480 to 156.6 MPa156.6\,MPa (67% reduction), giving FoS=1.28FoS=1.28 against yield, and deflection drops from 10.77 to 1.55 m1.55\,m (86% reduction, consistent with (5/2.5)3=8×(5/2.5)^3=8× beam-theory scaling). The actual stress ratio (0.33) deviates from the pure 1/t21/t^2 prediction (0.25) because the bend stress concentration factor KtK_t changes as the t/rit/r_i ratio increases from 0.83 to 1.67. The redesign achieves conditional pass for LC1 service loading: it passes the deflection limit (1.55<2.51.55<2.5 m) and is marginal against the γ=1.5γ=1.5 code allowable (FoScode=0.85FoS_code=0.85, resolvable by accepting γ=1.25γ=1.25 for a non-critical bracket or using work-hardened DC01 yield). LC2 (concentrated tip) remains a fail (FoS=0.53FoS=0.53, δ=4.51δ=4.51 m). Table 4: Code-compliance assessment. Baseline (t=2.5t=2.5 m) fails all strength/stiffness checks. Maximum safe load: 46 N46\,N (4.7 kg), governed by stiffness. Notation: σbend _bend = engineering bending stress at the bend, σy _y = yield strength (200 MPa200\,MPa), σb _b = bearing stress, fuf_u = ultimate tensile strength (340 MPa340\,MPa), t = thickness, γ=1.5γ=1.5 = safety factor, L = arm length, δ = tip deflection, FoS = factor of safety, ULS = ultimate limit state, SLS = serviceability limit state. Check Criterion Value Limit Verdict Baseline (t=2.5t=2.5 m), nominal BC, 200 N UDL: Strength (ULS) σbend<σy/1.5 _bend< _y/1.5 480 MPa 133 MPa FAIL (FoS = 0.42) Stiffness (SLS) δ<L/50δ<L/50 10.77 m 2.5 m FAIL Bearing σb<2.5fut/γ _b<2.5f_ut/γ 5.4 MPa 1417 MPa PASS Redesign (t=5.0t=5.0 m), nominal BC, 200 N UDL: Strength (ULS) σbend<σy/1.5 _bend< _y/1.5 156.6 MPa 133 MPa COND. (FoSy = 1.28) Stiffness (SLS) δ<L/50δ<L/50 1.55 m 2.5 m PASS Figure˜7 compares the baseline (t=2.5t=2.5 m) and redesigned (t=5.0t=5.0 m) bracket side by side, showing geometry, inner-bend mesh detail, and a quantitative comparison of mesh metrics and structural results. The embedded table confirms beam-theory scaling: deflection reduces by 6.95×6.95× (close to the (5/2.5)3=8×(5/2.5)^3=8× prediction), while stress reduces by 3.07×3.07× (deviating from (5/2.5)2=4×(5/2.5)^2=4× due to the bend KtK_t changing as the t/rit/r_i ratio increases from 0.83 to 1.67). Weight increases by 100%. Figure 7: Autonomous redesign outcome: baseline (t=2.5t=2.5 m, top) versus redesign RD2 (t=5.0t=5.0 m, bottom) for the nominal BC variant. Left: bracket geometry; centre: inner-bend mesh detail; right: mesh and result metrics including scaling ratios versus beam-theory predictions. The redesigned bracket achieves conditional pass for LC1 (distributed loading) but fails LC2 (concentrated tip load), confirming that the bracket is adequate for its intended shelf-support application but not for point loads at the arm tip. The pipeline recommends further measures for extreme loads: adding a diagonal gusset for triangulation (changing the load path from bending-dominated to axial-dominated) or reducing the arm length. These results require engineer review (Section˜7). 6.7 Pipeline execution statistics Table˜5 summarises the computational cost and resource usage of the complete pipeline run. The nine-agent pipeline completes in 22 minutes wall-clock time, consuming 92,245 tokens across 36 tool calls and producing approximately 46 files (7 FEA input/output sets, geometry and mesh specifications, JSON assessment records, and the final engineering report). At Claude Opus 4 API pricing ($15/M input, $75/M output tokens), the estimated cost is $3.05; on Claude Sonnet 4 ($3/M input, $15/M output) the same pipeline would cost approximately $0.61. Table 5: Pipeline execution statistics. All nine agents complete their checklist items on the first attempt (no gate re-iterations required). The FEA solver agent consumes the most tokens due to the seven-run simulation matrix. Cost estimates assume Claude Opus 4 API pricing. Metric Value Metric Value Wall-clock time 22 min 5 s Total tokens 92,245 Agents invoked 9 Tool calls 36 FEA runs (baseline) 7 FEA runs (redesign) 3 Gate iterations (G1 to G4) 1 each Files generated ∼ 46 Estimated cost (Opus 4) $3.05 Estimated cost (Sonnet 4) $0.61 Several aspects of the execution merit discussion. First, all four quality gates pass on the first iteration: Gate 1 (Agent 3, mesh reviewer: GCS audit, feature placement, mesh quality) PASS; Gate 2 (Agent 7, uncertainty analyst: mesh convergence) CONDITIONAL PASS; Gate 3 (Agent 7: analytical bound verification) CONDITIONAL PASS; Gate 4 (Agent 8, design recommender: code compliance) FAIL, a correct engineering outcome, not a pipeline error. The absence of gate re-iterations indicates that the inter-agent communication protocol (Section˜2.3) is functioning effectively; agents produce outputs that satisfy downstream verification on the first attempt. Second, the token distribution is approximately 70% input / 30% output, reflecting the pipeline’s design pattern where each agent receives a rich shared context (geometry specification, prior agent outputs, gate feedback) and produces relatively compact structured outputs (JSON specifications, solver input files, assessment records). The FEA solver agent is the most token-intensive (∼ 14,000 tokens) because it generates seven complete CalculiX input files with boundary conditions, material definitions, and load steps. Third, the quality metrics confirm internal consistency: the feature placement checklist (FPC) achieves 100% completeness (6/6 features correctly placed), dimensional consensus is achieved across three independent estimation methods (all within 25%), and linear scaling is validated (R5=1.5×R1R5=1.5×R1 exactly for both stress and deflection). The 22-minute execution time is dominated by CalculiX solver time for the seven fine-mesh runs (171,504 nodes each) and three redesign runs. The LLM inference time is a small fraction of the total. This suggests that for larger models or finer meshes, the pipeline remains LLM-cost-bounded rather than compute-bounded, an important consideration for scaling to industrial-complexity components. 7 Role of the professional engineer and self-improving architecture The results in Section˜6 are presented exactly as generated in the first autonomous iteration, without manual correction or cherry-picking. We deliberately do not assess the quality of these results, whether the mesh is adequately refined, whether the BC variants span the true physical uncertainty, whether the design code clauses are correctly applied, or whether the material assumption is valid. These assessments are left to the reader, purposefully emphasising that the sign-off role of a qualified professional engineer is irreplaceable. This is not a limitation but a feature. The framework produces a complete first draft in ∼ 22 minutes rather than 2 to 4 days, at an API cost of approximately $3. The engineer’s role is then to review, critique, provide critical feedback to the agents, and sign off, bringing professional judgement, contextual knowledge, and regulatory responsibility. A useful mental model is to treat each agent as an engineer in training: capable, diligent, but still acquiring experience; the critical feedback it receives from the supervising professional engineer is precisely what moves it towards being an experienced engineer over repeated analysis cycles. Specifically: (a) Validate extracted geometry and material: confirm image-derived parameters and their uncertainty bounds are physically reasonable. (b) Assess discretisation adequacy: evaluate whether the mesh (or particle distribution) resolves the quantities of interest. (c) Verify boundary conditions and loading: confirm BC variants and load combinations correctly represent physical conditions. (d) Critically review results: determine physical plausibility and identify results warranting re-analysis. (e) Professional sign-off: a registered PE/CEng/Pr.Eng. must personally certify the assessment. This certification cannot be delegated to an autonomous system, regardless of its accuracy, because it carries personal legal and professional liability. The framework makes every agent decision visible in the shared context (Section˜2.3), giving the reviewing engineer more transparency than a colleague’s manually produced analysis where many judgement calls go undocumented. The system is not designed to be flawless from the start, but rather to improve over time given proper engineering feeback. LLM agents make mistakes, misinterpret photographs, choose inappropriate boundary conditions, and occasionally produce nonsensical results. The critical design decision is not to prevent all errors but to ensure that errors are catchable through quality gates and correctable through feedback. A meta-agent (the “agent evolver”) processes engineer feedback, extracting abstract patterns from specific corrections and updating agent definitions and shared memory (Figure˜8). Over K review cycles, agent definitions evolve as si(k+1),mi(k+1)=ℱ(r(k),δr(k),si(k),mi(k))\s_i^(k+1),m_i^(k+1)\=F(r^(k),δ r^(k),\s_i^(k),m_i^(k)\), reducing the correction residual ‖δr(k)‖\|δ r^(k)\| with each cycle. This prompt-level refinement is lightweight, interpretable, and reversible. When the same correction recurs across multiple analyses, indicating a persistent weakness that prompt engineering alone cannot resolve, the feedback operator escalates to model-level refinement: supervised fine-tuning of pLMp_LM or targeted preference optimisation (DPO/RLHF) on the accumulated correction set. This two-tier architecture ensures that routine corrections are absorbed quickly at the prompt/memory level, while systematic deficiencies are addressed at the model level, progressively improving the LLM that executes the agents. Figure 8: Two-tier self-improving feedback loop. Prompt-level refinement (olive dashed): engineer corrections are distilled into abstract patterns updating agent definitions and shared memory, lightweight, interpretable, and reversible. Model-level refinement (red dashed): when the same correction recurs across multiple analyses, the feedback operator triggers supervised retraining (fine-tuning or preference optimisation) of the LLM executing the agents, so that persistent weaknesses are addressed at the model level. Each analysis performed under engineering supervision makes future analyses more reliable. 8 Discussion and conclusions We have presented a solver-agnostic multi-agent LLM framework for autonomous computational mechanics, demonstrated through an FEA pipeline transforming a photograph into a verified engineering report. The architecture is generic: the same perception, communication, uncertainty, and assessment layers apply to FEA, CFD, DEM, SPH, MPM, or LBM, with only discretisation and solver agents requiring specialisation. Capabilities The framework achieves end-to-end processing in ∼ 22 minutes at ∼ $3 API cost (vs. 2 to 4 days manually), makes defensible decisions about discretisation, code selection, and load combinations, delivers uncertainty-aware bounding envelopes rather than single deterministic results, autonomously executes redesign analyses when components fail, and identifies structural inadequacy in a real component (Section˜6.7). Limitations Engineering oversight remains essential. The current implementation handles prismatic components but would struggle with complex castings or assemblies. Only linear elastic static analysis is demonstrated. Image-derived uncertainty (±15%± 15\%) propagates into significant stress uncertainty. Geometry construction from images is fragile; feature-relative placement (Section˜3.3) mitigates this but does not eliminate it. Quality gates catch errors but are themselves LLM-based, creating a recursive verification challenge. Relationship to existing work Unlike automated meshing [25, 27] (requires CAD), PINNs [11] / neural operators [13] (approximate individual PDEs), or prior LLM-driven simulation [7, 8, 9] (generate solver inputs), this framework orchestrates the complete workflow with verification, uncertainty quantification (UQ), code-compliant assessment, and recommendations. It could initialise digital twins [38] and integrate learned constitutive laws [6]. Future work Nonlinear analysis, multi-physics coupling, DEM/SPH/MPM solver instantiation, assembly analysis, PINN surrogates for parametric sweeps, multi-view 3D reconstruction, and formal verification of agent decisions. The broader vision: any component assessed from perceptual data (image, video, audio, text) in combination. Not there yet, but the path is open. Declaration of generative AI and AI-assisted technologies in the manuscript preparation process During the preparation of this work the authors used Claude (Anthropic) in order to implement the multi-agent pipeline described in this paper, generate solver input files, and assist with manuscript preparation. After using this tool/service, the authors reviewed and edited the content as needed and take full responsibility for the content of the published article. Declaration of competing interest The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper. CRediT authorship contribution statement Daniel N. Wilke: Conceptualization, Methodology, Software, Validation, Formal analysis, Investigation, Writing – original draft, Writing – review & editing, Visualization, Supervision, Project administration. Data availability The complete agent definitions (including the full orchestrator prompt), example input data, and generated analysis files will be made publicly available upon acceptance of the paper. Acknowledgements This research did not receive any specific grant from funding agencies in the public, commercial, or not-for-profit sectors. References [1] 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, W. Zaremba, Evaluating large language models trained on code, arXiv preprint arXiv:2107.03374, 2021. doi:10.48550/arXiv.2107.03374 [2] R. Li, L. B. Allal, Y. Zi, N. Muennighoff, D. Kocetkov, C. Mou, M. Marone, C. Akiki, J. Li, J. Chim, Q. Liu, E. Zheltonozhskii, T. Y. Zhuo, T. Wang, O. Dehaene, M. Davaadorj, J. Lamy-Poirier, J. Monteiro, O. Shliazhko, N. Gontier, N. Meade, A. Zebaze, M. H. Yee, L. K. Umapathi, J. Zhu, B. Lipkin, M. Oblokulov, Z. Wang, R. Murthy, J. Stillerman, S. S. Patel, D. Abulkhanov, M. Zocca, M. Dey, Z. Zhang, N. Fahmy, U. Bhattacharyya, W. Yu, S. Singh, S. Luccioni, P. Villegas, M. Kunakov, F. Zhdanov, M. Romero, T. Lee, N. Timor, J. Ding, C. Schlesinger, H. Schoelkopf, J. Ebert, T. Dao, M. Mishra, A. Gu, J. Robinson, C. J. Anderson, B. Dolan-Gavitt, D. Contractor, S. Reddy, D. Fried, D. Bahdanau, Y. Jernite, C. M. Ferrandis, S. Hughes, T. Wolf, A. Guha, L. von Werra, H. de Vries, StarCoder: may the source be with you!, Transactions on Machine Learning Research, 2023. doi:10.48550/arXiv.2305.06161 [3] R. Taylor, M. Kardas, G. Cucurull, T. Scialom, A. Hartshorn, E. Saravia, A. Poulton, V. Kerkez, R. Stojnic, Galactica: A large language model for science, arXiv preprint arXiv:2211.09085, 2022. doi:10.48550/arXiv.2211.09085 [4] A. Lewkowycz, A. Andreassen, D. Dohan, E. Dyer, H. Michalewski, V. Ramasesh, A. Slone, C. Anil, I. Schlag, T. Gutman-Solo, Y. Wu, B. Neyshabur, G. Gur-Ari, V. Misra, Solving quantitative reasoning problems with language models, in: Advances in Neural Information Processing Systems 35, 2022. doi:10.48550/arXiv.2206.14858 [5] OpenAI, GPT-4 technical report, arXiv preprint arXiv:2303.08774, 2023. doi:10.48550/arXiv.2303.08774 [6] K. Linka, E. Kuhl, A new family of Constitutive Artificial Neural Networks towards automated model discovery, Computer Methods in Applied Mechanics and Engineering 403, Part A, (2023) 115731. doi:10.1016/j.cma.2022.115731 [7] M.J. Buehler, MechGPT, a language-based strategy for mechanics and materials modeling that connects knowledge across scales, disciplines and modalities, Applied Mechanics Reviews 76 (2) (2024) 021001. doi:10.1115/1.4063843 [8] J. Guo, C. Park, D. Qian, T.J.R. Hughes, W.K. Liu, Large language model-empowered next-generation computer-aided engineering, Computer Methods in Applied Mechanics and Engineering 450 (2026) 118591. doi:10.1016/j.cma.2025.118591 [9] Y. Qi, R. Xu, X. Chu, FeaGPT: an end-to-end agentic-AI for finite element analysis, arXiv preprint arXiv:2510.21993, 2025. doi:10.48550/arXiv.2510.21993 [10] R. Deotale, A. Srinivasan, Y. Tian, T. Zhang, P. P. Vlachos, and H. Gomez. ALL-FEM: Agentic Large Language models Fine-tuned for Finite Element Methods. arXiv preprint arXiv:2502.14925, 2026. doi:10.48550/arXiv.2603.21011 [11] M. Raissi, P. Perdikaris, G.E. Karniadakis, Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations, Journal of Computational Physics 378 (2019) 686–707. doi:10.1016/j.jcp.2018.10.045 [12] G.E. Karniadakis, I.G. Kevrekidis, L. Lu, P. Perdikaris, S. Wang, L. Yang, Physics-informed machine learning, Nature Reviews Physics 3 (2021) 422–440. doi:10.1038/s42254-021-00314-5 [13] L. Lu, P. Jin, G. Pang, Z. Zhang, G.E. Karniadakis, Learning nonlinear operators via DeepONet based on the universal approximation theorem of operators, Nature Machine Intelligence 3 (2021) 218–229. doi:10.1038/s42256-021-00302-5 [14] Z. Li, N. Kovachki, K. Azizzadenesheli, B. Liu, K. Bhattacharya, A. Stuart, A. Anandkumar, Fourier neural operator for parametric partial differential equations, in: International Conference on Learning Representations, 2021. doi:10.48550/arXiv.2010.08895 [15] J.H. Keyak, I.Y. Lee, H.B. Skinner, Correlations between orthogonal mechanical properties and density of trabecular bone: use of different densitometric measures, Journal of Biomedical Materials Research 28 (11) (1994) 1329–1336. doi:10.1002/jbm.820281111 [16] S.J. Hollister, N. Kikuchi, Homogenization theory and digital imaging: A basis for studying the mechanics and design principles of bone tissue, Biotechnology and Bioengineering 43 (7) (1994) 586–596. doi:10.1002/bit.260430708 [17] M. Wooldridge, An Introduction to MultiAgent Systems, 2nd Edition, John Wiley & Sons, 2009. ISBN: 978-0-470-51946-2. [18] A. Dorri, S.S. Kanhere, R. Jurdak, Multi-agent systems: A survey, IEEE Access 6 (2018) 28573–28593. doi:10.1109/ACCESS.2018.2831228 [19] S. Hong, M. Zhuge, J. Chen, X. Zheng, Y. Cheng, C. Zhang, J. Wang, Z. Wang, S. K. S. Yau, Z. Lin, L. Zhou, C. Ran, L. Xiao, C. Wu, and J. Schmidhuber, MetaGPT: Meta programming for a multi-agent collaborative framework, in: International Conference on Learning Representations, 2024. doi:10.48550/arXiv.2308.00352 [20] Q. Wu, G. Bansal, J. Zhang, Y. Wu, B. Li, E. Zhu, L. Jiang, X. Zhang, S. Zhang, J. Liu, A. H. Awadallah, R. W. White, D. Burger, and C. Wang, AutoGen: Enabling next-gen LLM applications via multi-agent conversation, First Conference on Language Modeling, 1328, 2024. COLM: 1328 [21] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, Y. Cao, ReAct: Synergizing reasoning and acting in language models, in: International Conference on Learning Representations, 2023. doi:10.48550/arXiv.2210.03629 [22] N. Shinn, F. Cassano, E. Berman, A. Gopinath, K. Narasimhan, S. Yao, Reflexion: Language agents with verbal reinforcement learning, in: Advances in Neural Information Processing Systems 36, 2023. CorpusID:258833055 [23] D.A. Boiko, R. MacKnight, B. Kline, G. Gomes, Autonomous chemical research with large language models, Nature 624 (2023) 570–578. doi:10.1038/s41586-023-06792-0 [24] A.M. Bran, S. Cox, O. Schilter, C. Baldassari, A.D. White, P. Schwaller, Augmenting large-language models with chemistry tools, Nature Machine Intelligence 6 (5) (2024) 525–535. doi:10.1038/s42256-024-00832-8 [25] C. Geuzaine, J.-F. Remacle, Gmsh: A 3-D finite element mesh generator with built-in pre- and post-processing facilities, International Journal for Numerical Methods in Engineering 79 (11) (2009) 1309–1331. doi:10.1002/nme.2579 [26] G. Dhondt, The Finite Element Method for Three‐Dimensional Thermomechanical Applications, Wiley, 2004. doi:10.1002/0470021217 [27] T.D. Blacker, W.J. Bohnhoff, T.L. Edwards, J.R. Hipp, R.R. Lober, S.A. Mitchell, G.D. Sjaardema, T.J. Tautges, T.J. Wilson, W.R. Oakes, CUBIT mesh generation environment, Volume 1: Users manual, Technical Report SAND94-1100, Sandia National Laboratories, 1994. doi:10.2172/10176386 [28] CEN, EN 1993-1-1:2005 – Eurocode 3: Design of Steel Structures, Brussels, 2005. Eurocode 3: Design of steel structures [29] CEN, EN 1990:2002 – Eurocode: Basis of Structural Design, Brussels, 2002. CEN, EN 1990:2002. [30] AISC, ANSI/AISC 360-22, Chicago, 2022. https://w.aisc.org/aisc/publications/current-standards/aisc-360/ [31] Standards Australia, AS 4100:2020 – Steel Structures, Sydney, 2020. ISBN: 978-1-76072-947-9. [32] Standards Australia/Standards New Zealand, AS/NZS 4600:2018 – Cold-formed Steel Structures, Sydney, 2018. 9781760720612 [33] W.L. Oberkampf, C.J. Roy, Verification and Validation in Scientific Computing, Cambridge University Press, 2010. doi:10.1017/CBO9780511760396 [34] P.J. Roache, Verification and Validation in Computational Science and Engineering, Hermosa, 1998. ISBN: 978-0-913478-08-0. 978-0913478080 [35] W.D. Pilkey, D.F. Pilkey, Peterson’s Stress Concentration Factors, 3rd Ed., Wiley, 2008. doi:10.1002/9780470211106 [36] R.E. Moore, Interval Analysis, Prentice-Hall, 1966. ISSN 2577-9435. [37] A. Ben-Tal, L. El Ghaoui, A. Nemirovski, Robust Optimization, Princeton University Press, 2009. doi:10.1515/9781400831050 [38] F. Tao, H. Zhang, A. Liu, A.Y.C. Nee, Digital twin in industry: State-of-the-art, IEEE Transactions on Industrial Informatics 15 (4) (2019) 2405–2415. doi:10.1109/TII.2018.2873186 [39] Anthropic, Claude Model Card, 2025. https://docs.anthropic.com/en/docs/about-claude/models [40] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A.N. Gomez, Ł. Kaiser, I. Polosukhin, Attention is all you need, in: Advances in Neural Information Processing Systems 30, 2017. doi:10.48550/arXiv.1706.03762 [41] D. Sulsky, Z. Chen, H.L. Schreyer, A particle method for history-dependent materials, Computer Methods in Applied Mechanics and Engineering 118 (1–2) (1994) 179–196. doi:10.1016/0045-7825(94)90112-0 [42] D. Sulsky, S.-J. Zhou, H.L. Schreyer, Application of a particle-in-cell method to solid mechanics, Computer Physics Communications 87 (1–2) (1995) 236–252. doi:10.1016/0010-4655(94)00170-7 [43] S.A. Silling, Reformulation of elasticity theory for discontinuities and long-range forces, Journal of the Mechanics and Physics of Solids 48 (1) (2000) 175–209. doi:10.1016/S0022-5096(99)00029-0 [44] S.A. Silling, M. Epton, O. Weckner, J. Xu, E. Askari, Peridynamic states and constitutive modeling, Journal of Elasticity 88 (2) (2007) 151–184. doi:10.1007/s10659-007-9125-1 [45] J.J. Monaghan, Smoothed particle hydrodynamics, Reports on Progress in Physics 68 (8) (2005) 1703. doi:10.1088/0034-4885/68/8/R01 [46] G.R. Liu, M.B. Liu, Smoothed Particle Hydrodynamics, World Scientific, 2003. doi:10.1142/5340 [47] X. Zhang, Z. Chen, Y. Liu, The Material Point Method: A Continuum-Based Particle Method for Extreme Loading Cases, Academic Press, 2017. https://w.sciencedirect.com/book/monograph/9780124077164/the-material-point-method [48] O.C. Zienkiewicz, J.Z. Zhu, A simple error estimator and adaptive procedure for practical engineering analysis, International Journal for Numerical Methods in Engineering 24 (2) (1987) 337–357. doi:10.1002/nme.1620240206 [49] A. Logg, K.-A. Mardal, G. Wells (Eds.), Automated Solution of Differential Equations by the Finite Element Method: The FEniCS Book, Springer, 2012. doi:10.1007/978-3-642-23099-8 [50] D. Arndt, W. Bangerth, B. Blais, M. Fehling, R. Gassmöller, T. Heister, L. Heltai, U. Köcher, M. Kronbichler, M. Maier, P. Munch, J. P. Pelteret, S. Proell, K. Simon, B. Turcksin, D. Wells, and J. Zhang, The deal.I library, version 9.3, Journal of Numerical Mathematics 29 (3) (2021) 171–186. doi:10.1515/jnma-2021-0081 [51] G. Chourdakis, K. Davis, B. Rodenberg, M. Schulte, F. Simonis, B. Uekermann, G. Abrams, H. J. Bungartz, L. C. Yau, I. Desai, K. Eder, R. Hertrich, F. Lindner, A. Rusch, D. Sashko, D. Schneider, A. Totounferoush, D. Volland, P. Vollmer, and O. Z. Koseomur, preCICE v2: A sustainable and user-friendly coupling library, Open Research Europe 2 (2022) 51. doi:10.12688/openreseurope.14445.2 [52] V. Smilauer, E. Catalano, B. Chareyre, S. Dorofeenko, J. Duriez, N. Dyck, J. Elias, B. Er, A. Eulitz, A. Gladky, N. Guo, C. Jakob, F. Kneib, J. Kozicki, D. Marzougui, R. Maurin, C. Modenese, L. Scholtes, L. Sibille, J. Stransky, T. Sweijen, K. Thoeni, C. Yuan, Yade Documentation, 2nd Edition, The Yade Project, 2015. doi:10.5281/zenodo.34073 [53] T. Weinhart, L. Orefice, M. Post, M.P. van Schrojenstein Lantman, I.F.C. Denissen, D.R. Tunuguntla, J.M.F. Tsang, H. Cheng, M.Y. Shaheen, H. Shi, P. Rapino, E. Grannonio, N. Losacco, J. Barbosa, L. Jing, J.E. Alvarez Naranjo, S. Roy, W.K. den Otter, A.R Thornton, Fast, flexible particle simulations—an introduction to MercuryDPM, Computer Physics Communications 249 (2020) 107129. doi:10.1016/j.cpc.2019.107129 [54] J.L. Schönberger, J.-M. Frahm, Structure-from-motion revisited, in: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016, p. 4104–4113. doi:10.1109/CVPR.2016.445 [55] J.M. Domínguez, G. Fourtakas, C. Altomare, R.B. Canelas, A. Tafuni, O. García-Feal, I. Martínez-Estévez, A. Mokos, R. Vacondio, A.J.C. Crespo, B.D. Rogers, P.K. Stansby, M. Gómez-Gesteira, DualSPHysics: from fluid dynamics to multiphysics problems, Computational Particle Mechanics 9 (5) (2022) 867–895. doi:10.1007/s40571-021-00404-2 [56] A.P. Thompson, H.M. Aktulga, R. Berger, D.S. Bolintineanu, W.M. Brown, P.S. Crozier, P.J. in ’t Veld, A. Kohlmeyer, S.G. Moore, T.D. Nguyen, R. Shan, M.J. Stevens, J. Tranchida, C. Trott, S.J. Plimpton, LAMMPS—a flexible simulation tool for particle-based materials modeling at the atomic, meso, and continuum scales, Computer Physics Communications 271 (2022) 108171. doi:10.1016/j.cpc.2021.108171 [57] C. Kloss, C. Goniva, A. Hager, S. Amberger, S. Pirker, Models, algorithms and validation for opensource DEM and CFD–DEM, Progress in Computational Fluid Dynamics 12 (2–3) (2012) 140–152. doi:10.1504/PCFD.2012.047457 [58] N. Govender, D.N. Wilke, C.-Y. Wu, R. Rajamani, J. Khinast, B.J. Glasser, Large-scale GPU based DEM modeling of mixing using irregularly shaped particles, Advanced Powder Technology 29 (10) (2018) 2476–2490. doi:10.1016/j.apt.2018.06.028 [59] H.G. Weller, G. Tabor, H. Jasak, C. Fureby, A tensorial approach to computational continuum mechanics using object-oriented techniques, Computers in Physics 12 (6) (1998) 620–631. doi:10.1063/1.168744 [60] T.D. Economon, F. Palacios, S.R. Copeland, T.W. Lukaczyk, J.J. Alonso, SU2: an open-source suite for multiphysics simulation and design, AIAA Journal 54 (3) (2016) 828–846. doi:10.2514/1.J053813 [61] I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, Y. Bengio, Generative adversarial nets, in: Advances in Neural Information Processing Systems 27, 2014. doi:10.48550/arXiv.1406.2661