> ## 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 one LingBot-VA LIBERO chunk using synthetic camera observations.

Request one LIBERO 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_lingbot_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_lingbot_actions.py
```

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

import numpy as np
from reactor_robotics.lingbot_va import VIEWS
from reactor_robotics.session import ReactorSession


async def main():
    session = ReactorSession("reactor/lingbot-va", fps=20, frame_size=(128, 128))
    try:
        await session.connect(VIEWS, subscribe=("action_prediction",))
        session.set_frames({view: np.zeros((128, 128, 3), dtype=np.uint8) for view in VIEWS})
        await asyncio.sleep(0.3)
        await session.send("set_executed_action_json", {"executed_action_json": ""})
        await session.send("reset", {"sampling_seed": 42})
        started = time.perf_counter()
        await session.send("set_task_description", {"task_description": "Put the bowl on the plate."})
        reply = await session.next_message("action_prediction", timeout_s=120)
        actions = np.asarray(reply["action"], dtype=np.float64)
        assert reply["step"] == 0
        assert actions.shape == (16, 7)
        assert np.isfinite(actions).all()
        executable = actions[4:]
        print("action shape:", actions.shape)
        print("executable shape:", executable.shape)
        print("first predicted row:", executable[0])
        print("task-to-reply ms:", round((time.perf_counter() - started) * 1000, 1))
    finally:
        await session.close()


asyncio.run(main())
```

Expect `action shape: (16, 7)` and `executable shape: (12, 7)`. The first four rows are conditioning
slots, not predicted motion. Synthetic images check connectivity and reply shape; do not execute the
outputs on hardware.

The example starts a fresh session and sets the task after reset, preventing an earlier task from
triggering a seed chunk. Timing excludes connection setup and the 300 ms frame wait. A fixed
sampling seed does not fix video delivery or observation timing.

Next, [run LIBERO](/robotics/lingbot-va/libero/simulation) or follow the
[execution protocol](/robotics/lingbot-va/libero/reference#advance-the-loop) in your own
integration.


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