> ## 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.

# Introduction

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.

<Tip>
  **Before you build:** set up your [development environment](/software/development-setup) first — your IDE (VSCode, Cursor, ...) connected to the robot over Remote SSH. All agent files live and run on the robot, so this is the foundation for everything that follows.
</Tip>

## 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 `~/innate-os/workspace/custom_agents/`.

No configuration files. No complex setup. Just Python.

The built-in agents come from `~/innate-os/workspace/innate_agents/` and appear on the **Home** screen in the Innate Controller App.

<CardGroup cols={2}>
  <Card title="No Prompt (`basic_agent`)">
    Minimal default behavior with `navigate_to_position` and no prompt text.
  </Card>

  <Card title="Demo Agent (`demo_agent`)">
    Friendly interactive demo agent with navigation, waving, and gaze.
  </Card>

  <Card title="J3SO (`j3so_directive`)">
    Character-style conversational agent with navigation.
  </Card>

  <Card title="Security Guard (`security_guard_agent`)">
    Patrol-oriented agent with door opening and email alert behavior.
  </Card>

  <Card title="Chess Piece Agent (`chess_piece_agent`)">
    Chess gameplay agent using piece manipulation and move detection.
  </Card>

  <Card title="Chess Self-Play Agent (`chess_self_play_agent`)">
    Autonomous self-play chess agent with narrated moves.
  </Card>

  <Card title="Board Calibration Agent (`board_calibration_agent`)">
    Guided workflow agent for chess board corner calibration.
  </Card>
</CardGroup>

<img src="https://mintcdn.com/innateinc/hx7RaA7br-n-YY5y/images/main/software/agents-overview.png?fit=max&auto=format&n=hx7RaA7br-n-YY5y&q=85&s=cd5a12cc763264a6ac9d5af22f93492d" alt="Built-in agents in the app" style={{ maxWidth: "360px", width: "100%", display: "block", margin: "16px auto" }} width="960" height="2142" data-path="images/main/software/agents-overview.png" />

## Chess beta guides

* [Chess (beta)](/software/agents/chess-beta)
* [Chessboard calibration (beta)](/software/agents/chessboard-calibration-beta)

## System Architecture

Agents integrate into the following architecture:

```text theme={null}
┌─────────────────────────────────────────────────────────────────┐
│                        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.