SCADA Meets AI: Integrating Industrial Control Systems with ASI Biont via REST API

Industrial SCADA systems are the backbone of modern manufacturing, energy, water treatment, and building management. They collect terabytes of sensor data, control thousands of actuators, and keep processes running 24/7. But traditional SCADA is often siloed – its data is locked inside proprietary HMIs and historians, and responding to anomalies requires human operators staring at dashboards. What if you could give your SCADA system an AI co-pilot that reads live data, predicts failures, and executes actions – all without writing a single line of integration code?

With ASI Biont, that’s exactly what happens. The AI agent connects to any SCADA system that exposes a REST API – and most modern SCADA platforms (Ignition, WinCC OA, Wonderware, VTScada, openSCADA) do. You simply describe your SCADA endpoint in the chat, and the AI writes the Python integration script on the fly, runs it in a secure sandbox, and starts interacting with your industrial process.

How ASI Biont Connects to SCADA via REST API

ASI Biont uses execute_python – a sandboxed environment on the ASI Biont server that has access to aiohttp, requests, httpx, and all major Python libraries. The AI reads your instructions (IP, authentication, endpoints), generates a tailored script, and executes it. No bridges, no local servers – just a chat conversation.

For example, you type:

Connect to my SCADA at 192.168.1.100:8080 with API key sk-abc123, read tag Tank_Level_01, and alert me if it exceeds 85%.

The AI writes the code, runs it, and sets up a monitoring loop (with proper async and sleep delays to stay within sandbox limits).

Authentication Methods

Most SCADA REST APIs support one of these:
- API Key – passed in headers: X-API-Key or Authorization: Bearer
- Basic Auth – username:password encoded in base64
- OAuth 2.0 – client credentials flow

The AI handles all of them. Example snippet for a SCADA that uses Bearer tokens:

import aiohttp
import asyncio

async def get_tank_level():
    headers = {"Authorization": "Bearer sk-abc123"}
    async with aiohttp.ClientSession(headers=headers) as session:
        async with session.get("http://192.168.1.100:8080/api/tags/Tank_Level_01") as resp:
            data = await resp.json()
            return data["value"]

level = asyncio.run(get_tank_level())
print(f"Current level: {level}%")

Real-World Use Cases

1. Reading Live Sensor Data and Generating Reports

A water treatment plant uses SCADA tags for pH, flow, and chlorine levels. The AI agent pulls these values every 30 minutes, checks against regulatory thresholds, and writes an Excel report. The code uses openpyxl to create a timestamped log.

import aiohttp
import asyncio
from openpyxl import Workbook
from datetime import datetime

async def fetch_tag(tag_name, url, headers):
    async with aiohttp.ClientSession(headers=headers) as session:
        async with session.get(f"{url}/api/tags/{tag_name}") as resp:
            data = await resp.json()
            return data["value"]

async def main():
    tags = ["pH_001", "Flow_Rate_001", "Chlorine_001"]
    url = "http://192.168.1.100:8080"
    headers = {"X-API-Key": "my-scada-key"}
    values = {tag: await fetch_tag(tag, url, headers) for tag in tags}
    wb = Workbook()
    ws = wb.active
    ws.append(["Timestamp", *tags])
    ws.append([datetime.now().isoformat(), *[values[t] for t in tags]])
    wb.save("scada_report.xlsx")
    print("Report saved.")

asyncio.run(main())

2. Predictive Analytics: Spotting Anomalies Before They Become Failures

SCADA historians store years of data. The AI can query recent trends and apply statistical models (using numpy and scipy) to detect deviations. For instance, if a pump’s current draw gradually increases over 6 hours, the agent flags it as a potential bearing failure.

import aiohttp
import asyncio
import numpy as np

async def get_historic_data(session, url, tag, hours):
    # Assume SCADA returns time-series JSON
    params = {"tag": tag, "from": f"-{hours}h"}
    async with session.get(f"{url}/api/history", params=params) as resp:
        data = await resp.json()
        return [point["value"] for point in data]

async def detect_anomaly():
    headers = {"X-API-Key": "key"}
    url = "http://192.168.1.100:8080"
    async with aiohttp.ClientSession(headers=headers) as session:
        values = await get_historic_data(session, url, "Motor_Current_001", 8)
        mean = np.mean(values)
        std = np.std(values)
        latest = values[-1]
        if abs(latest - mean) > 2 * std:
            print(f"ALERT: Motor current {latest:.1f}A deviates from normal ({mean:.1f}A ± {std:.1f}A)")
        else:
            print("All normal.")

asyncio.run(detect_anomaly())

3. Writing Setpoints and Controlling Processes

SCADA isn’t just about reading – operators also adjust setpoints. The AI can change a PID controller’s target temperature, start a pump, or acknowledge alarms via REST POST/PUT requests. Safety first: the AI always asks for confirmation before writing.

import aiohttp
import asyncio

async def set_setpoint(tag, value):
    headers = {"X-API-Key": "key", "Content-Type": "application/json"}
    payload = {"value": value}
    async with aiohttp.ClientSession(headers=headers) as session:
        async with session.put(f"http://192.168.1.100:8080/api/tags/{tag}", json=payload) as resp:
            if resp.status == 200:
                print(f"Setpoint {tag} set to {value}")
            else:
                print(f"Error: {await resp.text()}")

asyncio.run(set_setpoint("Reactor_Temp_SP", 85.0))

4. Automated Alarm Handling

When a critical alarm triggers (e.g., “High Pressure”), the SCADA webhook calls an ASI Biont endpoint. The AI receives the alarm payload, cross-references it with maintenance logs stored in a local database (using psycopg2 or sqlalchemy), and either sends a Telegram notification or executes a mitigation sequence.

Note: Because ASI Biont doesn’t have a public webhook URL, the AI can instead poll the SCADA alarm endpoint every 5 seconds (within sandbox timeout limits) and react immediately.

5. Generating Shift Summary Reports

At the end of each shift, the AI gathers production KPIs (OEE, throughput, downtime) from SCADA and emails a nicely formatted PDF using fpdf2 to management.

Why This Matters

Traditional SCADA integrations require months of custom software development and dedicated API gateways. With ASI Biont, you describe the need in natural language and the AI agent writes, tests, and deploys the integration in seconds. It’s not a device-specific plugin – it’s a universal execution engine. The AI understands your SCADA’s API documentation (or guesses from common patterns) and handles authentication, pagination, error retries, and asynchronous I/O.

And because the sandbox has access to the full Python ecosystem, you can combine SCADA data with Slack alerts, Excel reports, machine learning models, or cloud databases – all in one chat session.

Getting Started

Go to asibiont.com and create an account.
Navigate to Devices → Create API Key and download bridge.py if you need to connect local COM ports (not needed for SCADA API).
In the chat, simply tell the AI: “Connect to my SCADA REST API at 10.0.0.50 with API key xyz, read tag Temperature_01 and alert me if > 100°C.”
Watch as the AI writes the script, runs it, and starts monitoring.

No coding, no waiting for developers, no vendor lock-in. Your SCADA just got an AI brain.

Conclusion

Integrating SCADA with an AI agent is no longer a multi-month project. Using ASI Biont’s execute_python capability, any SCADA system with a REST API becomes instantly accessible to intelligent automation – from real-time monitoring and predictive maintenance to automated reporting and control. The barrier is just a conversation.

Ready to give your industrial process a digital co-pilot? Try the integration today at asibiont.com.

SCADA Meets AI: Integrating Industrial Control Systems with ASI Biont via REST API