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

# Register a model

> Registers a new model owned by your account. Callable by an `account_admin` or `developer`
when model serving is enabled for your account. The CLI equivalent is
`reactor model register`.

`model.name` is `<org>/<name>`, where `<org>` is your account's slug, or a bare `<name>`,
which is placed under your account's slug. Your account must have a slug. Names are unique
within an account, and a deleted model keeps its name reserved.

New models are private. A customer cannot make a model public; contact Reactor for that.

`status` is an integer on this request (`1` active, `2` deprecated, `3` disabled; default
active), while every response returns it as a lowercase string. `gpu_type` takes a string
name from `GET /gpu_types`.




## OpenAPI

````yaml /openapi.yaml post /models
openapi: 3.1.0
info:
  title: Reactor Platform API
  version: '1'
  description: >
    The Reactor Platform API mints session tokens, starts and operates sessions,
    negotiates media

    transport, and manages your account, models, and deployments. Every path is
    relative to

    `https://api.reactor.inc`. See the
    [Introduction](/platform-api/introduction) and

    [Authentication](/platform-api/authentication) pages for credentials,
    versioning, and errors.
  contact:
    name: Reactor support
    url: https://docs.reactor.inc/resources/support
servers:
  - url: https://api.reactor.inc
    description: Production
security:
  - apiKey: []
