Modbus/TCP + ASI Biont: PLC Automation Without Code — Read Registers, Control Production via an AI Agent

If you're an automation engineer, you've probably spent too many nights writing OPC-UA gateways or custom scripts just to get a few values from a PLC into a dashboard. Modbus/TCP is everywhere — from Siemens and Schneider to WAGO and legacy Mitsubishi controllers — but turning raw registers into business actions usually requires integration middleware, MQTT brokers, and a pile of code.

ASI Biont changes that. It's an AI-agent platform that connects directly to Modbus/TCP devices through a visual AI Integration Builder. You can read coils, input registers, and holding registers without writing program logic. Then you control your process through natural-language chat — ask "what's the current tank level?" or send "start line 2 after the temperature stabilizes" and the agent talks to the PLC in real time.

In this guide, I'll show you the complete path: from PLC setup and register mapping to alerting and chat-based control. We'll use a real scenario with a compact PLC and a temperature transmitter, but the same steps apply to any Modbus/TCP device.

What Is ASI Biont and Why Modbus/TCP Matters

ASI Biont is an automation platform for connecting industrial assets to AI agents. It's a no-code integration tool built for the shop floor. Instead of configuring drivers and data dictionaries, you define "devices" and "tags" once; the AI agent builds the semantic layer on top — it knows that register 40001 is tank_temp, not just a number.

Why Modbus/TCP? Because it remains the de facto open protocol for industrial controllers, energy meters, and sensors. Most PLCs and RTUs expose a Modbus/TCP interface out of the box. You don't need extra hardware — just the IP address, port (default 502), and unit ID.

Before You Start: Prerequisites

• A PLC or controller with Modbus/TCP server enabled (Siemens S7-1500, WAGO PFC100, Schneider M340, or any simulator)
• Network access to port 502 from your ASI Biont instance
• A list of register addresses and data types from the device manual
• (Optional) Python environment with pymodbus for quick tests

Step 1: Enable Modbus/TCP on the PLC Side

First, make sure your PLC acts as a Modbus/TCP server. On a WAGO PFC200, load the Modbus library and bind the server to the Ethernet interface. On a Schneider M340, configure the Ethernet module as a Modbus server and define the accessible memory map. If you're just testing, use a simulator or the pymodbus server:

# test_modbus_server.py
from pymodbus.server import StartTcpServer
from pymodbus.datastore import ModbusSlaveContext, ModbusSequentialDataBlock

store = ModbusSlaveContext(
    di=ModbusSequentialDataBlock(0, [0]*100),
    co=ModbusSequentialDataBlock(0, [0]*100),
    hr=ModbusSequentialDataBlock(0, [25]*100),
    ir=ModbusSequentialDataBlock(0, [25]*100))
StartTcpServer(store, address=("0.0.0.0", 502))

Industrial networks are often firewalled — make sure your IT team opens port 502 only for the ASI Biont connector IP.

Step 2: Connect Modbus/TCP to ASI Biont via the AI Integration Builder

Log into ASI Biont, go to Integration Builder → New Device → Modbus/TCP. You'll see a simple form:

• Name: "Tank 1 PLC"
• Host: 192.168.1.100
• Port: 502
• Unit ID: 1
• Polling interval: 1 s for process values, 10 s for slow KPIs

Click Test Connection. ASI Biont sends a standard Modbus function code 0x03 (Read Holding Registers) and verifies the response. If it fails, check IP, firewall, and unit ID — this is the #1 pitfall.

Step 3: Read Registers and Map Them to Tags

After the connection is live, define tags. For a temperature controller:

In the Builder, create these tags and set optional scaling. The AI agent now has a semantic model: it knows that tank_temp comes from address 40001, raw value 2500 with scale 0.1 means +250.0 °C. You can also mark tags as read-only or read-write. The agent will automatically restrict writes to read-write tags.

Step 4: Control Production Through Chat

This is the "wow" moment. Open the ASI Biont chat interface (or connect to Telegram / Slack) and type:

"If tank_temp rises above 80, set setpoint to 60 and turn on pump 1"

The AI agent:
1. Parses the condition and action.
2. Checks register access rights.
3. Writes setpoint via Modbus function code 0x06 (Write Single Register).
4. Writes coil 0x01 (Write Single Coil).
5. Confirms by reading back the registers.

Under the hood, the agent executes standard Modbus frames — you can see the exact log in the integration console:

[12:00:01] Read HR 40001: 790 (79.0 °C)
[12:00:01] Condition: tank_temp > 80? false — skipping
[12:00:05] Read HR 40001: 812 (81.2 °C)
[12:00:05] Write HR 40002 (setpoint) = 60
[12:00:05] Write Coil 00001 (pump_status) = ON
[12:00:06] Read HR 40001: 805 (80.5 °C) — confirmed

No custom code. If you want to test the same logic with Python, the connector uses pymodbus internally:

from pymodbus.client import ModbusTcpClient

client = ModbusTcpClient("192.168.1.100", port=502)
client.connect()
data = client.read_holding_registers(0, count=2, unit=1)  # address 0 = 40001
temp_raw = data.registers[0]
temp = temp_raw * 0.1
client.write_register(1, 60, unit=1)   # setpoint -> 40002
client.write_coil(0, True, unit=1)     # pump 1 on
client.close()

Step 5: Set Up Alerts and Scheduled Reports

ASI Biont's AI agent isn't just reactive — it can poll registers on a schedule or trigger on thresholds. In the Builder, define a rule:

• Trigger: tank_temp > 85
• Action: send a Telegram message with current temp and a dashboard link
• Cooldown: 10 minutes (to avoid alert fatigue)

You can phrase it in plain language: "Notify me on Telegram if any tank exceeds 90 °C for more than 2 minutes." The agent converts that to a polling interval and a debounce condition, then starts watching.

Real-World Scenario: Tank Farm Monitoring

A chemical plant has three tanks with Modbus/TCP level transmitters and motorized valves. The engineer sets up three devices in ASI Biont (each with a different unit ID or IP). Then she creates a chat prompt:

"Create a daily report at 8:00 with the average level of each tank and total pump runtime."

The AI agent schedules the task, reads all input registers during the day, and sends a formatted report to Teams. An operator later asks: "Close valve 3 and alert me when level falls below 20%." The agent executes the write and arms an alert. No tickets, no SCADA modification.

That's the core promise: keep your PLC, your fieldbus, and your control logic — but put an AI agent on top that speaks Modbus natively.

Pitfalls and Best Practices

• Endianness and data types. Always verify word order and 32-bit value mapping. A raw reading of 250 might mean 250.0 or 25.0 depending on scale. Read raw values first, then apply scaling.
• Don't poll too fast. Modbus/TCP is simple, but reading 100 registers every 100 ms can overload a legacy PLC. Set poll intervals that match process dynamics.
• Segment the network. Place the ASI Biont connector on the OT network, not in a public VLAN. Restrict port 502 to only the agent's IP address.
• Enable write protection. Mark critical registers as read-only in the tag map to prevent accidental commands. Test with a simulator before touching production.
• Document your mapping table. When the asset gets old, the 40001 map will save you weeks of reverse engineering.

Conclusion: Start With One Register

You don't need a full digitalization project to benefit. Copy the example above, connect one PLC, create two tags (temp and pump), and start controlling it through the ASI Biont chat. Once you see a live value respond to a natural-language command, you'll never want to go back to VPN + ladder logic + forgotten Python scripts.

ASI Biont is free to start and includes a Modbus/TCP simulator, so you can build your first AI-agent workflow today. Head over to asibiont.com and tell your AI agent: "Read holding register 1 and tell me if it's above 100" — it will.