Determinism instead of a black box.
The AI agent does not compute results itself, it generates an input script for the solver. Every run is deterministic, reproducible, and downloadable as a workspace, even years later.
Four steps, one traceable path.
Between the question “Will it hold?” and the report sit four clearly separated steps. Each has exactly one job, and each leaves a trace that can be checked.
AI agent
Translates part, material, supports, and loads from plain language into a complete setup. Asks where information is missing and highlights the affected faces on the model.
ExampleSetup“Fixed at the flange, 2 kN on the end face” becomes boundary conditions on specific faces.
Input script
A simulation is described by a Python script that drives the solver. The agent does not compute, it writes. The script is the complete, reproducible description of what gets computed.
ExampleScriptMaterial, mesh targets, load cases, and target accuracy are plain text, not rows in a database.
Solver
The in-house FEM solver computes and refines server-side in a container; the mesh comes from the market-proven Simmetrix mesher, firmly integrated into the computation path. Same input, same result, on any machine.
ExampleSolver runA convergence study runs unattended until the specified target accuracy is reached.
Report
Assumptions, mesh statistics, solver settings, and results land in a report built for review and sign-off in the team. The complete workspace stays downloadable.
ExampleReportA simulation expert sees at a glance which supports were assumed.
Three design decisions.
Agent-native from the ground up.
Others bolt assistants onto grown interfaces. At Dr.Q the solver was built for agent control from day one; the AI agent knows every function.
Guardrails built in.
The solver detects typical user errors, checks plausibility, and runs automatic convergence studies. Assumptions, mesh, and settings are in the report.
What the solver understands.
Today's scope, in concrete terms. The first six rows are available in the product; the seventh shows what is in progress.
Geometry and mesh
Parts arrive in the browser as STEP files. Automated meshing produces volume meshes of tetrahedra, linear or quadratic. Mesh density has three modes: physics-adaptive via the convergence study, geometry-driven from CAD features, or a custom size map. Mesh quality is checked per element and optimized automatically.
- Import: STEP
- Elements: tetrahedra, linear and quadratic
- Mesh density: physics-adaptive (convergence study), geometry-driven (CAD features), or a manual size map
- Mesh quality: checked per element and optimized automatically
Material
Linear elastic, isotropic material behavior, plus plasticity with isotropic hardening and viscoelastic behavior. Properties are Young's modulus, Poisson's ratio, density, and model-specific parameters, plus the coefficient of thermal expansion. The integrated unit system converts inputs internally, so that N and kN, or mm and m, do not get mixed up.
- Models: linear elastic, plastic (isotropic hardening), viscoelastic
- Properties: Young's modulus, Poisson's ratio, density, model-specific parameters
- Coefficient of thermal expansion for temperature loads (conversion happens internally)
- Units: checked and converted, never assumed
Supports and contact
Fixed supports and prescribed displacements per direction, normal supports for symmetry and sliding surfaces, stabilization springs for weakly supported parts, each applied to faces of the CAD model. Assemblies compute with contact between parts: bonded, frictionless, or frictional.
- Fixed support and prescribed displacement per axis
- Normal support (symmetry, sliding surfaces)
- Stabilization springs
- Contact: bonded, frictionless, rough, frictional
Loads and load cases
Forces, pressures including internal pressure, moments, remote forces, inertial loads (gravity, acceleration, centrifugal), temperature loads, plus bolt pretension and rivets. Several load cases compute on the same mesh.
- Force, surface load, moment, remote force
- Pressure and internal pressure
- Inertial loads: gravity, acceleration, centrifugal
- Temperature load, bolt pretension, rivets
- Several load cases on one mesh
Solution modes
Beyond static structural analysis, the solver runs three further solution modes and couples them where it makes engineering sense.
- Static structural analysis: linear static, plastic, contact
- Geometric nonlinearity is detected and accounted for automatically
- Thermal: heat conduction
- Modal analysis: natural frequencies and resonance
- Buckling: geometric eigenvalue analysis
- Couplings: heat conduction → structural, structural → modal / buckling
Results
Displacements as components and magnitude, equivalent stresses and strains after von Mises, Tresca, and Rankine, plastic strain, reaction forces, the safety factor against yield, and safety against buckling. Plus two quantities rarely shown elsewhere: element quality and the estimated discretization error of the mesh.
- Displacement: x, y, z, and magnitude
- Stress and strain: von Mises, Tresca, Rankine; plastic strain
- Reaction forces per support
- Safety factor against yield
- Safety against buckling from a geometric eigenvalue analysis
- Slip safety
- Element quality and estimated mesh error
What comes next
A capability is described here only once it is in production and technically signed off. In progress or in sign-off:
In progress
- Beam and shell elements from CAD meshing
- Dynamic strength assessment
- Nonlinear boundary conditions
The computation path in detail.
Six mechanisms that run in the background. None of them is magic, each of them is documented.
- Automated meshing
- A volume mesh emerges from the CAD geometry without manual work. Meshing runs on the market-proven Simmetrix mesher, firmly integrated into the computation path; element quality and geometric fidelity are checked per element and optimized automatically before computing. Mesh density is not a gut feeling, it is a directive from the convergence study. When an element still cannot be meshed, Dr.Q surfaces the offending location instead of aborting the run without explanation.
- Mesh, refined toward the bore
- Adaptive convergence study
- A single mesh proves nothing. The solver computes a sequence of progressively finer meshes, compares the target quantities, and estimates the remaining discretization error: from the mesh residuals for stresses, from the refinement sequence for deflections. Refinement happens where the error sits. The study ends when the specified target accuracy is reached, and the report shows the history.
- Error estimate per mesh stage
- Target accuracy as an input
- Instead of prescribing element sizes, a target accuracy is set for the relevant result quantities, for example the equivalent stress. This is an instruction to the solver on how accurately to compute, not a promise about the part. Judging the result stays with the engineer.
- One input, the mesh follows
- A script, not a click path
- A simulation is described by a Python script that drives the solver. No state hides in a user interface; the script contains everything the solver needs to know. Whoever reads it knows what was computed. Whoever runs it again gets the same reproducible result.
study = ConvergenceStudy( geometry_file_path, {0: steel})fixed_bc = DeflectionBc()force_bc = ForceBc()force_bc.force_vector = Vector3( Force.zero(), Force(2000.0, ForceUnit.N), Force.zero())study.boundary_conditions = [ fixed_bc, force_bc]study.questions = [Question( SolutionQuantity.VonMisesStress, Aggregation.Max, relative_error)]
Input script, example- Load cases on one mesh
- Several load cases compute on the same mesh. The LU factorization of the system matrix is reused; only the right-hand side changes. Each additional case costs roughly 2 % more compute; compared with a fresh run, that saves over 90 %. Every case stays comparable because they rest on identical discretization.
- Single cases, one mesh
- Reproducible, even years later
- Input script, mesh statistics, settings, and results belong together and stay together. The workspace is downloadable as a whole. A question during a warranty case or an audit then meets the complete computation path, not a folder of screenshots.
- Workspace archive, example
Computed in the cloud, not in the browser.
The browser shows the model, the conversation, and the result. Computation happens server-side: every run in a worker container with the compute the model needs. Hardware fits the simulation, not the other way around. No installation, no license server, no workstation running overnight.
- Browser: model, setup, and report, no installation
- Server-side worker containers: isolated, scalable, reproducible
- Private cloud on customer IT on request
How we build.
Four principles that decisions in the solver and the product are measured against.
Traceabilityover Speed
A fast result without a checkable path is not a result. Every run must be something a simulation expert can recompute.
Determinismover Magic
The AI writes the setup, the solver computes the physics. Same input, same result, without exception.
Complementover Replace
Dr.Q takes the routine off the simulation team, not the responsibility. Hard cases stay with the experts, sign-off stays with the engineer.
Proofover Claims
No result is declared correct. Assumptions, mesh, and convergence history are in the report so every number can be checked.
Built in, not bolted on.
Preprocessing
- STEP import in the browser
- Setup in plain language with the AI agent
- Face selection directly on the model
- Integrated unit system
- Plausibility check before the run
Solver
- Structural mechanics: linear static, plastic, contact, geometrically nonlinear
- Thermal, modal, and buckling as own solution modes
- Automated meshing, linear and quadratic
- Adaptive convergence study with error estimate
- Deterministic, server-side in a container
Postprocessing
- Stress and deformation plots in the browser
- Report with assumptions, mesh statistics, and settings
- Safety factor against yield
- Workspace downloadable as a whole
- Input script in plain text
Today: structural mechanics, from linear static to contact.
Dr.Q computes structural mechanics for typical mechanical engineering components: linear static, with plastic material, large deformations, and contact between parts, plus natural frequencies and linear buckling. Extensions such as thermal analysis and beam or shell meshes are on the roadmap and will only be described once they are in production and technically signed off.
More than 40 customer projects have been computed on the in-house solver core.