Navigation Interfaces

The Mobility interface 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

Mobility

Declare the interface with a class-level type annotation. Declaring is requiring — the run fails up front if the base is unavailable, so self.mobility is guaranteed inside execute():

from innate import Mobility, Skill

class MySkill(Skill):
    mobility: Mobility

Methods

Examples

import math

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

# Drive forward for 2 seconds (non-blocking; stops after duration)
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)

Closed-loop moves

send_cmd_vel is open loop — it commands a speed and hopes. When you need the robot to actually arrive, drive() and rotate_by() watch odometry and correct until they get there:

from innate import Mobility, Odometry, Skill

class NudgeForward(Skill):
    mobility: Mobility
    odom: Odometry

    def guidelines(self) -> str:
        return "Use to shuffle the robot forward a short, precise distance."

    def execute(self):
        # pass a reader; they poll it as they go
        arrived = self.mobility.drive(lambda: self.mobility.odom_xyt(self.odom), 0.25)
        return "Nudged forward" if arrived else "Couldn't get there"

odom_xyt() turns the odometry feed into the plain (x, y, theta) tuple these take.

Both return True on arrival and False on timeout or lost odometry — they never raise. They stop the base on the way out, whatever happened.

When to Use

Example: LookAround

A skill that rotates to survey the environment, written with every agent-facing method explicit:

import math
from innate import Mobility, Skill, SkillReturn

class LookAround(Skill):
    mobility: Mobility

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

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

        for i in range(num_directions):
            self.feedback(f"Looking direction {i + 1}/{num_directions}")
            self.mobility.rotate(rotation_per_step)
            self.sleep(0.2)

        return "Survey complete"

Cancellation needs no plumbing: self.sleep() raises the moment the user or agent interrupts, the base is braked for you, and the run reports CANCELLED.