VGA Output (ESP32 + DAC) and ASI Biont: Retro Display Meets AI Agent

In 2026, we rarely think of VGA monitors as intelligent devices. Yet tens of millions of 15-pin displays still sit in factories, airport terminals, hospital wards, and server rooms. An ESP32 with a simple DAC resistor network can drive those monitors with sharp 640x350 text. Now add ASI Biont, an AI agent that writes integration code on the fly, and you have a retro display that can render live stock prices, machine status, or Telegram notifications without a dedicated dashboard. This article explains how to connect an ESP32 VGA output to ASI Biont, why the AI handles the entire plumbing in a chat conversation, and how you can replicate the setup in under an hour.

Why VGA and ESP32 Still Make Sense

VGA may seem obsolete, but legacy displays are everywhere. Replacing them with modern LCDs is expensive and often unnecessary. An ESP32 costs around $3, has two 8-bit DAC channels (GPIO25 and GPIO26), and with an external resistor ladder you can create three analog color channels. Projects like bitluni's ESP32VGA library (github.com/bitluni/ESP32VGA) demonstrate that an ESP32 can generate VGA signals using the I2S peripheral plus a resistor DAC. No FPGA, no framebuffer chip, no GPU.

Why pair this with an AI agent? Because the hard part is not generating sync pulses; it is deciding what to display and updating it in real time. ASI Biont can pull data from a REST API, an MQTT broker, a Modbus PLC, or a database, format it as text, and send it over a serial link to the ESP32. That turns a dumb terminal into a smart IoT display.

Hardware: Building a VGA Output from ESP32

A minimal VGA connection requires horizontal sync (HSYNC), vertical sync (VSYNC), and three analog color channels (R, G, B). The ESP32's internal DACs can handle two channels, but most hobby projects use a resistor-ladder DAC on three GPIO pins. The library treats a color byte as 3 bits per channel, giving 8 colors, or as 6 bits per channel for 64 colors.

A typical pinout for bitluni's ESP32VGA library is:

Check the library documentation for your exact board. VGA sync inputs are TTL compatible, so 3.3V logic is fine. The color lines need a voltage divider to keep the analog level below 0.7V. According to the Espressif ESP32 technical reference (docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/dac.html), the internal DAC has 8-bit resolution and outputs 0 to 3.3V, so a resistor divider is required for direct VGA connection.

What Is ASI Biont? A Brief Overview

ASI Biont is a text-based AI agent that runs in a chat interface. It does not have a library of pre-made device drivers; instead, it generates the integration code for you. You describe the device, the connection parameters, and what you want to happen. The AI then writes a Python script, an Arduino sketch, or a bridge configuration, and often executes it on the spot.

The key difference from conventional IoT platforms is that there is no management panel with buttons like Add Device or Create Trigger. Everything happens in the chat dialog. The AI asks clarifying questions, proposes a plan, and then produces the code.

Choosing the Right Connection: COM Port vs MQTT

An ESP32 can connect to ASI Biont in several ways. For a VGA display attached to a serial port, the most straightforward is a COM port through the Hardware Bridge. Older displays are usually close to a PC, and a USB-UART adapter gives you a COM port (COM3 on Windows, /dev/ttyUSB0 on Linux). The bridge creates a transparent tunnel between ASI Biont and the serial device, using a secure token.

The alternative is MQTT: the ESP32 connects to Wi-Fi, subscribes to a topic, and ASI Biont publishes messages via paho-mqtt. This works well if the ESP32 is already networked, but it requires an MQTT broker and a more complex firmware. For a factory floor with strict firewall rules, serial is simpler and more deterministic.

This article focuses on the COM port route, because it requires no network configuration and works with any legacy VGA monitor.

Step-by-Step: How the Integration Works in Chat

Open ASI Biont and type something like:

"Connect to COM3 at 115200 baud. The device is an ESP32 with a VGA output. I want to show the current time, outside temperature from an HTTP API, and the last line of an RSS feed. Update every 10 seconds."

The AI replies with two parts: an Arduino/MicroPython sketch for the ESP32, and instructions for launching the Hardware Bridge on your PC. You flash the firmware, then run the bridge from a terminal:

bridge.py --token=YOUR_TOKEN --ports=COM3 --baud 115200 --rate=10

The --rate=10 parameter sets a 10 Hz command/response polling interval. The bridge then listens for industrial_command calls from ASI Biont and forwards them to the serial port.

Important: the Hardware Bridge does not expose an HTTP API. You must use the industrial_command() function in your AI-generated scripts. The exact signature is shown in the chat after the AI proposes the script; do not try to curl a URL on the bridge.

Firmware Example: A Minimal Text Terminal

The ESP32 firmware reads lines from the serial port and draws them on the VGA screen. The code below is an illustrative Arduino sketch using the popular ESP32VGA library. The exact API may differ slightly depending on the library version, but the pattern holds.

#include <ESP32VGA.h>
VGA vga;
String buffer;

void setup() {
  Serial.begin(115200);
  vga.init();
  vga.clear();
}

void loop() {
  while (Serial.available()) {
    char c = Serial.read();
    if (c == 10) { // newline character
      if (buffer.startsWith("TXT:")) {
        vga.clear();
        vga.drawString(0, 0, buffer.substring(4).c_str());
      } else if (buffer == "CLS") {
        vga.clear();
      }
      buffer = String();
    } else {
      buffer += c;
    }
  }
}

