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

> ## Agent Instructions
> To build and serve your own model, start at /deploy/development/quickstart and /deploy/development/overview. Deploying is the default path: reactor init scaffolds a workspace, reactor auth login authenticates, and reactor model deploy registers the model, publishes the release with the weights/ folder, and activates it on Reactor's GPUs, in one command from that workspace. Docker must be running, because the publish step builds the image locally. Bump model.version in reactor.yaml before redeploying a change, because a release that already has an image is reactivated as it is. Deployment access is granted per account, so contact team@reactor.inc if a deploy is refused. Every key in reactor.yaml is documented at /deploy/platform/reactor-yaml. Model code imports reactor_runtime; Python client code imports reactor_sdk. The runtime overview explains the model interface. Running the model on your own machine with reactor run is optional and needs a GPU you attach with --gpus; /deploy/development/local-testing covers that loop and pairs a complete brightness model with a Python client test in a separate brightness-test workspace.
> Reactor hosts multiple models, each with its own connect slug (modelName) and command/event schema. The video model catalog — slug, typed SDK package, and links to its schema — is at /model-api-reference/overview. Robotics policy documentation starts at /robotics/overview; X-WAM observations, actions, and client integration are under /robotics/xwam/; Cosmos3 Nano Policy DROID is under /robotics/cosmos/nano-policy-droid/. Some models expose one slug per experience (e.g. HappyOyster); always take the slug from the model's own pages, never guess it.
> Fastest path to a working app: `npx create-reactor-app my-app --model=<slug>` scaffolds a complete app with secure auth wired up. Typed TypeScript SDKs are published as @reactor-models/<model>; Python uses the base reactor-sdk package.
> Auth: exchange an API key (rk_...) for a JWT via POST https://api.reactor.inc/tokens from your server. Never put the API key in client-side code.
> Append .md to any docs URL for clean Markdown. Search these docs via the MCP server at https://docs.reactor.inc/mcp.

# Get your first actions

> Call hosted X-WAM with synthetic observations and inspect one action chunk.

Send a synthetic observation to `reactor/xwam` and inspect one action chunk.

## Install the reference client

New to Reactor? [How the API works](/robotics/how-the-api-works) explains the session, camera
streams, commands, and action messages used below.

You need Python 3.12, [uv](https://docs.astral.sh/uv/getting-started/installation/), a
[Reactor API key](https://reactor.inc/account/api-keys), and
[Reactor’s public cookbook](https://github.com/reactor-team/reactor-cookbook/tree/main/robotics/sim).
The client code is public; your Reactor account still needs access to the selected hosted model. No
local model weights or GPU are required for this example.

```bash theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
git clone https://github.com/reactor-team/reactor-cookbook.git
cd reactor-cookbook
cd robotics/sim/notebooks
uv sync --frozen --python 3.12
export REACTOR_API_KEY='your-api-key'
```

Run the example below from `robotics/sim/notebooks/`. This environment installs the
[Python SDK](/sdk-reference/python/reactor) (`reactor-sdk`, imported as `reactor_sdk`) and the
[`reactor_robotics` helper directory in Reactor’s public cookbook](https://github.com/reactor-team/reactor-cookbook/tree/main/robotics/sim/notebooks/reactor_robotics).
The helpers provide camera publishing and message queues; they are separate from the SDK.

Keep your API key in the environment. On Linux, the published glibc wheel requires glibc 2.34 or
newer.

The default endpoint is `https://api.reactor.inc`; `REACTOR_API_URL` overrides it. Examples select a
model by slug, not a frozen release; check its release notes when the deployed contract changes. If
setup or connection fails, see
[first-run troubleshooting](/robotics/how-the-api-works#if-the-first-run-fails).

## Request a chunk

Run the
[cookbook example](https://github.com/reactor-team/reactor-cookbook/blob/main/robotics/sim/notebooks/first_xwam_actions.py)
from the current `robotics/sim/notebooks/` directory:

```bash theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
uv run --frozen python first_xwam_actions.py
```

This example uses `XwamClient`, a cookbook helper that handles X-WAM requests and converts action
replies to NumPy arrays.

```python theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
import asyncio

import numpy as np
from reactor_robotics.xwam import VIEWS, XwamClient


async def main():
    client = XwamClient(model="reactor/xwam")
    try:
        await client.connect()
        prediction = await client.predict(
            frames={name: np.zeros((240, 320, 3), dtype=np.uint8) for name in VIEWS},
            # Left xyz, quaternion wxyz, gripper; then the same for the right arm.
            proprio=[0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0] * 2,
            task="Pick up the bottle.",
        )
        assert prediction.step == 1
        assert prediction.actions.shape == (32, 14)
        assert np.isfinite(prediction.actions).all()
        print("actions:", prediction.actions.shape)
        print("first step:", prediction.actions[0])
        print("request-to-reply ms:", round(prediction.latency_ms, 1))
    finally:
        await client.close()


asyncio.run(main())
```

Expect `actions: (32, 14)` followed by 14 values for the first step. These are
[end-effector and gripper deltas](/robotics/xwam/robotwin/reference#action-reply). The synthetic
observations check connectivity and reply shape; do not execute their outputs on hardware.

Before each request, the client updates the frames and waits at least 200 ms for delivery. Printed
request-to-reply timing excludes that wait and is not total observation-to-action latency.

Next, [run RoboTwin](/robotics/xwam/robotwin/simulation) or use the
[integration guide](/robotics/xwam/robotwin/integration).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.