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

# EdenLive overview

> Create high-fidelity interactive worlds from a low-fidelity 3D scene.

export const ModelRate = ({model, fallback = "View pricing"}) => {
  const [data, setData] = useState(null);
  const [error, setError] = useState(false);
  const [loading, setLoading] = useState(true);
  useEffect(() => {
    const ctrl = new AbortController();
    fetch("https://api.reactor.inc/pricing", {
      signal: ctrl.signal
    }).then(r => {
      if (!r.ok) throw new Error(`HTTP ${r.status}`);
      return r.json();
    }).then(json => {
      setData(json);
      setLoading(false);
    }).catch(err => {
      if (err.name === "AbortError") return;
      setError(true);
      setLoading(false);
    });
    return () => ctrl.abort();
  }, []);
  if (loading) {
    return <span aria-label="loading pricing" className="inline-block h-4 w-28 rounded bg-zinc-950/10 dark:bg-white/10 animate-pulse align-middle" />;
  }
  const creditsPerDollar = data?.settings?.credits_per_dollar;
  const rate = data?.models?.find(m => m.name === model)?.rate;
  const amountPerMin = typeof rate?.amount_per_min === "number" ? rate.amount_per_min : typeof rate?.amount_per_sec === "number" ? rate.amount_per_sec * 60 : undefined;
  const canRender = !error && creditsPerDollar && typeof amountPerMin === "number";
  if (!canRender) {
    return fallback === "View pricing" ? <a href="/resources/billing">View pricing</a> : <span className="text-zinc-950/60 dark:text-white/60">{fallback}</span>;
  }
  const perMin = (amountPerMin / creditsPerDollar).toFixed(3);
  return <span>
      <strong>${perMin}/min</strong>
    </span>;
};

**EdenLive**, from VAST, is a real-time world model that creates high-fidelity interactive worlds
from a low-fidelity 3D scene. Build a simple environment in Three.js or another 3D engine, then send
its rendered video to EdenLive with a reference image and a text prompt. EdenLive uses the reference
and prompt to generate the world's appearance as you move through the scene. Your rendered video
guides the layout, camera, and motion.

Your app controls the geometry, movement, camera, and physics. It also keeps the game rules, health,
and score. The model returns generated video. A scene made from colored cubes and other primitives
can guide a detailed environment in the visual style you choose. To try it first, use one of the
seven built-in games that EdenLive runs for you.

## At a glance

| Spec | Value |
| - | - |
| **Model name** | `reactor/eden-live` |
| **Pricing** | <ModelRate model="eden-live" /> |
| **Input** | A built-in game or your own video feed, one reference image, and a text prompt |
| **Output** | Generated video (`main_video`) and a preview of the source frames (`draft_video`) |

Use `reactor/eden-live` when you open a session. See [Pricing & Billing](/resources/billing).

## Key features

<CardGroup cols={3}>
  <Card title="Scene consistency" icon="gamepad-2">
    Use your 3D scene to guide consistent object placement and camera movement in the generated
    world. The engine keeps landmarks in place as you explore.
  </Card>

  <Card title="Art-directed environments" icon="image">
    Pair the scene with a reference image and prompt to choose its materials, lighting, and visual
    style.
  </Card>

  <Card title="Live visual changes" icon="sliders-horizontal">
    Update the prompt or switch video sources while the world keeps its visual history.
  </Card>
</CardGroup>

## Quick start

Install the published typed SDK in your app:

```shell theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
pnpm add @reactor-models/eden-live
```

Then connect, pick a built-in game, and start a world. Your server issues the token; see
[Authentication](/authentication).

```typescript theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
import { EdenLiveModel } from "@reactor-models/eden-live";

const eden = new EdenLiveModel();
eden.onMainVideo((_track, stream) => (worldVideo.srcObject = stream)); // Your <video> element.

await eden.connect(await getToken());
await eden.selectGame({ game: "freeze" });
await eden.start({});
```

The [tutorial](/model-api-reference/eden-live/tutorial) adds controls and game status, then streams
your own game.

## How it works

1. Connect to `reactor/eden-live`, publish your rendered scene as `source_video`, and call
   `set_source({ source: "client" })`. Sessions default to the built-in `game` source.
2. Upload a reference image and set a prompt. Until you call `start`, both outputs show the staged
   reference. Call `start` to create the world.
3. Play the generated `main_video` while your app handles movement and physics. Compare it with
   `draft_video`, which shows the source frames used for generation.
4. Update the prompt with `set_prompt` to steer the next generated chunk. The current reference
   image and visual history stay in use, so changes can be gradual.
5. Pause or resume the same world with `set_paused`. The `state_update` message reports the complete
   session state.

Seven built-in games are available as an alternate video source. Steer them with held keys
(`set_keys`) and a mouse-look rate (`set_look`). Each `state_update` reports the game's state,
health, events, and outcome. See the [schema](/model-api-reference/eden-live/schema) for commands
and lifecycle details.

<Note>
  Calling `start` creates a new world. Both `select_game` and `set_image` require a paused world and
  end it, so call `start` after either command.
</Note>


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