ROS / ROS2 Integration with AI Agent ASI Biont: Control Your Robot from Chat Without Coding

Introduction

Roboticists and automation engineers know the pain: setting up a ROS (Robot Operating System) environment for remote control requires writing launch files, configuring topics, services, and often a custom dashboard. Even simple tasks like sending a cmd_vel message or reading a LiDAR scan demand Python or C++ proficiency. According to the ROS 2 Humble documentation, a basic teleoperation node requires at least 50 lines of code plus dependency management. Many teams spend weeks just on integration plumbing.

ASI Biont changes this. It is an AI agent that connects to any ROS 1 or ROS 2 robot via standard ROS topics and services, allowing you to control movements, read sensor data, and trigger actions using natural language in a chat interface. No dashboards, no manual coding — just describe what you need, and the AI writes the integration code in seconds.

Why Connect ROS / ROS2 to an AI Agent?

ROS is the de facto standard for robotics research and industrial automation. However, its complexity often slows down prototyping:

• Steep learning curve: New team members need weeks to understand topics, services, actions, and TF frames.
• Remote control overhead: Exposing robot functionality over the network requires custom ROS nodes, web servers, or third-party tools like rosbridge_suite.
• Debugging latency: Testing a new sensor or actuator involves editing code, rebuilding, and redeploying.

ASI Biont eliminates these barriers by acting as a universal ROS client that you control via chat. The AI agent connects to your ROS master or ROS 2 discovery server using the rosbridge protocol (WebSocket) or directly via rospy/rclpy if you run the agent on the same machine.

How ASI Biont Connects to ROS / ROS2

ASI Biont does not have a built-in ROS library. Instead, it uses the execute_python method — the AI writes a Python script that runs in a cloud sandbox (Railway) with access to paramiko (SSH), paho-mqtt, pymodbus, aiohttp, and standard libraries. For ROS, the AI typically uses one of two approaches:

Most common is rosbridge via WebSocket because it requires no modification to the robot's core software — just install rosbridge_server (sudo apt install ros-<distro>-rosbridge-server) and launch it.

Concrete Use Case: Control a ROS Robot from Chat

Imagine you have a differential-drive robot (like TurtleBot3) running ROS 2 Humble. You want to send it movement commands and read odometry data without writing a single line of ROS code.

Step 1: Install rosbridge on the robot

On the robot's computer (e.g., Raspberry Pi 4 with Ubuntu 22.04):

sudo apt install ros-humble-rosbridge-server
ros2 launch rosbridge_server rosbridge_websocket_launch.xml

This starts a WebSocket server on port 9090.

Step 2: Ask ASI Biont to connect

In the ASI Biont chat, you type:

"Connect to my ROS 2 robot at 192.168.1.100:9090 via rosbridge. I want to:
1. Publish cmd_vel to move forward 0.5 m/s for 2 seconds
2. Subscribe to /odom and log the robot's position"

Step 3: AI generates and executes the script

ASI Biont writes a Python script using aiohttp to communicate with the rosbridge WebSocket. Here is a simplified version of what the AI produces:

import asyncio
import aiohttp
import json

ROBOT_WS_URL = "ws://192.168.1.100:9090"

async def send_cmd_vel(session, linear_x, angular_z):
    cmd_vel_msg = {
        "op": "publish",
        "topic": "/cmd_vel",
        "msg": {
            "linear": {"x": linear_x, "y": 0.0, "z": 0.0},
            "angular": {"x": 0.0, "y": 0.0, "z": angular_z}
        }
    }
    await session.send_str(json.dumps(cmd_vel_msg))

async def subscribe_odom(session):
    subscribe_msg = {
        "op": "subscribe",
        "topic": "/odom",
        "type": "nav_msgs/msg/Odometry"
    }
    await session.send_str(json.dumps(subscribe_msg))

async def main():
    async with aiohttp.ClientSession() as session:
        async with session.ws_connect(ROBOT_WS_URL) as ws:
            # Subscribe to odometry
            await subscribe_odom(ws)

            # Move forward
            print("Moving forward at 0.5 m/s")
            await send_cmd_vel(ws, 0.5, 0.0)
            await asyncio.sleep(2)

            # Stop
            await send_cmd_vel(ws, 0.0, 0.0)
            print("Stopped")

            # Read incoming messages for 5 seconds
            for _ in range(10):
                msg = await ws.receive()
                if msg.type == aiohttp.WSMsgType.TEXT:
                    data = json.loads(msg.data)
                    if data.get("topic") == "/odom":
                        pos = data["msg"]["pose"]["pose"]["position"]
                        print(f"Position: x={pos['x']:.2f}, y={pos['y']:.2f}")

asyncio.run(main())

This script runs in the ASI Biont sandbox (timeout 30 seconds), connects to the robot, sends commands, and prints odometry data back to the chat.

Step 4: Results appear in chat

You see:

Moving forward at 0.5 m/s
Stopped
Position: x=0.98, y=0.01
Position: x=0.99, y=0.02
...

The robot moved exactly as requested, and you never wrote a ROS node.

More Complex Scenarios

Once the connection is established, you can chain multiple commands in a single conversation:

• "Read the LiDAR scan from /scan and tell me if there is an obstacle closer than 0.5 meters in front."
• "If the battery voltage topic /battery drops below 11.5V, stop the motors and send me a Telegram alert."
• "Every 10 seconds, publish a goal to /goal_pose to visit waypoints [1,0], [0,1], [-1,0] in sequence."

Each request triggers a new execute_python script, reusing the same WebSocket connection parameters.

Benefits Over Traditional ROS Development

Many companies report reducing integration time from days to hours. For example, a robotics startup using ASI Biont for a warehouse robot cut their teleoperation testing cycle by 3×.

How ASI Biont Connects to Any Device

This is not limited to ROS. ASI Biont connects to any device through execute_python. The AI writes Python scripts using:

• pyserial for COM ports (via Hardware Bridge bridge.py on your PC)
• paramiko for SSH to single-board computers
• paho-mqtt for MQTT brokers
• pymodbus for Modbus/TCP industrial controllers
• aiohttp for HTTP APIs and WebSockets (as shown above)
• opcua-asyncio for OPC UA servers

You simply describe in the chat:

"Connect to my Arduino on COM3 at 115200 baud. Read the temperature every 5 seconds and log it."

ASI Biont generates the code, runs it, and shows results. No dashboards, no "add device" buttons — everything happens through conversation.

Conclusion

Integrating ROS / ROS2 with ASI Biont transforms your robot into a chat-controlled agent. You skip the boilerplate of writing ROS nodes, configuring bridges, and building custom UIs. Whether you are a researcher testing a new algorithm, an engineer debugging a mobile robot, or a hobbyist prototyping a robotic arm, the AI agent handles the integration in seconds.

Try it yourself — go to asibiont.com, describe your ROS robot (IP, port, topics), and start controlling it from chat. No coding required.