AI Interface

Talk to your physics model.

A conversational interface to your deployed Simthetic ROM. Run simulations, design controllers, query operating points, and explore the design space — in natural language, through Claude, ChatGPT, or any MCP-compatible LLM.

Try Live Demo Read the Technical Article

Capabilities

What You Can Ask

Every prompt below maps to a concrete tool call — the assistant runs the simulation, interprets the result, and reports back with units, plots, and design recommendations.

Sweep an input

“Vary V_in from 15 to 45 V and show V_out tracking.”

Ramp simulation, plot of V_out vs V_in, slope analysis.

Tune a controller

“Design a PI controller for V_out = 12 V, settling < 5 ms, ≤ 5 % overshoot.”

Returns Kp, Ki, closed-loop step response, overshoot metric.

Find an operating point

“Efficiency at V_in = 36 V, full load, duty 0.45?”

Steady-state V, I, P values plus computed η.

Stress the envelope

“Where does this ROM start losing accuracy?”

Boundary sweep with honest accuracy warnings near the operating-range edges.

Compare scenarios

“How does duty 0.4 vs 0.6 affect V_out ripple at R_load = 2 Ω?”

Side-by-side overlay plot plus delta metrics.

Generate a report

“Summarise this design's steady-state behaviour for engineering review.”

Markdown table plus plots, ready to paste into a doc.

The Protocol

Open. Standard. Yours.

Simthetic ROMs speak the Model Context Protocol — Anthropic's open standard for connecting LLMs to tools. The entire stack runs on your own machine: the LLM host, the MCP server, and the ROM container all sit behind your firewall, with no data ever leaving your network.

  • Runs fully on your machine

    LLM host, MCP server, and ROM container all execute locally. No telemetry, no Simthetic cloud round-trip, no proprietary data leaves your network.

  • Open standard

    Works with Claude Desktop, Cursor, Continue, and any MCP-compatible LLM client.

  • No vendor lock-in

    The ROM stays in your Docker container; the LLM stays in your account. Communication is stdio or HTTP between local processes — no cloud broker, no Simthetic intermediary.

  • Audit-friendly

    Every tool call is logged with inputs and outputs; deterministic ROM behaviour means results are reproducible for compliance reviews.

LLM Host Claude · Cursor MCP Server stdio · http ROM Container Docker · FMU Model Context Protocol JSON-RPC over stdio or HTTP Runs locally
.mcp.json 
{
  "mcpServers": {
    "simthetic-rom": {
      "command": "docker",
      "args": ["run", "-i", "simthetic/my-rom:v1"]
    }
  }
}

Sample Session

A real engineering session

Excerpts from a design review of a PMSM drive ROM with embedded thermal coupling — the kind of multi-physics model where conversational iteration replaces hours of scripting.

pmsm_review.session
What's the motor's torque ripple and stator copper loss at 4000 rpm, 80 Nm, with 25 °C ambient?
At that operating point: torque ripple 2.1 % peak-to-peak (THD 1.4 %), stator copper loss 312 W, junction temperature stabilises at 84 °C after ~6 s. Efficiency 94.2 %. Operating well within thermal envelope (Tj,max = 125 °C).
Design a field-oriented controller targeting 0.5 % torque ripple. Constraint: junction temperature must stay below 100 °C under repeated 50 → 100 Nm step loads.

First iteration: Kp_iq = 0.18, Ki_iq = 220. Torque ripple drops to 0.6 %, but Tj overshoots to 103 °C on the third consecutive load step.

Adding a thermal-aware torque limiter: when Tj > 95 °C, reduce torque setpoint by 15 % until cooled. Re-running…

Final result: torque ripple 0.42 %, Tj peak 97.4 °C across 30 successive transients. Step-response plot attached.

100°C
Where does the ROM's accuracy start degrading? I want to know before I trust it for safety-critical tuning.

Sweeping the operating envelope: ROM tracks Simscape within ±1.5 % on torque and ±2 % on Tj across the full motoring quadrant.

Accuracy degrades to ±4 % in deep flux weakening (above 7500 rpm at light load) and ±6 % during regenerative braking transients shorter than 5 ms.

Suggest treating those two regions as advisory only or commissioning a targeted ROM refit — datasheet excerpt attached.

Representative session shown for illustration.

Closed-Loop

The LLM writes the control law. The ROM runs it.

Beyond chat, the assistant can author small Python control hooks that the ROM evaluates at every simulation step. The LLM proposes a control law, the ROM executes it inside the physics, and the LLM iterates on the results — without leaving the conversation.

PI / PID
Auto-tuned in conversation, validated against the physics in seconds.
ML controllers
Drop a trained policy into the loop; the ROM tells you whether it's safe.
What-if
Custom Python logic for fault injection, sensor noise, or aging models.
Zero rebuild
Hook code travels in the request payload; no container rebuild between iterations.

Hook execution is sandboxed and deterministic — the LLM can iterate freely without affecting the ROM's compiled core.

controller_hook.py 
# PI controller for V_out = 12 V
def hook(step_idx, t_s, dt_s, last_outputs, inputs, state):
    if last_outputs is None:
        return inputs
    err = 12.0 - last_outputs['V_out']
    state['I'] = state.get('I', 0.0) + err * dt_s
    duty = 0.10 * err + 5.0 * state['I']
    inputs['DC_int'] = max(0.2, min(0.8, duty))
    return inputs
Sandboxed · NumPy only < 1 ms overhead per step

Stop scripting. Start asking.

Try the live Buck Converter ROM in your browser, or talk to us about wiring your own ROM into your LLM stack.

Try Live Demo Book a Pilot