> ## Documentation Index
> Fetch the complete documentation index at: https://servo.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduction

> Connect physical robots to hosted VLA models with low-latency streaming.

Servo connects physical robot hardware to cloud-hosted Vision-Language-Action (VLA) models with
low-latency streaming, smooth action execution, and built-in safety controls.

Instead of forcing your robot into rigid custom frameworks or writing fragile glue code,
Servo connects model inputs and outputs directly to your existing Python functions, camera streams,
and motor controllers.

> **Preview.** The `servo.connect` API is currently in developer preview and not yet shipped in general availability. Early feedback and testing are welcome. Code samples on this page import `connect`/`camera` explicitly from `servo.universal` — they don't yet resolve as `servo.connect` etc.

## Why Servo

1. **Zero Glue Code**: Model inputs (such as camera feeds and joint angles) and outputs (target joint actions) bind directly to your existing Python callables, ROS 2 topics, or hardware camera handles.
2. **Smooth 30 Hz Motion**: Pipelined action chunk prefetching streams actions continuously without chunk-boundary pauses or arm stutter.
3. **Built-in Safety**: If a motor driver raises an exception (overcurrent, joint limits exceeded, or E-stop), Servo catches the fault immediately, commands an active zero-velocity hold, and logs diagnostic telemetry.
4. **Environment Isolation**: Your robot drivers can run in their native environment while Servo's background engine handles hardware-accelerated video compression and low-latency network transport.
5. **Live Monitoring & Interventions**: Review real-time camera feeds in your browser and seamlessly transition between autonomous policy control and manual teleoperation.

## How it works

Connecting a robot takes just a few lines of Python:

```python theme={null}
from servo.universal import camera, connect
from my_robot import BimanualYam

# 1. Initialize your robot driver
arm = BimanualYam()

# 2. Connect model inputs and outputs
session = connect(
    "allenai/MolmoAct2-BimanualYAM",
    region="us-west-2",
    observe={
        "top": camera(serial="250423122040"),
        "left": camera(serial="402323071792"),
        "right": camera(serial="402323071794"),
        "state": arm.get_joint_positions,
    },
    act=arm.apply_joint_targets,
)

# 3. Run an autonomous task
report = session.run(task="pick up the red cup", timeout_s=20.0)
print(report)
```

Servo automatically starts its local background daemon (`servo daemon`) on first use to manage video compression, shared memory buffers, and streaming transport. For dedicated production robot cells, you can install the daemon as a supervised system service with `servo daemon --install-service`.

Before moving physical hardware, you can also run zero-motion preflight verification using `servo check-rig` to validate all camera streams, network connections, and motor bindings safely.

## Next steps

* Follow the [Quickstart](/quickstart) to test a simulated rollout on your laptop in 5 minutes.
* Read the [Robot Integration Guide](/guides/robots) for complete details on cameras, motor contracts, and ROS 2.
* Learn how to manage multi-robot deployments in [Robot Fleets](/guides/fleet-deployment).
* Explore all classes and methods in the [Python API Reference](/reference/python-api).