Platform · Architecture

How TRAIN is built, and how it runs in your environment.

TRAIN is a modular causal-intelligence layer, not a monolithic stack. Four architecture blocks (the Platform foundation, the Core Services causal engine, the Language Service and the Optimization Service) assemble into one governed Combined Causal Model, running inside your perimeter alongside the systems you already operate. Open the diagram below to drill into each block's services and capabilities. This is the architecture behind the platform capabilities.

Scroll down · the four blocks, the model, and how it deploys
Building block by block

Four blocks, one governed model. Open it up.

TRAIN is organized as four architecture blocks: the Platform foundation, the Core Services causal-inference engine, the Language Service, and the Optimization Service. Click a block to understand what each capability does and the features behind it.

The Combined Causal Model

The model is an assembled, governed artifact.

The Combined Causal Model is not learned in one pass. It is composed from three layers, reconciled where they disagree, versioned, and continuously re-estimated as the operation moves.

Compose

Three layers merge

Principle (physics and engineering relationships), Rationale (your engineers’ reasoning and practice) and Structural (learned from temporal process data) are combined into one directed causal graph.

Reconcile

Conflicts are surfaced

Where the layers disagree on a relationship’s presence, direction or strength, the conflict is flagged for expert resolution rather than silently averaged away.

Version

Every state is retained

Model versions, assumptions and evidence links are stored. The current model can be compared against any historical baseline to expose structural, directional and magnitude drift.

Three stacked model layers (Principle, Rationale and Structural causal models) merge into one Combined Causal Model shown as a governed directed graph, held together, governed, and traceable to source.
TRAIN screen: a causal graph comparison view contrasting the current combined causal model against a historical baseline to expose structural and strength drift.
The current combined causal model compared against a historical baseline: the versioned artifact made inspectable.Model comparison on temporal scale
Open at every boundary

A causal layer above your data foundation, not a replacement for it.

TRAIN strengthens the historians, platforms, models and solvers you already run. Designed for interoperability through documented interfaces, with supported data and result portability.

Ingests from

Historians, data lakes, lab / MES / CMMS systems, engineering documents and P&IDs, ontologies and knowledge graphs, and the outputs of your analytical models.

Publishes to

APIs, Jupyter, dashboards, simulators and physics models, ML models, MILP solvers, APC / MPC stacks, and agentic workflows.

Method interoperability

Identification and estimation interoperate with DoWhy, PyWhy and EconML; results are cross-checked against those frameworks and reconciled with simulation or first-principles baselines.

Programmatic access

A runtime REST API and JupyterHub expose supported capabilities to Python and R workflows, against the same governed model the visual tools use.

TRAIN screen: the runtime API documentation, an OpenAPI reference covering customer, project, process, hypothesis, model and analysis endpoints.
The TRAIN runtime API surface: core runtime capabilities are available through documented APIs for customer workflows.API documentation
Reference deployment

The reference deployment is yours.

TRAIN can be deployed without sending customer data to an external LLM API. Language-model architecture is agreed during an architecture and cybersecurity review, and TRAIN is installed into infrastructure you control before anything is provisioned.

Where it runs

Your cloud tenant, your private cloud, or on premises, including restricted and low-egress or air-gapped environments. You own the environment and the upgrade path.

Language models stay local

Where a language model is used, it can run as a local model inside your perimeter, sent only decision-relevant evidence rather than raw data. Token-reduction results are reported only alongside the test configuration and evaluation basis they were measured under.

Modular install

Deploy the full lifecycle or a single layer. Components scale independently, and new capabilities are added without re-platforming.

Certification through your process

Control evidence and certification are provided for your architecture and security review, not asserted by a third-party trust page.

Governance and security

Governed, isolated, auditable.

The architecture is built so that data stays where it belongs, access follows the permissions you already maintain, and every claim can be reconstructed after the fact.

Data residency

In approved customer-controlled configurations, operational data and models remain within the agreed perimeter; telemetry, support access, and training use are governed by contract and architecture review.

Identity and access

Single sign-on with your identity provider, and role-based permissions aligned to the no-code, low-code and high-code personas and to site, unit and function boundaries.

Lineage and audit

Supported model, evidence, recommendation, and user events are logged with attribution and retained according to configured policy: the basis for both engineering trust and regulatory review.

IP ownership

Customer data and customer-specific operational knowledge remain governed by the customer. Ownership and license rights for models are defined in the applicable agreement.

Get started

Walk the architecture with your team.

Bring your platform architects and security reviewers. We will map TRAIN onto your environment and scope a bounded deployment.

Request a demo