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.

The MobilityInterface gives you direct control over the robot base—rotation, velocity commands, and movement. Use it for custom navigation behaviors that complement the built-in navigation.

​
Core Navigation (Built-in)

The robot comes with built-in navigation that the agent calls innately. You don’t need to implement this—it works out of the box. Do not modify the core navigate_to_position skill. It’s a system-level skill that the agent uses automatically. Modifying it could break navigation behavior. When you tell the robot “go to the kitchen,” the agent automatically:
  1. Translates “kitchen” to map coordinates (if the location is saved)
  2. Calls the built-in navigation skill
  3. Monitors progress and handles obstacles

​
MobilityInterface

Declare the interface at class level: 
from brain_client.skill_types import Skill, Interface, InterfaceType

class MySkill(Skill):
    mobility = Interface(InterfaceType.MOBILITY)

​
Methods

MethodParametersDescription
rotate()
angle_radians: float
Rotate in place (blocking, uses Nav2).
send_cmd_vel()
linear_x: floatangular_z: floatduration: float
Publish velocity commands (non-blocking).
rotate_in_place()
angular_speed: floatduration: float
Rotate at a fixed angular speed for a set duration.

​
Examples

import math

# Rotate 90 degrees (blocking)
self.mobility.rotate(math.pi / 2)

# Drive forward for 2 seconds (non-blocking)
self.mobility.send_cmd_vel(linear_x=0.1, angular_z=0.0, duration=2.0)

# Spin in place
self.mobility.rotate_in_place(angular_speed=0.5, duration=3.0)

​
When to Use

ScenarioRecommendation
Go to a saved locationUse built-in behavior (agent handles it).
Survey surroundingsCreate a custom skill with rotate().
Follow a personCreate a custom skill with send_cmd_vel().
Fine positioning for manipulationCreate a custom skill.
Patrol a routeCreate a custom skill.

​
Example: LookAround

A skill that rotates to survey the environment: 
from brain_client.skill_types import Skill, SkillResult, Interface, InterfaceType
import math

class LookAround(Skill):
    mobility = Interface(InterfaceType.MOBILITY)

    @property
    def name(self):
        return "look_around"

    def guidelines(self):
        return "Use when the robot needs to look in multiple directions."

    def execute(self, num_directions: int = 4):
        rotation_per_step = (2 * math.pi) / num_directions

        for i in range(num_directions):
            if self._cancelled:
                return "Survey cancelled", SkillResult.CANCELLED

            self._send_feedback(f"Looking direction {i+1}/{num_directions}")
            self.mobility.rotate(rotation_per_step)

        return "Survey complete", SkillResult.SUCCESS

    def cancel(self):
        self._cancelled = True
        return "Survey cancelled"