Your AI should know
what's actually happening.
Connect any operational data source — devices, APIs, databases — build governed queries with Azi, and give any MCP-native AI live access to your operational data. In one session.
The problem
Your AI is powerful.
And flying blind.
You've adopted Claude, Copilot, or your own agents. You can see what's possible when AI has real operational context. But they're answering from training data — not your sensors, not your LIMS, not what's actually happening right now.
Every time you try to close that gap, you're rebuilding the same integration from scratch — only to find yourself locked to whatever AI your platform vendor happens to support.
Your AI can't see what's actually happening
Claude and Copilot are smart — but they're answering from generic training data, not your sensors, your LIMS, or your live operations right now.
You've built the same plumbing six times
New data source means new boilerplate, new auth, new parsing logic. Every connection is a from-scratch project and you're the bottleneck for every data request that comes in.
Nobody knows who built what or why
Six months later: mystery API, no docs, original engineer gone. Every team has one. It's not a people problem — it's the absence of governance at the moment something was built.
Every platform locks you to their AI
Switching AI tools means rebuilding your data layer. Vendor roadmaps shift and your integrations break. The lock-in isn't a side effect — it's the business model.
What changes
Any source. Any AI.
Governed from day one.
From raw data to queryable API - in one session
Connect your sources, describe what you need, and have a live HTTP endpoint before your coffee gets cold. No ETL scripts. No deployment pipeline. No waiting on another team.
Give the AI you already use live eyes on your systems
Paste your MCP server URL into Claude Desktop, VS Code Copilot, or any MCP-native tool. Three lines of config. Your AI immediately sees what's actually happening — governed, attributed, live. Your AI. Your governance. Not ours.
Every query governed — whoever calls it
Azi proposes, you approve. That governance applies to every caller: Claude, Copilot, a Python script, a dashboard. Who approved it, when, and why is in every response payload. Not a bolt-on audit feature. Just how the API works.
Who it is for
Built for the teams
who own the data.
OpenIndustrial is useful wherever there is a gap between data that exists and AI tools that could use it - but cannot reach it. That gap shows up differently depending on who you are.
Tired of building the same connector for the sixth time
You know exactly what you want. You could build this yourself - you have before. But the boilerplate-to-insight ratio is wrong, and you are the bottleneck for every data request that comes in.
Making the case for AI — but the AI can't see the real data
You've adopted Claude, Copilot, or both. You can see what's possible when AI has real operational context. You've tried workarounds — exports, manual RAG, custom MCP — and found them unsatisfying.
Every data access request is a ticket. You are the bottleneck.
You own the internal data infrastructure. Other teams need access to operational data. Giving it to them safely - with governance, with provenance - means building something. Again.
The data exists. Getting to it still requires filing a request.
You run experiments that generate machine data constantly. Getting it into a usable form means either doing it yourself - slow, painful - or waiting on a data or IT team whose queue is not your queue.
Enormous sensor data. Dashboards that have not changed since 2019.
You are sitting between OT and IT. You have access to sensor data at scale. Your existing dashboards show what someone decided to show three years ago. The questions you actually want to ask have no home.
How it works
Six steps. One session.
Any AI connected.
Every step ends with something real. You leave with a live governed API and an AI — your AI — that can query it.
Step 01
Drop in a connection
Drag your source onto the canvas - IoT device, REST API, database, or MCP tool. It auto-configures. No connection boilerplate.
API: REST | GraphQL | Webhooks
DB: SQL | Time-series | Data lakes
Step 02
Watch your data arrive in real time
Hit deploy. The Live Stream panel shows impulses arriving immediately. Your actual data - not sample data, not a mock.
- Azi configures it. You approve.
Step 03
Create a Surface
A Surface is where your queries live. Route one or more connections into it. All the data you need - none you do not.
Multiple Surfaces can share sources.
Step 04
Describe what you want - Azi writes it
Type what you need in plain English. Azi writes the query, shows her reasoning, and previews it against live data. Edit, reject, or approve.
- Azi writes KQL - You approve - Done.
Step 05
Your API is live the moment you approve
No deployment step. No waiting. Approved query = live HTTP endpoint, right now. Every response includes governance metadata automatically.
Step 06
Connect any AI - in under 10 minutes
Paste your MCP server URL into Claude Desktop, VS Code Copilot, or any MCP-native tool. Three lines of config. Your AI now sees what's actually happening — governed, attributed, live.
Governance applies to every caller, automatically.
Your AI co-builder
Describe it.
Azi builds it.
You stay in control.
Azi understands your whole workspace — every connection, every data shape, every query already approved. She writes the query, shows her reasoning, previews against live data, and waits for your OK. Always. Nothing ships without your sign-off. And that governance extends to every AI that calls your endpoints.
You describe it
Plain English. No query language required — but you can edit the KQL directly if you want to.
Azi builds it
A specific query, connection config, or transform - with her full reasoning visible.
You preview it
Real results, live data. Edit it, reject it, or approve it. Your call.
You approve — it ships
One click and it's a live API. Your name, timestamp, and reasoning go on it automatically.
Any AI can call it — governed
Connect Claude, Copilot, or your own agent. Every call goes through the control plane. Full audit trail, whoever's calling.
Telemetry
| where timestamp > ago(1h)
| summarize avg_temp=avg(temperature),
avg_humidity=avg(humidity)
by bin(timestamp, 5m)
| extend anomaly = (avg_temp > 75 or avg_temp < 65
or avg_humidity > 60 or avg_humidity < 40)
| order by timestamp ascPreview: 12 intervals, 2 anomaly flags. Approve to ship as a live API — governance metadata included in every response.can call it. Governance applies to all of them.
Bring any AI
Use the AI
you already trust.
OpenIndustrial exposes your governed queries as MCP tools — the open standard every major AI client supports. Use whichever AI you want, swap whenever you like. Your data access isn't tied to any of them.
Claude Desktop
Ask Claude about your live data and it queries your governed endpoints directly. Three lines of config. No exports.
MCP NativeClaude Code
Point Claude Code at your governed API and build real applications against your live data. The governance schema gives it the context to scaffold correctly.
MCP NativeVS Code Copilot
Copilot gets real schema context from your live data. Suggestions actually match your structures. Connect via MCP extension in minutes.
MCP NativeAny MCP Client
Cursor, Windsurf, Replit, custom agents — if it speaks MCP, it connects. Switch whenever you want. We don't care which AI you use.
MCP NativeFire us. Keep everything running.
Your APIs are standard HTTP. Your MCP connections use an open protocol. Deploy to your own Azure tenant. Switch AI tools, change vendors, export everything — it all works without us. We built it this way on purpose. Tools you can walk away from are tools worth staying with.
Any source
If it produces data,
you can query it.
OpenIndustrial isn't an IoT platform. It's a data-to-AI connection layer. Device telemetry, scheduled API pulls, databases, LIMS, ERP — connect them all in the same workspace and build queries that span every source. No glue code required.
Streaming Devices
IoT sensors, industrial equipment, edge gateways. Real-time telemetry via MQTT, AMQP, or HTTPS - visible on your canvas the moment it arrives.
APIs & Scheduled Pulls Coming soon
Pull from any REST API on a schedule — LIMS, ERP, third-party services. Define the interval, Azi handles the rest. No custom scripts, no deployment cycle.
Databases & Warehouses
SQL, time-series, data lakes. Query structured data side-by-side with live streams - in the same query, in the same session.
Aggregated Systems
Lab information systems, industrial historians, on-prem servers. Pull from anything that aggregates operational data before you touch it.
Governed by design
Build once.
Every caller, governed.
Every query becomes a live HTTP endpoint. Call it from dashboards, scripts, or AI agents. Every response includes governance metadata — who approved it, when — baked into the payload. Not an audit feature bolted on. Just how the API works.
'https://api.openindustrial.co/warm-queries/data-avg' \
-H 'Authorization: Bearer YOUR_JWT'
"query": "data-avg",
"executedAt": "2026-03-05T14:22:00Z",
"results": [
{ "source": "device", "avg_temp": 68.2, "anomaly": false },
{ "source": "lims-api", "avg_pH": 7.2, "anomaly": false }
],
"approvedBy": "engineer@company.co",
"approvedAt": "2026-03-05T09:30:00Z",
"calledBy": "claude-desktop"
}
}
Claude, Copilot, a Python script. Same audit trail, always.
No sales call. No credit card. No lock-in.
Bring your AI.
Own your data.
Connect your sources, build a governed query with Azi, and give the AI you already use live access to your operational data. In one session. Fire us anytime — your APIs keep running.