A runtime thatlives on thefactory floor.

Duromex is not a SaaS dashboard with an API bolted on. The primary artefact is an edge runtime that runs beside your PLCs, speaks OPC UA and MQTT, and is operated like infrastructure — versioned, canaried and rolled back.

Read the docs Request access

connector families

transport protocols

<100 ms

target station decision latency

CLI to deploy a plant

Bring a line online

The CLI provisions the edge runtime, registers connectors, sets the autonomy level and captures a baseline before anything is written.

What the CLI does

Provisions the K3s-based edge runtime on site
Registers connectors over OPC UA, MQTT, REST and PLC tags
Sets autonomy per line — shadow, advisory or control
Captures a measured baseline before any write is enabled
Runs twin validation as a release gate

duromex-cli — plant-ankara-2

# Deploy the edge runtime to a plant
$ duromex edge init --site plant-ankara-2 --gpu jetson-orin
$ duromex connector add press --protocol opcua --endpoint opc.tcp://press-04:4840
$ duromex connector add tester --protocol mqtt --topic plant/tester-11/#
$ duromex connector add mes --protocol rest --url https://mes.internal/api

$ duromex autonomy set --line refrigeration-cabinet-01 --level shadow
  autonomy: shadow   writes: disabled   audit: enabled

$ duromex baseline measure --metric first_pass_yield --window 14d
  baseline captured. 14d first-pass yield: 91.4%

$ duromex twin validate --change recipe/foam-v13
  predicted FPY 93.8% (+2.4) · takt held · gate: PASS

Stream a unit through the loop

The Python SDK models the factory the way the plant does: sites, lines, stages and serialised units — not generic events.

Design principles

The unit is the primary object, from blank to pallet
Every verdict carries its citations
Autonomy level is explicit, never implicit
Calls are idempotent and safe to retry
Nothing writes to equipment without granted authority

python · duromex-sdk

# Register a line and stream a unit through the loop
from duromex import Factory

factory = Factory(site="plant-ankara-2", edge="local")

line = factory.line(
    id="refrigeration-cabinet-01",
    stages=["form", "weld", "enamel", "foam",
            "assemble", "test", "pack"],
    autonomy="shadow",   # shadow | advisory | control
)

unit = line.unit(serial="RF-2026-0004417")
unit.attach("vision", stream="opcua://press-04/cam")
unit.attach("pressure_decay", stream="mqtt://tester-11/decay")

verdict = unit.evaluate()
print(verdict.first_pass, verdict.risk, verdict.citations)
# True  0.03  ["recipe:foam-v12", "spec:IEC-60335-2-24"]

How you integrate

Four surfaces, chosen so an OT engineer and a platform engineer can both work without fighting each other.

Connectors

OPC UA, MQTT, REST, PLC tags and file drops for presses, enamel lines, foamers, stations, testers and MES.

Agent API

Webhooks

Exception escalation, autonomy changes, drift alerts and audit events pushed to your ticketing and notification surfaces.

Edge CLI

Provision, configure, canary, roll back and inspect the runtime on site, including when the WAN link is down.

Exceptions come to you

When an agent is below its confidence threshold, the unit is held and the exception is escalated with its probable cause and evidence already attached.

Event types

agent.exception — held for human review
agent.action — a write was performed
autonomy.changed — authority granted or revoked
model.drift — drift detected against golden data
twin.gate — a change passed or failed validation

POST /your-endpoint · application/json

// Exception escalation webhook payload
{
  "event": "agent.exception",
  "agent": "leak-and-test",
  "line": "refrigeration-cabinet-01",
  "serial": "RF-2026-0004417",
  "confidence": 0.61,
  "probable_cause": {
    "stage": "foam",
    "signal": "density_gradient_low_rear",
    "evidence": ["frame:8821", "shot:4471"]
  },
  "action": "held_for_human",
  "audit_id": "aud_01JQ8Z...c4"
}

What Duromex is built on

Go and Python FastAPI services behind a NestJS control plane, with a factory edge runtime in Rust and C++. PostgreSQL with pgvector, TimescaleDB for process and test telemetry, and Redis.

Infrastructure is AWS plus factory edge — K3s on site with IGX class hardware — delivered through GitHub Actions, Terraform, ArgoCD and signed edge OTA updates.

Observability and AI

Datadog, Grafana and OpenTelemetry across edge and cloud
Langfuse for agent and model tracing
PyTorch with NVIDIA Isaac, Metropolis, Holoscan, Cosmos, cuOpt and Omniverse
LangGraph orchestration with Anthropic and Gemini reasoning
Triton and NIM for GPU serving at the edge

The release path for a model or recipe change

Same path every time, whether the change came from us or from your engineer's correction.

Evaluate in CI

Golden datasets and judge models run against the change. A regression on any gated metric blocks the release.

Validate in the twin

The change is simulated against line and product behaviour, producing predicted quality, yield and takt.

Canary on one line

Signed OTA update to a canary line with automatic rollback on regression.

Roll forward

Fleet-wide rollout per site, with per-site autonomy authority respected throughout.

Observe

Drift monitoring against golden data, with alerts routed to your on-call surface.

Running Duromex like infrastructure

Because that is what it is once it can write to a press.

Offline-first

Inference, control and the audit log are local. WAN loss degrades learning, not production.

Least privilege

Write authority is scoped per line and per workflow, granted explicitly and revocable instantly.

Versioned everything

Models, recipes, connectors and runtime versions are tracked together, so a rollback is one coherent action.

Isolated tenancy

Per-tenant data, model and vector-store scoping enforced by the platform rather than by convention.

Audit as an API

The assurance log is queryable and exportable, so quality can build their own evidence workflows.

Simulation on tap

The twin is available to developers, not just to the change process — test against a simulated line before you touch a real one.

Your code will run next to a stamping press

Every design decision — offline-first, idempotent, fail-safe, signed, reversible — exists because the consequence of a bad deploy here is not a 500 error. It is a damaged cabinet, or worse.

Form & stampWeld & seamEnamel & paintFoam & insulateWire & assembleLeak & function testRate & pack

Engineering budgets

What the runtime is designed against.

<100 ms

station decision where takt demands it

sensor streams per line Aspirational

99.9%

uptime target

cloud dependencies on the control path

Where to go from here

Docs

Documentation

Connectors, agent APIs, the edge runtime, autonomy levels and the deployment workflow.

Reference

Security

Security model

Isolation, audit logging, IP protection, safety design and the compliance posture.

Assurance

Access

Request access

The SDK and edge runtime are available to design partners and pilots during pre-launch.

Contact

Practical questions

Is there a public sandbox?

Not yet. During pre-launch, SDK and runtime access is granted to design partners and pilot customers, because a sandbox without a real line teaches the wrong things.

What language are the connectors written in?

The edge runtime is Rust and C++; connector configuration is declarative. You do not write connector code for the supported families.

Can we extend the agents with our own models?

In enterprise agreements, yes — custom product, line and quality models are part of the offering, served through the same Triton/NIM layer with the same evaluation gating.

How do you version the audit log schema?

Additively. Audit records are append-only and schema changes are backward compatible, because retroactive reinterpretation of an assurance log would defeat its purpose.

Build on a runtime that respects takt time.

Request SDK and edge runtime access as part of a design-partner engagement.

Request access Read the docs

Duromex is pre-launch. Figures shown are design-partner targets and modelled economics, not audited results. Ask us for the methodology.