Integrations, jobs, and agents

Integrations let the Istari Digital Platform interact with Digital Engineering (DE) tools (such as CAD, CFD, simulation, and requirements software) that run in your infrastructure. Through integrations, the platform can extract data from proprietary files, run simulations, perform compliance checks, or execute any function that a DE tool supports — all without moving your data outside your network.

Note: In this context a model is a file that the platform can process (e.g. a CAD assembly, a simulation input deck). An artifact is a file produced by running a function on a model. See Terminology for full definitions.

Why does it matter?

• Unlock data from proprietary formats: Many engineering files are locked into formats that require specific software and licences to open. Integrations let the platform reach into those files and produce open, shareable artifacts (images, tables, metadata) that anyone can view.
• Keep data and licences where they are: The Istari Digital Agent runs entirely in your infrastructure. You can install it on machines that already have the DE tools installed and licensed. Your files never leave your network; the platform orchestrates the work remotely.
• Automate repetitive work: Instead of manually opening a tool, manipulating models, exporting results, and uploading them, you submit a job from the Istari Digital UI or using our Python Client and the platform handles the rest — including artifact upload and status tracking.
• Traceability and auditability: Every execution is recorded as a job with a full lifecycle (Pending → Completed or Failed), linking inputs, outputs, and the agent that ran the work.

Key concepts

Integration

An integration is the platform's ability to work with a specific external tool or data source. Each integration is delivered by a module installed on an agent.

For example, the Dassault 3DExperience integration enables the platform to extract views, geometry, and parameters from CATIA assemblies. The MSC NASTRAN integration enables the platform to run finite-element simulations on .bdf input decks. The PTC Creo integration can extract model data, update parameters, or pull files directly from Windchill. The set of integrations available to you depends on which modules are installed on your agents.

See Supported Integrations for the full list of vendors, tools, and functions.

Module

A module is software installed on an agent that provides one or more functions for a specific DE tool. You can think of a module as the bridge between the Istari Digital Platform and the tool itself.

Modules and their functions are namespaced using a @scope:name key. Built-in modules use the @istari scope (e.g. @istari:ptc_creo_parametric, @istari:dassault_3dexperience). Custom modules use your organisation's scope. Function keys share the same scope as their parent module (e.g. @istari:extract belongs to @istari:ptc_creo_parametric).

Each module ships with a manifest (module_manifest.json) that declares the module's key, supported operating systems, compatible agent versions, and the functions it provides (with their input and output schemas). The manifest is the contract between the module and the platform — it tells the agent exactly how to invoke the module and what file types each function accepts.

For example, the @istari:ptc_creo_parametric module declares functions like @istari:extract and @istari:update_parameters, each with its own input requirements (e.g. .prt or .asm files) and output artifacts (PNG views, JSON parameters, BOM data).

Modules are versioned and managed independently, so new tool capabilities can be added without updating the agent itself. See the Module Manifest API Reference for the full specification.

Custom module

The integration catalogue is not limited to the modules that ship with the platform. Using the Integrations SDK, you can build a custom module for any tool — proprietary, open-source, or developed in-house.

A custom module is structurally identical to a built-in one: you write a executable that accepts an input JSON file and produces an output JSON file, then describe it in a module_manifest.json. The manifest declares which functions the module provides, what file types they accept, and what artifacts they produce. Once installed on an an Istari Digital agent, the platform treats your custom module exactly like any other — it appears in the function picker, jobs are matched and executed the same way, and outputs are registered automatically.

For example, you could wrap internal Python scripts, connect to older software without APIs, or chain multiple tools into a single function, all while keeping data and licenses securely within your infrastructure. Once built, your module works seamlessly alongside built-in integrations, accessible through the same UI and SDK.

Function

A function is a specific operation that a module can perform on one or more models. Functions are identified by a namespaced key (e.g. @istari:extract). Real-world examples include:

• Extraction — @istari:extract on a Creo .prt file produces orthographic views (PNG), parameters (JSON), mass properties (JSON), and a BOM (JSON). The @istari:extract_geometry function on a 3DExperience assembly exports STEP, IGES3D, or STL geometry.
• Simulation — @istari:run on an MSC NASTRAN .bdf deck runs the solver and produces simulation outputs.
• Parameter updates — @istari:update_parameters on a Creo or 3DExperience model pushes new parameter values into the file, enabling automated design-space exploration.

Functions accept inputs (models and parameters) and produce outputs (artifacts and metadata). The number and types of inputs and outputs are declared in the module manifest's function schema, so the platform knows which file types a function accepts (e.g. @extension:xlsx) and what artifacts it will produce.

Agent (Istari Digital Agent)

The agent is a worker process that runs on a host machine in your infrastructure — an engineer's workstation, a virtual machine, an HPC node, or a Kubernetes pod. It:

1. Polls the platform's Job Service for pending work.
2. Claims a job it can fulfil (based on its installed modules).
3. Downloads the required model file(s).
4. Delegates execution to the matching module.
5. Adds the resulting artifacts back to the platform.
6. Reports the job outcome to the platform.

How agents match jobs

Not every agent is capable of executing every job. The matching process is determined by the module manifest, which defines the functions declared by the agent’s installed modules. Additionally, a job can specify requirements such as the tool version and operating system needed for execution.

An agent will only claim a job if it can fulfill all the specified requirements. If a job is assigned to a specific agent, only that agent will see and process it. Otherwise, any compatible agent in the system can claim and execute the job.

For example, if a user runs @istari:extract on a .prt file, only agents with the ptc_creo_parametric module (which declares that function) installed will pick up the job. An agent that only has the dassault_3dexperience module will skip it.

Since the agent runs in your environment, the DE tool's licence is consumed locally. The module acts as the interface, but the underlying tool performs the actual work.

Your organisation may run any number of agents, each configured with a different set of modules to support different tools or operating systems.

Job

A job is a single execution of a function on one or more models. When you click "Execute" in the UI or call the SDK, the platform creates a job and queues it.

Each job progresses through a lifecycle of statuses:

Status	Meaning
Pending	Created, waiting for an agent to pick it up.
Claimed	An agent has reserved the job.
Validating	The agent is downloading and verifying inputs.
Running	The module is executing the function.
Uploading	The agent is uploading output artifacts.
Completed	The job finished successfully.
Failed	An error occurred during execution.
Canceled	A user canceled the job before it was claimed.

You can optionally assign a job to a specific agent. If you choose Select Agent for Me, the platform assigns the job to the next available agent that can run the requested function.

How it all fits together

Key details

• Tool Licencing: The DE tool licence is consumed on the agent's host machine, just as it would be if an engineer ran the tool manually.
• Agent assignment: You can let the platform auto-assign jobs or target a specific agent. Auto-assignment picks the next available agent whose modules match the requested function.
• Permissions: Only users with Editor or Administrator access to a file can execute functions on it.
• Supported platforms: Agents run on multiple versions of Ubuntu, RHEL, Windows, and macOS.
• Extensible: Beyond the built-in integrations, you can create custom modules for any tool using the Integrations SDK.

Related terms

Agent, Agent Token, Artifact, DE Tool, Extraction, Function, Integration, Job, Model, Module