ESP32 + ASI Biont: Control Your IoT Devices Through an AI Agent (Step-by-Step Guide)

ESP32 + ASI Biont: Control Your IoT Devices Through an AI Agent (Step-by-Step Guide)

The Problem: You Built a Smart Device, Now You Need a Smart Way to Use It

We all know the feeling. You spent a weekend soldering a relay controlled by an ESP32. You flashed it, connected it to Wi-Fi, and saw the blinking LED. Then you asked yourself: "So what now?" Building a web dashboard is time-consuming. MQTT brokers like Mosquitto give you raw data, but you still need a client. If you want a natural interaction, you need an AI layer.

ASI Biont solves exactly that. It's an integration platform that lets you connect your devices, data streams, and AI agents without writing a backend server. You define what your device can do (telemetry and commands), and the agent handles the rest: understanding messages, transforming them into MQTT calls, and sending the response back to the user.

In this guide I'll show you a complete working example: an ESP32 with a DS18B20 temperature sensor and a relay, connected to ASI Biont, and controlled from Telegram through an AI agent. You'll get the wiring, the firmware, the integration configuration, and a couple of real-world pitfalls that you'll definitely hit.

What You Need Before Starting

Optionally, a Telegram bot token if you want chat control. I'll use Telegram as the UI because it's the fastest way to test.

Step 1: Wiring the ESP32 to the Sensor and Relay

The DS18B20 uses the 1-Wire protocol. It only needs one data line plus power. Here's the pinout:

The relay module has three control pins:

Step 2: Writing the ESP32 Firmware

Open the Arduino IDE, install the ESP32 board package (Boards Manager -> search "esp32" -> install). Then install these libraries:

• PubSubClient by Nick O'Leary
• OneWire by Paul Stoffregen
• DallasTemperature by Miles Burton
• ArduinoJson by Benoit Blanchon

Now create a new sketch. The firmware has three tasks:

1. Connect to Wi-Fi and MQTT with TLS.
2. Read the temperature every 10 seconds and publish a JSON payload.
3. Subscribe to a command topic and control the relay.

Here is the full sketch. I removed the certificate handling for simplicity; see the GitHub repo for the working TLS version.

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <ArduinoJson.h>

// WiFi settings
const char* ssid = "your_wifi";
const char* password = "your_password";

// MQTT settings
const char* mqtt_server = "broker.asi-biont.example";
const int   mqtt_port = 8883;
const char* mqtt_user = "device-lab-esp32";
const char* mqtt_pass = "your_token_here";

// Pins
#define ONE_WIRE_BUS 4
#define RELAY_PIN 16

WiFiClientSecure wifi_client;
PubSubClient mqtt(wifi_client);
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

const char* base_topic = "devices/lab-esp32";

void reconnect() {
  while (!mqtt.connected()) {
    if (mqtt.connect("esp32-lab", mqtt_user, mqtt_pass)) {
      mqtt.subscribe((String(base_topic) + "/commands/#").c_str());
    } else {
      delay(5000);
    }
  }
}

