Abaqus Agent

Local Simulation QA & Regression Framework for Abaqus FEA.

Turn Abaqus runs into reproducible experiment capsules:

.inp / spec -> syntaxcheck -> solver -> ODB KPI -> physics contracts -> diff report

Abaqus Agent runs in your own Abaqus-licensed environment. The core is deterministic and auditable; LLMs, MCP clients, Codex, Claude Code, or the web UI are optional frontends.

Why This Exists

Most AI simulation demos focus on generating a model or script. Real Abaqus teams usually have a harder problem:

• Did this run use the right input deck, solver settings, Abaqus version, and environment?
• Are the ODB KPIs within expected physical bounds?
• What changed between this run and the previous baseline?
• Why did the solver fail?
• Can this result be turned into a repeatable report for a team or customer?

Abaqus Agent is moving toward the simulation equivalent of pytest / CI / diff / diagnostics for Abaqus workflows.

v0.2 Direction

The current codebase already has the original Abaqus automation pipeline. The v0.2 direction adds a Simulation DevOps kernel:

See docs/STRATEGY.md for the product strategy.

Installation

Install from source:

git clone https://github.com/Tomsabay/abaqus_agent.git
cd abaqus_agent
pip install -e ".[dev,mcp]"

Optional extras:

pip install -e ".[llm]"  # Anthropic / OpenAI planners
pip install -e ".[all]"  # dev + mcp + llm

Quick Start

Run tests that do not require Abaqus:

pytest tests/ -v

Validate public benchmark specs without Abaqus:

python run_benchmark.py --dry-run

Run one full Abaqus case on a machine with Abaqus installed:

python agent/orchestrator.py cases/cantilever/spec.yaml \
  cases/cantilever/expected.json \
  cases/cantilever/runner.json

Use an existing .inp as a first-class input:

meta:
  abaqus_release: "2024"
  model_name: "CustomerModel"
geometry:
  type: custom_inp
  inp_path: model.inp
material:
  name: Placeholder
  E: 210000
  nu: 0.3
analysis:
  solver: standard
  step_type: Static
bc_load: {}
outputs:
  kpis:
    - name: U_tip
      type: nodal_displacement

Create an experiment capsule from an .inp:

from capsule.store import init_from_inp

capsule = init_from_inp("model.inp", "runs/model_capsule")
print(capsule["run_id"])

Evaluate physics contracts:

from contracts import evaluate_contracts

result = evaluate_contracts(
    [
        {"name": "deflects_down", "type": "direction", "kpi": "U_tip", "direction": "negative"},
        {"name": "stress_margin", "type": "range", "kpi": "MISES_MAX", "max": 250.0},
    ],
    {"U_tip": -0.002, "MISES_MAX": 210.0},
)

Diagnose solver logs:

from doctor import diagnose_logs

diagnosis = diagnose_logs(paths=["Job-1.msg", "Job-1.sta"])

Compare KPI results:

from simdiff import diff_kpis

diff = diff_kpis({"U_tip": -0.002}, {"U_tip": -0.0021})

Architecture

Codex / Claude Code / ChatGPT / Web UI / CLI
        |
        v
Intent layer (optional LLM)
        |
        v
Simulation DevOps kernel
  - Experiment Capsule
  - Physics Contracts
  - ODB Lens
  - Solver Doctor
  - Simulation Diff
        |
        v
Abaqus adapter / local BYOL runner
  - noGUI
  - syntaxcheck
  - submit
  - monitor
  - ODB extraction
        |
        v
Artifacts: .inp, .cae, .odb, .sta, .msg, .log, reports

The older NL-to-spec planner remains available, but it is no longer the product center.

Project Structure

agent/              End-to-end orchestration and optional LLM planner
capsule/            Experiment capsule manifest, hashing, and store helpers
contracts/          Physics contract evaluation
doctor/             Solver log diagnostics and pattern library
simdiff/            KPI diff and Markdown rendering
runner/             Abaqus build, syntaxcheck, submit, monitor
post/               ODB KPI extraction
tools/              Errors, schema validation, static guard, Abaqus command resolver
mcp_server.py       MCP server for agent integration
mcp_bridge.py       HTTP/SSE bridge for browser clients
server.py           FastAPI server
cases/              Public benchmark specs
premium/            Open-core prototype modules from v0.1

Benchmark Status

Public specs currently cover:

Notes:

• python run_benchmark.py --dry-run validates specs without Abaqus.
• Full regression requires a local Abaqus installation and license.
• Historical local validation has been done on Abaqus 2024 / Windows.
• External contributor validation exists for Abaqus 2026 compatibility.

Safety And Deployment

All generated or processed workflows are intended to run locally in the user's own Abaqus-licensed environment.

The recommended commercial deployment model is BYOL:

• customer-local runner
• customer-owned Abaqus license
• local artifacts and ODBs
• optional consulting, report templates, private recipes, and team runner

Do not run third-party Abaqus workloads as a hosted SaaS without explicit legal review of the relevant Dassault Systemes license terms.

Roadmap

• 7-stage Abaqus pipeline: validate, build, syntaxcheck, submit, monitor, extract, compare
• Windows .bat command resolver for Abaqus subprocess calls
• MCP server and HTTP bridge
• FastAPI/SSE web API
• custom_inp no-CAE build path
• v0.2 capsule / contract / diff / doctor kernel skeleton
• ODB Lens YAML KPI DSL
• Capsule-backed run output from the orchestrator
• Physics contract checks in benchmark reports
• Markdown/PDF report templates
• Solver Doctor CLI
• Validation matrix for Abaqus versions and operating systems

Acknowledgments

• GLY2024 / Goulingyun — first external contributor. Verified Abaqus 2026 compatibility and contributed Windows command-path fixes. See docs/CASE_STUDY_GLY2024.md.

License

Apache 2.0. See LICENSE.