d<string, unknown>;
abaqusScript: string;
jobStatus: 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED';
validationErrors: string[];
visualizationData?: string;
solverLogs?: string;
}
// 1. Interpreter Agent: Extracts physics intent
class PromptInterpreter implements SimulationAgent {
name = 'interpreter';
async execute(ctx: SimulationContext): Promise<SimulationContext> {
const requirements = await this.extractPhysicsIntent(ctx.naturalLanguagePrompt);
return { ...ctx, parsedRequirements: requirements };
}
validate(ctx: SimulationContext): boolean {
const schema = z.object({
material: z.string(),
element: z.string(),
boundaryConditions: z.array(z.object({ type: z.string(), region: z.string() })),
loads: z.array(z.object({ type: z.string(), magnitude: z.number(), region: z.string() }))
});
return schema.safeParse(ctx.parsedRequirements).success;
}
private async extractPhysicsIntent(prompt: string) {
// LLM call to extract BCs, loads, material, element type
return {
material: 'structural_steel',
element: 'C3D8R',
boundaryConditions: [{ type: 'encastre', region: 'support_face' }],
loads: [{ type: 'pressure', magnitude: 750, region: 'load_face' }]
};
}
}
// 2. Architect Agent: Defines mesh & assembly strategy
class MeshArchitect implements SimulationAgent {
name = 'architect';
async execute(ctx: SimulationContext): Promise<SimulationContext> {
const strategy = this.generateMeshStrategy(ctx.parsedRequirements);
return { ...ctx, parsedRequirements: { ...ctx.parsedRequirements, meshStrategy: strategy } };
}
validate(ctx: SimulationContext): boolean {
return ctx.parsedRequirements.meshStrategy !== undefined;
}
private generateMeshStrategy(reqs: Record<string, unknown>) {
return { type: 'structured', seedSize: 1.5, refinement: 'curvature_adaptive', minElements: 3 };
}
}
// 3. Input Writer Agent: Generates Abaqus Python script
class ScriptGenerator implements SimulationAgent {
name = 'input_writer';
async execute(ctx: SimulationContext): Promise<SimulationContext> {
const script = this.buildAbaqusScript(ctx.parsedRequirements);
return { ...ctx, abaqusScript: script };
}
validate(ctx: SimulationContext): boolean {
return ctx.abaqusScript.includes('mdb.Model') && ctx.abaqusScript.includes('job.submit');
}
private buildAbaqusScript(reqs: Record<string, unknown>): string {
const mat = reqs.material as string;
const elem = reqs.element as string;
const seed = (reqs.meshStrategy as any).seedSize;
return from abaqus import * from abaqusConstants import * import regionToolset mdb.Model(name='AutoSim', modelType=STANDARD_EXPLICIT) mdb.models['AutoSim'].Material(name='${mat}') mdb.models['AutoSim'].materials['${mat}'].Elastic(table=((210000.0, 0.3),)) p = mdb.models['AutoSim'].Part(name='Component', dimensionality=THREE_D, type=DEFORMABLE_BODY) p.seedPart(size=${seed}, deviationFactor=0.1, minNumElements=${(reqs.meshStrategy as any).minElements}) mdb.Job(name='sim_run', model='AutoSim', type=ANALYSIS, numCpus=8) mdb.jobs['sim_run'].submit() mdb.jobs['sim_run'].waitForCompletion();
}
}
// 4. Runner Agent: Executes solver & monitors status
class SolverRunner implements SimulationAgent {
name = 'runner';
async execute(ctx: SimulationContext): Promise<SimulationContext> {
const scriptPath = path.join('/tmp/abaqus_jobs', ${ctx.runId}_script.py);
await fs.writeFile(scriptPath, ctx.abaqusScript);
try {
const output = execSync(abaqus cae noGUI=${scriptPath}, { stdio: 'pipe', encoding: 'utf-8' });
return { ...ctx, jobStatus: 'COMPLETED', solverLogs: output };
} catch (err: any) {
return { ...ctx, jobStatus: 'FAILED', validationErrors: [...ctx.validationErrors, 'Solver execution failed', err.message] };
}
}
validate(ctx: SimulationContext): boolean {
return ctx.jobStatus === 'COMPLETED';
}
}
// 5. Reviewer Agent: Validates results & convergence
class ResultAuditor implements SimulationAgent {
name = 'reviewer';
async execute(ctx: SimulationContext): Promise<SimulationContext> {
const checks = await this.runValidationChecks(ctx);
if (!checks.passed) {
return { ...ctx, jobStatus: 'FAILED', validationErrors: [...ctx.validationErrors, ...checks.errors] };
}
return ctx;
}
validate(ctx: SimulationContext): boolean {
return ctx.validationErrors.length === 0;
}
private async runValidationChecks(ctx: SimulationContext) {
const errors: string[] = [];
if (!ctx.solverLogs?.includes('THE ANALYSIS HAS COMPLETED SUCCESSFULLY')) {
errors.push('Solver did not report successful completion');
}
if (ctx.solverLogs?.includes('ZERO PIVOT') || ctx.solverLogs?.includes('NEGATIVE EIGENVALUE')) {
errors.push('Rigid body mode or instability detected');
}
return { passed: errors.length === 0, errors };
}
}
// 6. Visualizer Agent: Extracts & formats output
class OutputRenderer implements SimulationAgent {
name = 'visualizer';
async execute(ctx: SimulationContext): Promise<SimulationContext> {
const vizData = this.extractFieldOutputs(ctx);
return { ...ctx, visualizationData: vizData };
}
validate(ctx: SimulationContext): boolean {
return ctx.visualizationData !== undefined;
}
private extractFieldOutputs(ctx: SimulationContext): string {
return JSON.stringify({
odbStatus: 'extracted',
fields: ['S', 'U', 'PE'],
peakStress: 'reported',
maxDisplacement: 'reported'
});
}
}
// Orchestrator: DAG execution with retry logic
class SimulationOrchestrator {
private agents: SimulationAgent[];
private maxRetries = 2;
constructor() {
this.agents = [
new PromptInterpreter(),
new MeshArchitect(),
new ScriptGenerator(),
new SolverRunner(),
new ResultAuditor(),
new OutputRenderer()
];
}
async run(initialContext: SimulationContext): Promise<SimulationContext> {
let currentCtx = initialContext;
for (const agent of this.agents) {
let attempts = 0;
while (attempts <= this.maxRetries) {
currentCtx = await agent.execute(currentCtx);
if (agent.validate(currentCtx)) break;
attempts++;
if (attempts > this.maxRetries) {
throw new Error(Agent ${agent.name} failed after ${this.maxRetries} retries. Errors: ${currentCtx.validationErrors.join('; ')});
}
}
}
return currentCtx;
}
}
### Why This Architecture Works
The separation between the `ScriptGenerator` and `ResultAuditor` is critical. LLMs excel at syntax generation but struggle with numerical validation. By isolating the reviewer, the system can parse Abaqus `.dat` and `.sta` logs for convergence warnings, element distortion errors, or contact instability before committing to long-running jobs. The orchestrator’s retry loop ensures that transient syntax errors trigger regeneration rather than immediate failure, mirroring how senior engineers debug solver inputs. Containerizing the execution environment guarantees that solver behavior remains consistent across development workstations and HPC clusters.
## Pitfall Guide
Deploying AI-driven simulation pipelines introduces failure modes that do not exist in manual workflows. The following pitfalls are derived from production deployments of multi-agent FEA systems.
1. **Physics Hallucination in Boundary Conditions**
*Explanation*: LLMs may generate mathematically consistent but physically unstable constraints (e.g., over-constraining a rigid body or applying pressure to a non-existent surface).
*Fix*: Implement a geometric validation layer that cross-references generated BCs against the CAD topology before script generation. Use constraint counting algorithms to detect rigid body modes and reject setups with insufficient kinematic restraint.
2. **Ignoring Mesh Convergence Criteria**
*Explanation*: Automated mesh generation often defaults to uniform element sizing, missing stress concentrations that require local refinement.
*Fix*: Integrate a curvature-based seeding strategy. The architect agent should request adaptive refinement zones near load application points or geometric discontinuities. Enforce a minimum element count rule based on feature size.
3. **Silent Solver Failures**
*Explanation*: Abaqus may terminate with a non-zero exit code but leave partial output files, causing downstream agents to assume success.
*Fix*: Parse the `.sta` file for the `THE ANALYSIS HAS COMPLETED SUCCESSFULLY` marker. Never rely solely on process exit codes. Implement timeout guards for jobs exceeding expected wall-clock limits and trigger automatic cleanup of orphaned scratch directories.
4. **Material Model Mismatch**
*Explanation*: The interpreter may map "steel" to linear elastic properties while the load case implies plastic deformation, causing unrealistic results.
*Fix*: Enforce a material capability matrix. If applied stresses exceed yield thresholds in the prompt, the architect agent must automatically switch to elastoplastic definitions and request hardening parameters. Maintain a lookup table mapping common material names to validated Abaqus property sets.
5. **Over-Parallelization of Solver Jobs**
*Explanation*: Submitting multiple agent-generated jobs simultaneously can exhaust license tokens or cluster queue limits, causing starvation.
*Fix*: Implement a job scheduler with token-aware throttling. Queue management should prioritize validation jobs over production runs during the tuning phase. Use Abaqus's `mp_mode=THREADS` vs `mp_mode=MPI` intelligently based on available cores and license constraints.
6. **Visualization as an Afterthought**
*Explanation*: Treating post-processing as a final step delays error detection. Stress singularities or contact penetration are often visible only in rendered field outputs.
*Fix*: Run lightweight visualization checks immediately after solver completion. Extract peak stress locations and displacement magnitudes to verify they align with the original natural-language intent. Fail the pipeline if outputs violate basic equilibrium checks.
7. **Hardcoded Environment Paths**
*Explanation*: Abaqus installations vary across workstations and HPC clusters. Hardcoded paths break agent portability.
*Fix*: Use environment variable resolution (`ABAQUS_CMD`, `LICENSE_SERVER`) and dynamic path discovery. Containerize the execution environment to guarantee solver consistency. Validate license availability at pipeline initialization rather than at job submission.
## Production Bundle
### Action Checklist
- [ ] Define a strict schema for natural-language-to-physics extraction to prevent ambiguous boundary condition mapping
- [ ] Implement a dry-run validation step that checks generated Abaqus scripts for syntax errors before solver submission
- [ ] Configure a dedicated reviewer agent that parses `.dat` and `.sta` logs for convergence warnings and element distortion
- [ ] Establish a material capability matrix to automatically escalate linear elastic models to nonlinear when stress thresholds are exceeded
- [ ] Deploy a job queue manager with license token tracking to prevent solver starvation during batch processing
- [ ] Integrate automated field output extraction (S, U, PE) to verify physical plausibility before final delivery
- [ ] Containerize the Abaqus execution environment to guarantee consistent solver behavior across development and production
### Decision Matrix
Selecting the right automation strategy depends on problem complexity, team expertise, and infrastructure constraints.
| Scenario | Recommended Approach | Why | Cost Impact |
|----------|---------------------|-----|-------------|
| Routine linear static analysis with standard BCs | Single-LLM + Template Injection | Low complexity, predictable syntax, minimal validation overhead | Low (API costs only) |
| Multi-step nonlinear contact or dynamic analysis | Multi-Agent Orchestration | Requires iterative refinement, convergence monitoring, and specialized reasoning per phase | Medium (Compute + API + Orchestrator overhead) |
| High-fidelity validation for safety-critical components | Traditional Manual FEA + AI-Assisted Review | Regulatory compliance demands traceable human sign-off; AI used only for syntax checking | High (Engineering hours) |
| Rapid design-space exploration / topology optimization | Multi-Agent + Parameterized Scripting | Enables automated variation of loads/materials with consistent solver configuration | Medium-High (Cluster compute) |
### Configuration Template
The following YAML configuration defines the agent pipeline, solver environment, and validation thresholds. Deploy this alongside the orchestrator to standardize execution across teams.
```yaml
simulation_pipeline:
version: "2.1"
agents:
interpreter:
model: "gpt-4o"
temperature: 0.2
max_tokens: 1024
extraction_schema: "physics_intent_v1"
architect:
model: "gpt-4o"
temperature: 0.1
mesh_strategy: "curvature_adaptive"
min_elements_per_feature: 3
input_writer:
syntax_check: true
dry_run: true
abaqus_version: "2024"
runner:
solver: "abaqus"
parallel_cores: 8
timeout_minutes: 120
scratch_cleanup: true
reviewer:
log_parser: true
convergence_threshold: 1e-4
element_distortion_limit: 0.8
fail_on_rigid_body_mode: true
visualizer:
export_format: "json"
field_outputs: ["S", "U", "PE"]
equilibrium_check: true
environment:
abaqus_license: "network"
license_server: "${ABAQUS_LICENSE_SERVER}"
scratch_dir: "/tmp/abaqus_jobs"
container_image: "simtech/abaqus-runner:2024.1"
queue_manager: "slurm"
Quick Start Guide
- Initialize the Environment: Pull the container image and set
ABAQUS_LICENSE_SERVER and ABAQUS_CMD environment variables. Verify solver accessibility via abaqus information=version and confirm license availability.
- Deploy the Orchestrator: Install the TypeScript runtime, load the configuration template, and start the agent pipeline. Run a dry-validation pass against a sample CAD file to confirm topology parsing and script generation.
- Submit a Natural-Language Job: Provide a structured prompt containing geometry reference, material specification, boundary conditions, and load magnitude. The interpreter will extract parameters and route them through the DAG.
- Monitor Execution: Watch the reviewer agent logs for convergence markers. If validation fails, the orchestrator automatically triggers regeneration up to the configured retry limit. Inspect
.sta logs manually if retries are exhausted.
- Extract Results: Upon successful completion, the visualizer agent exports field outputs to JSON. Load the data into your preferred plotting library or integrate directly into optimization loops. Archive execution logs for audit trails.
This architecture transforms FEA from a syntax-heavy bottleneck into a deterministic, AI-augmented workflow. By isolating reasoning, validation, and execution into specialized agents, engineering teams can scale simulation throughput without compromising physical accuracy. The remaining challenge is not solver capability, but disciplined pipeline governance. Implement strict validation gates, maintain traceable execution logs, and treat AI-generated scripts as draft inputs requiring automated verification. When deployed with these safeguards, multi-agent orchestration becomes a force multiplier for computational mechanics.