The firmware never needs to know where the text comes from. It is a classic dumb terminal, which is exactly what makes it reliable. You can extend it with commands for setting the cursor position, changing color, or drawing a rectangle.

Sending Commands from ASI Biont

Once the bridge is running, ASI Biont sends data to the ESP32 through industrial_command(). The AI-generated code might look like this:

industrial_command(
    protocol='serial',
    command='TXT: Flight SU1234 is now boarding\n',
    port='COM3',
    baud=115200
)

The command string wraps the text in a simple protocol: TXT: followed by the message and a newline. The ESP32 parses it and displays the text. The AI wrote this call after you described the device; you did not manually create a device profile.

In the chat dialog, you can ask the AI to send a test message immediately. The AI will execute the industrial_command call and you will see the text appear on the VGA monitor within milliseconds.

Real-World Scenario 1: Airport Information Board

A small regional airport has a stack of Samsung SyncMaster 753s monitors from the early 2000s. Their ancient Windows 98 PCs are failing. The airport IT engineer replaces each PC with an ESP32 board, a resistor DAC, and a VGA cable. A single Raspberry Pi runs the Hardware Bridge for all displays.

The engineer opens ASI Biont and types:

"Read the departure list from our REST API at https://api.example.com/flights. Extract flight number, destination, and status. For each delayed flight, send a text line to COM3. Update every 15 seconds."

ASI Biont writes a Python script that fetches the JSON data, parses it, and loops over the flights, calling industrial_command() for each delay message. The ESP32 draws the text on the VGA screen. The airport now has an information board with no graphics drivers, no X11, and no obsolete operating system. The AI also adds a fallback: if the API is unreachable, it sends the text "API OFFLINE" to the display.

Scenario 2: Factory OEE Terminal

A manufacturing plant uses a Siemens S7 PLC to track Overall Equipment Effectiveness (OEE). Previously, a dedicated HMI panel showed the metrics. The plant wants to reuse a spare CRT monitor in the break room. The ESP32 VGA display is connected to a USB-UART adapter on an industrial PC that already runs the Hardware Bridge.

The engineer asks ASI Biont:

"Poll the S7 PLC for DB10.DBW0 and DB10.DBW2. Calculate availability and performance. Display them as a single line on the serial VGA display every 5 seconds."

ASI Biont uses snap7 to read the PLC registers, calculates the OEE, formats a string like OEE 87.3% Avail 95.0% Perf 91.9%, and sends it via industrial_command(). The CRT in the break room now shows real-time production efficiency. No new HMI hardware was purchased.

The Universal Fallback: execute_python

Not every device has a dedicated Hardware Bridge driver. That is why ASI Biont also offers a universal execute_python mechanism. You can connect to any device by asking the AI to write a Python script. For example:

"Write a Python script that connects to my ESP32 via pyserial on /dev/ttyUSB0, baud 115200, and sends the text 'Hello from AI' every second."

ASI Biont generates a script using pyserial, similar to:

import serial
import time
ser = serial.Serial('/dev/ttyUSB0', 115200, timeout=1)
for i in range(10):
    ser.write(b'TXT: Hello from AI\n')
    time.sleep(1)
ser.close()

The sandbox has a 30-second timeout, so the AI avoids infinite while True loops and instead uses a for loop with a delay. This script can be scheduled by ASI Biont to run periodically. This means you can connect a VGA output to ASI Biont even if you never touch the Hardware Bridge; the AI simply writes the integration code for you at runtime.

Whether you use the Hardware Bridge or execute_python, the user never opens a configuration file or edits a JSON manifest. You describe the device in natural language, specify the port, baud rate, or API key, and the AI does the rest.

Security and Reliability Notes

• The Hardware Bridge authenticates with a --token, so strangers cannot write to your COM port.
• The execute_python environment is sandboxed; the AI has no direct access to your host beyond the bridges and APIs you explicitly configure.
• At 115200 baud, a 100-character command takes about 9 milliseconds, leaving plenty of time for the ESP32 to update the VGA display.
• Avoid blocking operations in the ESP32 firmware; VGA signal generation must continue during serial processing. Use non-blocking reads and a short loop.
• Always test with a known-good VGA cable and a monitor that supports standard 640x350 or 800x600 modes.

Results Without Hype

We will not invent a fake percentage for efficiency improvement. What we can say is that the workflow changes qualitatively. Previously, a display integration project involved writing custom firmware, a PC-side driver, a network protocol, and a UI to configure content. With ASI Biont, the same person achieves the result in a single chat session. The AI creates the firmware, the bridge command, and the data-parsing logic. Users typically move from I wonder if this works to it is on my desk displaying live data in under an hour.

Early users report that the biggest time savings come from the AI asking the right clarifying questions. Instead of reading a 200-page protocol document, the user types one sentence, and the AI selects the correct library and data format. The VGA monitor itself is a secondary detail; the AI's ability to abstract away the low-level hardware is the real value.

Conclusion: Try the Integration Today

The combination of an old VGA monitor, a cheap ESP32, and an AI agent is surprisingly powerful. You do not need to wait for a vendor to add ESP32 support to ASI Biont; the AI can write code for any device you can describe. Open asibiont.com, start a chat, and ask ASI Biont to connect to your COM port and drive a retro VGA terminal. You will be amazed at how quickly a decades-old display can become part of a modern AI-driven system.