void callback(char* topic, byte* payload, unsigned int length) {
  String message;
  for (int i = 0; i < length; i++) message += (char)payload[i];

  String relay_cmd = String(base_topic) + "/commands/relay";
  if (String(topic) == relay_cmd) {
    if (message == "on") {
      digitalWrite(RELAY_PIN, HIGH);
      mqtt.publish((String(base_topic) + "/state/relay").c_str(), "on");
    } else if (message == "off") {
      digitalWrite(RELAY_PIN, LOW);
      mqtt.publish((String(base_topic) + "/state/relay").c_str(), "off");
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("WiFi connected");

  sensors.begin();
  mqtt.setServer(mqtt_server, mqtt_port);
  mqtt.setCallback(callback);
}

void loop() {
  if (!mqtt.connected()) {
    reconnect();
  }
  mqtt.loop();

  static unsigned long last_read = 0;
  if (millis() - last_read >= 10000) {
    sensors.requestTemperatures();
    float temp = sensors.getTempCByIndex(0);

    JsonDocument doc;
    doc["temp"]["value"] = temp;
    doc["temp"]["unit"] = "C";
    char buffer[128];
    serializeJson(doc, buffer);
    mqtt.publish((String(base_topic) + "/telemetry").c_str(), buffer);

    Serial.print("Published: ");
    Serial.println(buffer);
    last_read = millis();
  }
}

Notice that I used WiFiClientSecure but didn't set the CA certificate. For production, you should download the Let's Encrypt root certificate and use wifi_client.setCACert. Otherwise, the TLS handshake will fail on many brokers. I'll link to the full solution at the end.

Step 3: Configuring ASI Biont with the AI Integration Builder

Now log into ASI Biont and navigate to the AI Integration Builder. This is where you describe your device to the AI agent.

1. Click Create Integration -> MQTT Device.
2. Give your device a name: lab-esp32.
3. In the Connection tab, enter:
4. Broker address: the one you set in the firmware
5. Port: 8883
6. Username: device-lab-esp32
7. Password: your generated token
8. In the Schema tab, define the data model:

{
  "device": "lab-esp32",
  "telemetry": {
    "temp": {
      "type": "float",
      "unit": "C",
      "description": "Ambient temperature in Celsius"
    }
  },
  "commands": {
    "relay": {
      "type": "boolean",
      "on": true,
      "off": false
    }
  }
}

1. Save, then deploy the integration.

ASI Biont will now subscribe to devices/lab-esp32/telemetry on your behalf. When the ESP32 publishes, the agent's short-term memory stores the latest value.

The AI Integration Builder also lets you write custom actions. For example, I added an action called get_temperature which the agent uses when a user asks about the temperature. The builder automatically maps this action to the MQTT topic.

Step 4: Connecting a Chat Platform and Testing

Go to Channels and add a Telegram bot. Paste your BotFather token. ASI Biont creates a unique chat ID for you. Now send a message:

"what's the current temperature?"

The agent will retrieve the latest telemetry and reply:

"The current temperature in the lab is 22.4°C."

Then try:

"Turn the relay on for 10 seconds."

The agent publishes on to devices/lab-esp32/commands/relay and then after a delay (I used a custom workflow) publishes off. The reply is:

"Relay is now on (will turn off in 10 seconds)."

Automating Data Collection and Control

The fun doesn't stop at direct commands. Because ASI Biont uses an AI agent, you can create schedules and rules. In the Automation tab, set:

• Every hour, ask the agent to summarize the temperature trend.
• If the current temperature is above 30°C, automatically turn on a fan (via the relay) and notify you in Telegram.

These automations work by sending pre-written prompts to the agent. The agent executes them just like a chat message.

Pitfalls and Solutions

Here are things that went wrong for me, so they don't break your setup:

1. TLS issues with WiFiClientSecure. PubSubClient with SSL requires a certificate. Using a public broker with a self-signed cert will fail. Fix: add the CA certificate to the firmware. I recommend using mqtt.setBufferSize(512) to avoid fragment issues.

2. Flooding the broker with short QoS 0 messages. I initially published every second. As a result, ASI Biont's rate limit kicked in and the agent stopped responding. Fix: increase interval to 10 seconds and set QoS to 1 for important messages.

3. Wrong MQTT topic case sensitivity. I used Telemetry instead of telemetry. Commands didn't arrive. Make sure your topics are exactly what the schema expects.

4. Relay clicking constantly. The relay turned on and off due to a floating input pin. Add an external 10kΩ pull-down resistor on GPIO16, or set pinMode(RELAY_PIN, INPUT_PULLDOWN) (though the ESP32's internal pulldown is weak).

5. AI agent returning stale data. If the telemetry hasn't arrived yet, the agent may say "I don't know." In ASI Biont, enable the "wait for fresh data" option in the integration settings. This makes the agent wait for the next telemetry message before responding.

Results and Real-World Numbers

I ran the setup for seven days. Here are the key metrics:

The ESP32 only lost connectivity once, after a router reboot. The auto-reconnect loop handled it in ~15 seconds.

Conclusion: Give It a Try

Connecting an ESP32 to ASI Biont is one of the quickest ways to add an AI-powered conversation interface to your IoT project. You don't need a cloud backend or a complicated web app. Just an ESP32, an MQTT connection, and an AI Integration Builder.

I've published the full sketch with TLS certificate support and the ASI Biont integration template in this GitHub repo: https://github.com/asi-biont/esp32-example. Clone it, add your Wi-Fi credentials, create a bot, and you're live.

If you have questions or want to share your own ESP32 + ASI Biont project, write a comment below. And don't forget to subscribe to the blog - next week I'll explain how to connect a Raspberry Pi camera to the same agent and build a smart doorbell.

Now, go automate something. Your AI agent is waiting.