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

> Python example for requesting one FastWAM LIBERO action chunk.

Your account needs access to `reactor/fastwam-libero`. Contact [Reactor](mailto:team@reactor.inc) if
it is not enabled. This example uses synthetic observations to check connectivity and output shape;
it never executes actions.

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

The shared public helper already supports this request pattern. No FastWAM model code or recorded
observations need to be downloaded.

## Request a chunk

Run the
[cookbook example](https://github.com/reactor-team/reactor-cookbook/blob/main/robotics/sim/notebooks/first_fastwam_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_fastwam_actions.py
```

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

import numpy as np
from reactor_robotics.session import ReactorSession

VIEWS = ("exterior_view_1", "wrist_view")


async def main():
    session = ReactorSession("reactor/fastwam-libero", fps=20, frame_size=(256, 256))
    try:
        await session.connect(VIEWS, subscribe=("action_prediction", "command_error"))
        await session.send("set_task_description", {"task_description": "Open the drawer."})
        session.set_frames({name: np.zeros((256, 256, 3), dtype=np.uint8) for name in VIEWS})
        request = {
            "proprio": [0.1, 0.2, 0.3, 0.0, 0.0, 0.0, 0.02, -0.02],
            "chunk_id": 1,
            "seed": 42,
        }
        started = time.perf_counter()
        await session.send("set_state_json", {"state_json": json.dumps(request)})
        reply = await session.next_message("action_prediction", timeout_s=120)
        actions = np.asarray(reply["actions"], dtype=np.float32)
        assert reply["step"] == request["chunk_id"]
        assert actions.shape == (32, 7)
        assert np.isfinite(actions).all()
        assert np.isin(actions[:, 6], [-1, 0, 1]).all()
        print("actions:", actions.shape)
        print("first step:", actions[0])
        print("model prediction seconds:", reply["inference_seconds"])
        print("request-to-reply ms:", round((time.perf_counter() - started) * 1000, 1))
    finally:
        await session.close()


asyncio.run(main())
```

Expect `actions: (32, 7)` and seven values for the first control step. Do not execute outputs from
these fabricated images and state on hardware. A fixed seed does not guarantee identical replies
when video encoding or observation timing changes the inputs.

`ReactorSession` keeps publishing the supplied frames while the request waits. Both tracks must
continue delivering frames after the request; publishing each image once beforehand can leave it
waiting. The example's 20 fps is a camera publishing rate, not a required robot control frequency.
The printed request time includes input waiting and transport; `inference_seconds` does not.

Next, [map simulator observations](/robotics/fastwam/libero/simulation) and
[implement execution](/robotics/fastwam/libero/integration). If the request times out, inspect
`command_error` messages as described in
[troubleshooting](/robotics/fastwam/libero/troubleshooting).


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