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

> Request synthetic XR-1 RoboCasa365 actions without a local simulator.

Request one RoboCasa365 action chunk using synthetic observations. This public model needs no
separate model-access grant.

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

TRACKS = ("left_agentview", "right_agentview", "wrist_view")


async def main():
    session = ReactorSession("reactor/xr1-robocasa365", fps=15, frame_size=(256, 256))
    try:
        await session.connect(TRACKS, subscribe=("action_prediction",))
        await session.send("set_task_description", {
            "task_description": "close the blender lid"
        })
        session.set_frames({
            name: np.full((256, 256, 3), 40 + 60 * i, dtype=np.uint8)
            for i, name in enumerate(TRACKS)
        })
        # A static synthetic observation makes every history slot identical.
        await asyncio.sleep(0.8)
        rows = [[0.0] * 14 for _ in range(4)]
        await session.send("set_state_history_json", {
            "state_history_json": json.dumps({"state_history": rows}, allow_nan=False)
        })
        started = time.perf_counter()
        await session.send("set_executed_step_json", {
            "executed_step_json": json.dumps({"step": 0})
        })
        reply = await session.next_message("action_prediction", timeout_s=90)
        actions = np.asarray(reply["action"], dtype=np.float64)
        assert actions.shape == (16, 60) and np.isfinite(actions).all()
        assert reply["step"] == 0
        print("actions:", actions.shape)
        print("first simulator action:", actions[0, :12])
        print("request-to-reply ms:", round((time.perf_counter() - started) * 1000, 1))
    finally:
        await session.close()


asyncio.run(main())
```

Expect `actions: (16, 60)` and 12 active values in the printed simulator action. The first execution
echo is required even though no actions have been executed. The model waits for at least four
complete camera sets while the helper continues publishing.

Constant synthetic images and zero state check connectivity and reply shape; do not execute these
outputs on hardware. Repeating frames is appropriate only for this artificial static history. A
rollout requires [aligned camera and state history](/robotics/xr1/robocasa365/simulation).

Printed timing starts at the execution echo, excluding connection and frame warmup. Next, use the
[integration guide](/robotics/xr1/robocasa365/integration) and
[history contract](/robotics/xr1/robocasa365/reference#history-and-readiness).


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