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

> Request and inspect a DreamZero DROID action chunk without hardware.

Request one DreamZero DROID action chunk using synthetic observations.

## 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_dreamzero_droid_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_dreamzero_droid_actions.py
```

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

import numpy as np
from reactor_robotics.session import ReactorSession

TRACKS = ('exterior_1', 'exterior_2', 'wrist')
STATE = {'joint_position': [0.0, -0.6283, 0.0, -2.5133, 0.0, 1.885, 0.0], 'gripper_position': 0.0}


async def main():
    session = ReactorSession("reactor/dreamzero", fps=15, frame_size=(180, 320))
    try:
        await session.connect(
            TRACKS,
            subscribe=("action_chunk", "command_error", "episode_started", "prompt_accepted"),
            ready_timeout_s=900,
        )
        # Synthetic fixtures: never execute their predicted actions on hardware.
        rng = np.random.default_rng(7)
        frames = {name: rng.integers(0, 256, (180, 320, 3), dtype=np.uint8)
                  for name in TRACKS}
        for field, value in STATE.items():
            await session.send("set_" + field, {field: value})
        session.set_frames(frames)
        await asyncio.sleep(0.5)
        started = time.perf_counter()
        await session.send("set_prompt", {"prompt": "put the block in the bin"})
        reply = await session.next_message("action_chunk", timeout_s=300)
        actions = np.asarray(reply["actions"], dtype=np.float64)
        assert actions.shape == (24, 8), actions.shape
        assert np.isfinite(actions).all()
        assert reply["chunk_index"] == 0, reply["chunk_index"]
        print("actions:", actions.shape)
        print("first row:", actions[0])
        print("obs_seq:", reply["obs_seq"])
        print("model inference seconds:", reply["inference_seconds"])
        print("prompt-to-chunk seconds:", round(time.perf_counter() - started, 3))
    finally:
        await session.close()


asyncio.run(main())
```

Expect `actions: (24, 8)` and eight numeric values for the first row. The synthetic observations
check connectivity and reply shape; do not execute their outputs on hardware.

The helper repeats fixture images for this check. Use actual camera samples for an integration:
repeated images can erase useful temporal history. The 15 fps setting is video publishing, not robot
control cadence. See
[integration](/robotics/dreamzero/droid/integration#freshness-and-temporal-context).

Printed timing excludes session startup and the half-second settling wait, which does not guarantee
synchronization. `inference_seconds` also excludes client transport.

Next, [run RoboLab](/robotics/dreamzero/droid/simulation) or use the
[integration guide](/robotics/dreamzero/droid/integration). For missing replies, see
[troubleshooting](/robotics/dreamzero/droid/troubleshooting).


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