tags:
  - name: Status
    description: >-
      Public, unauthenticated endpoints for service health, pricing, and the
      values the API accepts.
  - name: Tokens
    description: >
      Exchange a long-lived API key for a short-lived, session-scoped token that
      a client can use

      to create and operate sessions without holding the key.
  - name: Users
    description: >
      Read your own user record, your account's roster, and account memberships,
      and manage

      member roles as an account admin.
  - name: API Keys
    description: >-
      Revoke API keys. Use the [Dashboard](https://reactor.inc/dashboard) to
      list or create keys. The CLI can also create a key with `reactor auth
      login`.
  - name: Sessions
    description: >
      Create, inspect, and end sessions. A session holds one running model for
      one client

      application; media and messages flow over a transport you attach to it
      afterwards.
  - name: Transport
    description: >
      Attach a client to a session. WebRTC signaling carries ICE servers, SDP,
      and ICE candidates;

      a LiveKit room connection lets the session join a room you host.
  - name: Files
    description: >
      Upload files a model reads, either for one running session or ahead of
      time for sessions you

      have not started yet.
  - name: Recordings
    description: >
      Fetch the recorded video of a session as an HLS playlist, during the
      session or after it ends.
  - name: Accounts
    description: >
      Read and manage the account your credential acts in: its name and slug,
      its credit

      balance, its effective quotas, and its accelerator capacity.
  - name: Invitations
    description: >
      Invite people to your account by email, and manage pending invitations.
      The recipient

      accepts from the emailed link while signed in to the dashboard.
  - name: Usage
    description: >
      List the sessions your account has run, filter them by status, date,
      model, or API key,

      and read exact session totals for a date window.
  - name: Models
    description: >
      Register, read, update, and delete the models your account serves, and
      list the models you can

      use. The `reactor model` CLI commands are built on these endpoints.
  - name: Releases
    description: >
      Register a model's versioned releases, push their container image, and
      deploy a release with a

      per-region instance plan.
  - name: Model Weights
    description: >
      Upload and inspect the weights bundle of a release: single-request
      uploads, multipart uploads

      for large files, and the server-side finalize that marks a bundle
      complete.
  - name: Model Schemas
    description: >
      Attach an OpenAPI schema to a release that describes the model's commands,
      messages, and

      tracks. Schemas of public models are readable without credentials.
  - name: Model Access
    description: |
      Share a private model with other accounts, one environment at a time.
  - name: Projects
    description: >
      A project is the deploy identity of a model you serve on Reactor. Each
      model is one

      project, with its own UUID. Creating a project also creates its
      `production` environment.
  - name: Environments
    description: >
      An environment is a named deploy target of a project, such as `production`
      or `staging`.

      Each write to an environment creates its next revision, and the newest
      revision is what the

      environment runs. Environment access grants let another account start
      sessions on one

      environment.
  - name: Revisions
    description: >
      A revision is an immutable, numbered snapshot of one environment: its
      model image, weights,

      resources, instances, and variables. An environment's revisions, newest
      first, are its change

      log.
  - name: Images
    description: >
      Model images are the container images pushed to your model's repository,
      named by digest.

      Experimental: this API can change without notice.
  - name: Weight Sets
    description: >
      A weight set is a version-2 weights bundle, named by its set digest. Push
      the files, then put

      the manifest. Available when weight sets are enabled for your account.
      Experimental: this API

      can change without notice.
  - name: Tags
    description: >
      A tag is a movable name on one model image or one weight set of a project.
      A release of the

      model is a read-only tag. Experimental: this API can change without
      notice.
paths:
  /models:
    post:
      tags:
        - Models
      summary: Register a model
      description: >
        Registers a new model owned by your account. Callable by an
        `account_admin` or `developer`

        when model serving is enabled for your account. The CLI equivalent is

        `reactor model register`.


        `model.name` is `<org>/<name>`, where `<org>` is your account's slug, or
        a bare `<name>`,

        which is placed under your account's slug. Your account must have a
        slug. Names are unique

        within an account, and a deleted model keeps its name reserved.


        New models are private. A customer cannot make a model public; contact
        Reactor for that.


        `status` is an integer on this request (`1` active, `2` deprecated, `3`
        disabled; default

        active), while every response returns it as a lowercase string.
        `gpu_type` takes a string

        name from `GET /gpu_types`.
      operationId: createModel
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ModelCreateRequest'
            examples:
              gpuModel:
                summary: A GPU model
                value:
                  model:
                    name: your-org/your-model
                  description: Real-time video model
                  is_gpu: true
                  gpu_type: NVIDIA_H100
                  gpu_count: 1
              multiSession:
                summary: A multi-session model with workers
                value:
                  model:
                    name: your-org/your-model
                  is_gpu: true
                  gpu_type: NVIDIA_H100
                  gpu_count: 1
                  cpu_request: '4'
                  memory_request: 32Gi
                  workers:
                    count: 4
                    cpu:
                      request: '1'
                      limit: '2'
                    memory:
                      request: 2Gi
                      limit: 4Gi
                    shared_memory:
                      input: 1Mi
                      output: 24Mi
      responses:
        '201':
          description: >-
            The model was created. The body is the model detail, without
            `project_id`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ModelDetail'
              example:
                id: 7b3f1bc2-a4e5-4d78-b9c1-0e6c2f9a1d34
                account_id: 8c8b7e12-a4c1-4627-b0a0-5d2e9f3a7b61
                account: Your Org
                name: your-org/your-model
                description: Real-time video model
                status: active
                is_public: false
                is_gpu: true
                gpu_type: NVIDIA_H100
                gpu_count: 1
                created_at: '2025-05-11T21:46:40Z'
                updated_at: '2025-05-11T21:46:40Z'
        '400':
          description: >
            The body is invalid: `model.name` is missing or malformed,
            `display_name` or a top-level

            `name` is present, `gpu_type` is unknown, `is_gpu` is `true` with no
            `gpu_type`, a

            resource quantity is malformed or below its request, or `workers`
            breaks a rule (the

            message names the field).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          description: >
            Your role may not register models, model serving is not enabled for
            your account

            (`serve access is not enabled for this account`), your account has
            no slug, `<org>`

            is not your account's slug, or the request sets `is_public: true`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '409':
          description: >
            The name is taken in your account. `error` is `model_name_taken` (a
            live model holds

            it) or `model_name_tombstoned` (a deleted model still reserves it).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '429':
          description: The CPU or memory request exceeds your account's per-model quota.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '503':
          $ref: '#/components/responses/ServiceUnavailable'
components:
  schemas:
    ModelCreateRequest:
      type: object
      required:
        - model
      properties:
        model:
          type: object
          required:
            - name
          properties:
            name:
              type: string
              description: >-
                `<org>/<name>` with your account slug as `<org>`, or a bare
                `<name>`.
              example: your-org/your-model
        description:
          type: string
          description: Human-facing description.
        status:
          type: integer
          enum:
            - 1
            - 2
            - 3
          default: 1
          description: >-
            Initial status as an integer: `1` active, `2` deprecated, `3`
            disabled. Responses return the lowercase string.
        is_public:
          type: boolean
          default: false
          description: Must be `false` or omitted; a customer cannot create a public model.
        is_gpu:
          type: boolean
          default: false
          description: Whether the model needs a GPU. With `true`, `gpu_type` is required.
        gpu_type:
          type: string
          description: >-
            An accelerator name from `GET /gpu_types`. Integer values are
            refused.
          example: NVIDIA_H100
        gpu_count:
          type: integer
          minimum: 0
          description: GPUs per instance. Some types allow only `1`.
        extra_args:
          type: array
          items:
            type: string
          description: Extra command-line arguments passed to the model container.
        cpu_request:
          type: string
          description: >-
            CPU request of the model container, such as `4`. Defaults apply when
            omitted.
        cpu_limit:
          type: string
          description: CPU limit; must be at least `cpu_request`.
        memory_request:
          type: string
          description: Memory request, such as `32Gi`.
        memory_limit:
          type: string
          description: Memory limit; must be at least `memory_request`.
        workers:
          $ref: '#/components/schemas/ModelWorkers'
    ModelDetail:
      type: object
      description: The full view of a model, for its owner.
      required:
        - id
        - name
        - status
        - is_public
        - is_gpu
        - created_at
        - updated_at
      properties:
        id:
          type: string
          format: uuid
        account_id:
          type: string
          format: uuid
          description: The owning account.
        account:
          type: string
          description: The owning account's name.
        name:
          type: string
          example: your-org/your-model
        description:
          type: string
        status:
          $ref: '#/components/schemas/ModelStatus'
        is_public:
          type: boolean
        is_gpu:
          type: boolean
        gpu_type:
          type: string
          example: NVIDIA_H100
        gpu_count:
          type: integer
        extra_args:
          type: array
          items:
            type: string
        cpu_request:
          type: string
          example: '4'
        cpu_limit:
          type: string
        memory_request:
          type: string
          example: 32Gi
        memory_limit:
          type: string
        workers:
          $ref: '#/components/schemas/ModelWorkers'
        pod_total:
          type: object
          readOnly: true
          description: >
            For a model with `workers`: the CPU and memory of one whole
            instance, with defaults

            filled in. This is what your account's per-model quotas are checked
            against.
          properties:
            cpu:
              $ref: '#/components/schemas/ModelQuantityPair'
            memory:
              $ref: '#/components/schemas/ModelQuantityPair'
        created_at:
          type: string
          format: date-time
          description: When it was created, as an RFC 3339 timestamp.
          example: '2026-01-15T10:30:00Z'
        updated_at:
          type: string
          format: date-time
          description: When it was last updated, as an RFC 3339 timestamp.
          example: '2026-01-15T10:30:00Z'
        project_id:
          type: string
          format: uuid
          description: The model's project. Only on `GET /models/{id}`.
    Error:
      type: object
      required:
        - error
      properties:
        error:
          type: string
          description: >-
            A stable error code (for example `not_found`) on newer routes, or a
            sentence on older ones. When `message` is present, branch on
            `error`.
        message:
          type: string
          description: >-
            A human-readable explanation. Do not parse it; its wording may
            change.
        resource:
          type: string
          description: The type of the resource a `not_found` refers to.
        reason:
          type: string
          description: >-
            A more specific cause for `failed_precondition`, `aborted`, and some
            `invalid_request` errors.
    ModelWorkers:
      type: object
      description: >
        Makes the model multi-session: each instance runs one model server,
        which holds the model

        and the GPUs, plus `count` workers, each serving one session. The
        model's own `gpu_*`,

        `cpu_*`, and `memory_*` fields apply to the model server. Omit `workers`
        for one session

        per instance. The CLI sends this from `model.resources.workers` in
        `reactor.yaml`.
      required:
        - count
      properties:
        count:
          type: integer
          minimum: 1
          maximum: 64
          description: Workers per instance.
        cpu:
          allOf:
            - $ref: '#/components/schemas/ModelQuantityPair'
          description: CPU of each worker. Defaults to `500m` request and `2000m` limit.
        memory:
          allOf:
            - $ref: '#/components/schemas/ModelQuantityPair'
          description: >-
            Memory of each worker. Defaults to `1Gi` request and `4Gi` limit.
            The limit must hold 2 × `shared_memory.input`.
        shared_memory:
          type: object
          description: >-
            Sizes of each worker's input and output blocks, in whole bytes
            (`1Mi`, `25165824`). One worker's blocks (2 × input + output) may
            hold at most 16 GiB.
          properties:
            input:
              type: string
              description: Defaults to 1 MiB.
              example: 1Mi
            output:
              type: string
              description: Defaults to 32 MiB.
              example: 24Mi
    ModelStatus:
      type: string
      enum:
        - active
        - deprecated
        - disabled
      description: The model's status, always lowercase in responses.
    ModelQuantityPair:
      type: object
      properties:
        request:
          type: string
          description: A resource quantity such as `500m` or `2Gi`.
        limit:
          type: string
          description: A resource quantity such as `2000m` or `4Gi`.
  responses:
    Unauthorized:
      description: The credential is missing, invalid, or expired.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    ServiceUnavailable:
      description: A dependency is temporarily unavailable. Retry with backoff.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  securitySchemes:
    apiKey:
      type: http
      scheme: bearer
      description: >-
        A Reactor API key (`rk_...`), sent as `Authorization: Bearer rk_...`.
        Keep it on a server.

````

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