Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.innate.bot/llms.txt

Use this file to discover all available pages before exploring further.

An agent defines who your robot is and what it can do. Without an agent, a robot is just hardware waiting for instructions. With an agent, it becomes a security guard, a tour guide, a friendly greeter etc.

​
What is an Agent?

An agent is a Python class that defines three things together: the skills the robot can execute, the inputs it listens to, and the prompt that defines behavior and tone. When you activate an agent, the robot adopts that identity. The same hardware can run very different agents with distinct personalities and capabilities.

​
Agents as Portable Applications

Agents are designed to be shareable. Write an agent once, and anyone with an Innate robot can use it—just drop the Python file into the agents folder. No configuration files. No complex setup. Just Python. For OS 0.5.1, the built-in agents come from innate-os/agents and appear on the Home screen in the Innate Controller App.

No Prompt (`basic_agent`)

Minimal default behavior with navigate_to_position and no prompt text.

Demo Agent (`demo_agent`)

Friendly interactive demo agent with navigation, waving, and gaze.

J3SO (`j3so_directive`)

Character-style conversational agent with navigation.

Security Guard (`security_guard_agent`)

Patrol-oriented agent with door opening and email alert behavior.

Chess Piece Agent (`chess_piece_agent`)

Chess gameplay agent using piece manipulation and move detection.

Chess Self-Play Agent (`chess_self_play_agent`)

Autonomous self-play chess agent with narrated moves.

Board Calibration Agent (`board_calibration_agent`)

Guided workflow agent for chess board corner calibration.
Built-in agents in the app

​
Chess beta guides

​
System Architecture

Agents integrate into the following architecture: 
┌─────────────────────────────────────────────────────────────────┐
│                        Cloud AI                                  │
│            Processes vision and makes decisions                  │
└────────────────────────────┬────────────────────────────────────┘
                             │ WebSocket
┌────────────────────────────▼────────────────────────────────────┐
│                    Brain Client (ROS 2)                          │
│       Manages agents, executes skills, bridges cloud ↔ robot     │
└────────────────────────────┬────────────────────────────────────┘
                             │
        ┌────────────────────┼────────────────────┐
        │                    │                    │
┌───────▼───────┐    ┌───────▼───────┐    ┌──────▼──────┐
│    Agents     │    │    Skills     │    │   Inputs    │
│ (Personality) │    │  (Actions)    │    │  (Sensors)  │
└───────────────┘    └───────────────┘    └─────────────┘
The cloud AI receives camera feeds and input data. It reads the agent’s prompt to understand the robot’s role, checks available skills to know what actions are possible, then decides what to do. The robot executes accordingly. Your agent is the contract between you and the AI—it defines who the robot is and what it can do.

​
Design Philosophy

Traditional robotics software often requires deep expertise to modify. Agents take a different approach: they’re designed to be readable and modifiable. You can look at an agent file and immediately understand what it does. You can modify it, experiment, and iterate quickly. The goal is to let you focus on building interesting robot behaviors rather than wrestling with infrastructure.