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

> Select a checkpoint and check an action chunk with synthetic observations.

Select a checkpoint and request one 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_flux_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_flux_actions.py
```

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

import numpy as np
from reactor_robotics.session import ReactorSession

TRACKS = ("wrist_view", "exterior_view_1", "exterior_view_2")


async def main():
    session = ReactorSession("reactor/flux3-action-droid", fps=15, frame_size=(360, 640))
    try:
        await session.connect(
            TRACKS, subscribe=("checkpoint_selected", "action_prediction", "command_error")
        )
        await session.send("get_checkpoint", {})
        status = await session.next_message("checkpoint_selected", timeout_s=20)
        selected = status["checkpoint"]
        if selected not in status["available"]:
            raise RuntimeError("Default checkpoint unavailable; select a listed alternative")
        await session.send("select_checkpoint", {"checkpoint": selected})
        confirmed = await session.next_message("checkpoint_selected", timeout_s=20)
        assert confirmed["locked"] and confirmed["checkpoint"] == selected
        await session.send(
            "set_task_description", {"task_description": "put the marker in the cup"}
        )
        rng = np.random.default_rng(0)
        session.set_frames({
            name: rng.integers(0, 256, (360, 640, 3), dtype=np.uint8)
            for name in TRACKS
        })
        request = {
            "proprio": [0.0, -0.6, 0.0, -2.2, 0.0, 1.6, 0.8, 0.0],
            "chunk_id": 1,
            "seed": 1,
        }
        await session.send("set_state_json", {"state_json": json.dumps(request)})
        reply = await session.next_message("action_prediction", timeout_s=90)
        actions = np.asarray(reply["actions"], dtype=np.float64)
        assert reply["step"] == request["chunk_id"]
        assert actions.shape == (32, 8) and np.isfinite(actions).all()
        assert reply["checkpoint"] == selected
        print("checkpoint:", selected, "actions:", actions.shape)
    finally:
        await session.close()


asyncio.run(main())
```

Expect a checkpoint name and `actions: (32, 8)`. The repeating publisher supplies post-request
frames; it does not simulate a moving robot. To compare checkpoints, run separate sessions and
select each desired value from `available` before sending state.

Next, [build a simulator adapter](/robotics/flux-action/droid/simulation) or use the
[integration guide](/robotics/flux-action/droid/integration) with your robot client.


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