> ## 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; The launch policies are Cosmos Nano DROID (/robotics/cosmos/nano-policy-droid/), DreamZero DROID (/robotics/dreamzero/droid/), and FLUX Action DROID (/robotics/flux-action/droid/), organized by model family and embodiment. 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.

# Streamed Sessions

> The default session type. The model generates continuously and streams live video and audio to your app

## What is a streamed session?

A streamed session runs the model continuously and plays its output to your app in real time, as
live video and audio. It is the default of the two
[session types](https://docs.reactor.inc/concepts/sessions#session-types), and the one you get unless you ask for a
[stepped session](https://docs.reactor.inc/concepts/sessions/stepped.md).

Every model runs as a loop of **steps**. In a streamed session the model drives that loop on its
own: once the session is `ready`, it runs step after step, and each step's frames go out on the
model's output tracks as soon as they are produced. Your app does not request frames. It steers the
model while it runs.

## When to use it

Use a streamed session for anything a person watches or plays live:

* **Interactive video and worlds.** A user steers the model with controls, prompts, or a camera, and
  sees the result immediately.
* **Live transformation.** Your app streams a camera or screen into the model and shows what comes
  back.
* **Viewers and multiplayer.** Several
  [connections](https://docs.reactor.inc/concepts/sessions#multiple-connections-per-session) watch, and steer, one running
  model.

If you need to know exactly which input produced which output, or want frames as arrays rather than
a video stream, use a [stepped session](https://docs.reactor.inc/concepts/sessions/stepped.md) instead.

## How it works

| Part | In a streamed session |
| - | - |
| **Output** | The model's frames arrive on its output [tracks](https://docs.reactor.inc/concepts/tracks.md#output-tracks-model-to-app), over WebRTC. Render them or read them. |
| **Input media** | Your app publishes live media on the model's [input tracks](https://docs.reactor.inc/concepts/tracks.md#input-tracks-app-to-model): a camera, a screen, or frames you push. |
| **Commands** | [Commands](https://docs.reactor.inc/concepts/commands-and-messages.md) change the model's state while it runs. The steps after a command use the new state. |
| **Messages** | The model sends [messages](https://docs.reactor.inc/concepts/commands-and-messages.md) whenever it has something to report, alongside the media. |
| **Frame rate** | Playback is paced to the model: at the frame rate it sets, or at the rate it actually generates. |
| **Frame metadata** | Tag an input frame and read the tag back on the output it produced. See [Frame metadata](https://docs.reactor.inc/concepts/frame-metadata.md). |
| **Recordings** | Ask for [clips](https://docs.reactor.inc/concepts/recordings.md) of the live session as MP4. A model on `reactor-runtime` 3.11.8 or later records by default. |

The model does not wait for your app. A command changes what the model generates from the next step
on, not a particular frame. If you need to change the prompt or controls between two specific steps,
use a stepped session.

## Starting a streamed session

You don't need to ask for a streamed session: every session is streamed unless your app asks for a
stepped one. Connect as usual, and media starts flowing once the connection reaches `ready`.

```typescript JavaScript theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
import { Reactor } from "@reactor-team/js-sdk";

const reactor = new Reactor({ modelName: "your-model-name" });
await reactor.connect(jwt);
```

```python Python theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
from reactor_sdk import Reactor

reactor = Reactor("your-model-name", api_key=api_key)
await reactor.connect()
```

See the [Quickstart](https://docs.reactor.inc/quickstart.md) for a full example that renders the model's video and sends a
command.

## Next steps

> [card] [Tracks](https://docs.reactor.inc/concepts/tracks.md)
>
> Receive the model's live media and publish your own.

> [card] [Commands & Messages](https://docs.reactor.inc/concepts/commands-and-messages.md)
>
> Steer the model while it runs and handle what it sends back.

> [card] [Recordings](https://docs.reactor.inc/concepts/recordings.md)
>
> Save clips of a live session.

> [card] [Stepped sessions](https://docs.reactor.inc/concepts/sessions/stepped.md)
>
> Run one step per request instead of a live stream.


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