MANUFACTURING - FULL
Full Track: Author Your Production Intelligence
You chose complete control. Build your production system from first principles.
This track assumes nothing. You design the data architecture, create the surface hierarchy, and author every query.
What you will build
| Component | Scope |
|---|---|
| Connections | Every production data source |
| Surfaces | A plant, line, cell and station hierarchy |
| Warm queries | An OEE, quality and downtime library |
| Team | Access for operations, quality and maintenance |
| MCP | Any AI client reading the library |
Phase 1: Design the production architecture
Step 1.1: Map your hierarchy
Plant
├── Line 1
│ ├── Cell A (Machining)
│ │ ├── Station 1
│ │ └── Station 2
│ └── Cell B (Assembly)
│ ├── Station 1
│ └── Station 2
├── Line 2
│ └── Same structure
└── Support
├── Quality Lab
└── Maintenance
Step 1.2: Identify data sources
| Level | Data source | Metrics | How it reaches OpenX |
|---|---|---|---|
| Station | PLC or sensor | Cycle time, state, counts | A connection, through an edge gateway |
| Cell | Cell controller | Throughput, work in progress | A connection |
| Line | MES | Yield, batch tracking | An API Source polling the MES |
| Plant | The queries above | Total output, efficiency | Warm queries over the rest |
Step 1.3: Create connections
Ask Azi in the main panel:
"Create connections for the Line 1 PLC data and the cell controllers, and an API source for the MES."
She proposes them. Accept each one, then Deploy: connections and API sources are built only when someone deploys. Each connection's Connection Info tab then shows the credentials your gateway sends with.
TIP
Hardware not ready? Add a Simulator node shaped like your station data. Deploy starts it, and the surfaces and queries work the same way.
Phase 2: Create the surface hierarchy
Step 2.1: Plant surface
"Create a plant-level surface fed by every line's connections."
Azi proposes a Plant-Production surface wired to those connections. Accept it; it is live at once.
Step 2.2: Line surfaces
| Surface | Fed by | Purpose |
|---|---|---|
Line-1 | Cell A and Cell B connections | Line 1 detail |
Line-2 | Line 2 connections | Line 2 detail |
Step 2.3: Cell and station surfaces
| Surface | Fed by | Purpose |
|---|---|---|
Line-1-Cell-A | Station 1 and 2 data | Machining detail |
Line-1-Cell-B | Station 1 and 2 data | Assembly detail |
Your surface hierarchy decides how finely your queries can break production down.
Phase 3: Build the query library
Where your data is
Device data lands in one table, Data (Devices in workspaces whose IoT fabric was set up earlier), with each
payload as JSON in RawData. The queries unpack it with todynamic(RawData). The field names (line,
station, status, duration, units, quality, cycleTime, lotNumber) are examples; use your systems'
own. Ask Azi to sample with Data | take 5 first. The queries below are examples to adapt, not tested against your data.
| Query | Purpose | Level |
|---|---|---|
plant-oee | OEE for the plant, by line | Plant |
station-cycle | Station cycle analysis | Station |
downtime-pareto | Top downtime causes | Plant / line |
quality-fpy | First-pass yield | Line |
lot-trace | Every step for one lot | Line |
Step 3.1: Plant OEE by line
"Create a query for OEE across the plant over the last day, broken down by line."
Data
| where EnqueuedTime > ago(1d)
| extend Payload = todynamic(RawData)
| summarize AvailableSeconds = sumif(todouble(Payload.duration), tostring(Payload.status) != "Planned Downtime"),
RunSeconds = sumif(todouble(Payload.duration), tostring(Payload.status) == "Running"),
Units = sum(toint(Payload.units)),
GoodUnits = sumif(toint(Payload.units), tostring(Payload.quality) == "Pass")
by Line = tostring(Payload.line)
| extend IdealCycleSeconds = 30.0 // adjust per line
| extend Availability = RunSeconds / AvailableSeconds,
Performance = (Units * IdealCycleSeconds) / RunSeconds,
Quality = todouble(GoodUnits) / Units
| extend OEE = Availability * Performance * Quality * 100
| project Line,
Availability = round(Availability * 100, 1),
Performance = round(Performance * 100, 1),
Quality = round(Quality * 100, 1),
OEE = round(OEE, 1)
Step 3.2: Bottleneck stations
"Build a query that finds bottleneck stations by cycle-time variation."
Data
| where EnqueuedTime > ago(8h)
| extend Payload = todynamic(RawData)
| where isnotempty(Payload.cycleTime)
| summarize AvgCycle = avg(todouble(Payload.cycleTime)),
StdDev = stdev(todouble(Payload.cycleTime)),
Cycles = count()
by Station = tostring(Payload.station)
| extend Variation = StdDev / AvgCycle
| order by Variation desc
Step 3.3: Trace one lot
"Create a query that lists every recorded step for a given lot number."
Data
| extend Payload = todynamic(RawData)
| where tostring(Payload.lotNumber) == "LOT-4582"
| project EnqueuedTime, DeviceID, Step = tostring(Payload.step), Station = tostring(Payload.station),
Measurement = todouble(Payload.measurement), Status = tostring(Payload.status)
| order by EnqueuedTime asc
A warm query can declare parameters, so the lot number can be passed on each call instead of written in.
AZI
Every production metric now has one saved definition. When someone asks "What's our yield?", there is one answer, with the query there to read.
Phase 4: Give your team access
The owner adds teammates in Workspace -> Team Members: enter their email and click Invite. They are members at once. No AI can invite members, and the role picker in that window is not saved - what a member can change is set by access rights.
| Team | What they need |
|---|---|
| Engineering | Workspace.Deploy to build connections; Workspace.Access.Manage to manage access |
| Operations, Quality | Membership: any member can save and accept queries; some changes need a management right (see Permissions) |
| Maintenance | Membership, to read the downtime surfaces and queries |
| Management dashboards | An API key from APIs -> API Keys, carrying only the rights the dashboard needs |
Access rights apply to the whole workspace; there is no per-surface permission. See Permissions.
Phase 5: Connect any AI over MCP
The OpenX MCP Server is at https://openx.fathym.com/ox-api/mcp. Sign in through the browser: in Claude.ai or
ChatGPT, add a custom connector and paste the URL; for coding agents, run
fai mcp install https://openx.fathym.com/ox-api/mcp --name openx and sign in when the browser opens. Setup for
each client is in Bring Any AI.
Then ask:
"Why did Line 1 miss its production target yesterday? Show me the contributing factors."
The AI reads your saved queries with call_api. If it wants to build something new, it proposes it with
manage_proposals, and a person accepts.
What you built
| Component | Count |
|---|---|
| Connections | 3 or more |
| Surfaces | 5 or more, plant to cell |
| Warm queries | 5 |
| Team access | Set |
| MCP clients | 1 or more |
Before and after
| Before | After |
|---|---|
| A different OEE in every system | One definition, one number |
| Tribal knowledge about metrics | Saved queries anyone can read |
| Manual root-cause analysis | Queries that trace a lot step by step |
Next steps
| If you want to... | Go to... |
|---|---|
| Try the hybrid track | Hybrid track |
| See query patterns | Query Patterns |
| Connect more AI clients | Bring Any AI |
| Explore pharma | Pharma Factory |
On this page
- Full Track: Author Your Production Intelligence