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

# Navigation Interfaces

export const NavigationUseCasesTable = () => {
  const rows = [{
    scenario: "Go to a saved location",
    recommendation: "Use built-in behavior (agent handles it)."
  }, {
    scenario: "Survey surroundings",
    recommendation: "Create a custom skill with rotate()."
  }, {
    scenario: "Follow a person",
    recommendation: "Create a custom skill with send_cmd_vel()."
  }, {
    scenario: "Fine positioning for manipulation",
    recommendation: "Create a custom skill."
  }, {
    scenario: "Patrol a route",
    recommendation: "Create a custom skill."
  }];
  return <div className="interface-methods-table-wrap">
      <table className="interface-methods-table">
        <thead>
          <tr>
            <th>Scenario</th>
            <th>Recommendation</th>
          </tr>
        </thead>
        <tbody>
          {rows.map(row => <tr key={row.scenario}>
              <td>{row.scenario}</td>
              <td>{row.recommendation}</td>
            </tr>)}
        </tbody>
      </table>
    </div>;
};

export const NavigationInterfaceMethods = () => {
  const rows = [{
    method: "rotate()",
    params: [{
      name: "angle_radians",
      type: "float"
    }],
    desc: "Rotate in place (blocking, uses Nav2)."
  }, {
    method: "send_cmd_vel()",
    params: [{
      name: "linear_x",
      type: "float"
    }, {
      name: "angular_z",
      type: "float"
    }, {
      name: "duration",
      type: "float (seconds)"
    }],
    desc: "Publish velocity commands for duration seconds (non-blocking)."
  }, {
    method: "rotate_in_place()",
    params: [{
      name: "angular_speed",
      type: "float"
    }, {
      name: "duration",
      type: "float (seconds)"
    }],
    desc: "Rotate at a fixed angular speed for a set duration in seconds."
  }];
  return <div className="interface-methods-table-wrap">
      <table className="interface-methods-table">
        <thead>
          <tr>
            <th>Method</th>
            <th>Parameters</th>
            <th>Description</th>
          </tr>
        </thead>
        <tbody>
          {rows.map(row => <tr key={row.method}>
              <td>
                <span className="interface-method-pill">{row.method}</span>
              </td>
              <td>
                {row.params?.length ? <div className="interface-method-params">
                    {row.params.map(param => <span key={`${row.method}-${param.name}`} className="interface-param-badge">
                        {param.name}
                        {param.type ? <span className="interface-param-type">: {param.type}</span> : null}
                      </span>)}
                  </div> : <span className="interface-no-params">None</span>}
              </td>
              <td>{row.desc}</td>
            </tr>)}
        </tbody>
      </table>
    </div>;
};

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:

```python theme={null}
from brain_client.skill_types import Skill, Interface, InterfaceType

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

### Methods

<NavigationInterfaceMethods />

### Examples

```python theme={null}
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

<NavigationUseCasesTable />

## Example: LookAround

A skill that rotates to survey the environment:

```python theme={null}
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"
```