> ## Documentation Index
> Fetch the complete documentation index at: https://docs.livepeer.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Workload Options

> The four job types an orchestrator can process – transcoding, batch AI inference, Cascade live-video AI, and LLM inference – with hardware requirements, pricing models, routing mechanics, and how to choose which workloads to run.

export const CustomDivider = ({color = "var(--lp-color-border-default)", middleText = "", spacing = "default", style = {}, className = "", ...rest}) => {
  const spacingPresets = {
    default: {
      margin: "24px 0"
    },
    overlap: {
      margin: "-1rem 0 -1rem 0"
    },
    tight: {
      margin: "0 0 -1rem 0"
    },
    section: {
      margin: "0 0 -2rem 0"
    },
    sectionOverlap: {
      margin: "-1rem 0 -2rem 0"
    },
    deepOverlap: {
      margin: "-1rem 0 -1.5rem 0"
    }
  };
  const spacingStyle = spacingPresets[spacing] || spacingPresets.default;
  return <div role="separator" aria-orientation="horizontal" className={className} style={{
    display: "flex",
    alignItems: "center",
    ...spacingStyle,
    fontSize: style?.fontSize || "16px",
    height: "fit-content",
    ...style
  }} {...rest}>
      <span style={{
    marginRight: "var(--lp-spacing-px-8)",
    opacity: 0.2
  }}>
        <Icon icon="/snippets/assets/logos/Livepeer-Logo-Symbol-Theme.svg" />
      </span>
      <div style={{
    flex: 1,
    height: "1px",
    background: "var(--lp-color-border-default)",
    opacity: 0.4
  }}></div>
      {middleText && <>
          <Icon icon="circle" size={2} />
          <span style={{
    margin: "0 8px",
    fontWeight: "bold",
    color: color,
    opacity: 0.7
  }}>
            {middleText}
          </span>
          <Icon icon="circle" size={2} />
        </>}
      <div style={{
    flex: 1,
    height: "1px",
    background: "var(--lp-color-border-default)",
    opacity: 0.4
  }}></div>
      <span style={{
    marginLeft: "var(--lp-spacing-px-8)",
    opacity: 0.2
  }}>
        <span style={{
    display: "inline-block",
    transform: "scaleX(-1)"
  }}>
          <Icon icon="/snippets/assets/logos/Livepeer-Logo-Symbol-Theme.svg" />
        </span>
      </span>
    </div>;
};

export const TableCell = ({children, align = "left", header = false, style = {}, className = "", ...rest}) => {
  const Component = header ? "th" : "td";
  return <Component className={className} style={{
    padding: "0.75rem 1rem",
    textAlign: align,
    border: header ? "none" : "1px solid var(--lp-color-border-default)",
    ...style
  }} {...rest}>
      {children}
    </Component>;
};

export const TableRow = ({children, header = false, hover = false, style = {}, className = "", ...rest}) => {
  const rowId = `table-row-${Math.random().toString(36).substr(2, 9)}`;
  return <>
      {hover && <style>{`
          #${rowId}:hover {
            background-color: var(--lp-color-bg-card);
          }
        `}</style>}
      <tr id={rowId} className={className} style={{
    ...header && ({
      backgroundColor: "var(--lp-color-accent-strong)",
      color: "var(--lp-color-on-accent)",
      fontWeight: "bold"
    }),
    ...style
  }} {...rest}>
        {children}
      </tr>
    </>;
};

export const StyledTable = ({children, variant = "default", style = {}, className = "", ...rest}) => {
  const wrapperVariants = {
    default: {
      border: "1px solid var(--lp-color-border-default)",
      backgroundColor: "var(--lp-color-bg-card)",
      overflow: "hidden"
    },
    bordered: {
      border: "2px solid var(--lp-color-accent)",
      backgroundColor: "var(--lp-color-bg-page)",
      overflow: "hidden"
    },
    minimal: {
      border: "none",
      backgroundColor: "transparent",
      overflow: "visible"
    }
  };
  return <div data-docs-styled-table-shell className={className} style={{
    width: "100%",
    padding: 0,
    margin: 0,
    ...wrapperVariants[variant],
    ...style
  }} {...rest}>
      <table data-docs-styled-table style={{
    width: "100%",
    borderCollapse: "collapse",
    borderSpacing: 0,
    margin: 0,
    backgroundColor: "transparent"
  }}>
        {children}
      </table>
    </div>;
};

Orchestrators on Livepeer earn fees from four distinct categories of work. Each has different GPU requirements, a different pricing model, and a different path for how jobs reach your node. Use this page to compare the workload types, understand their routing logic, and choose the setup path that fits your hardware.

<CustomDivider />

## At a glance

<StyledTable variant="bordered">
  <TableRow header>
    <TableCell header>Job type</TableCell>
    <TableCell header>What it does</TableCell>
    <TableCell header>Min VRAM</TableCell>
    <TableCell header>Pricing unit</TableCell>
    <TableCell header>Configured via</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>**Video Transcoding**</TableCell>
    <TableCell>Converts video streams to multiple resolutions and bitrates</TableCell>
    <TableCell>None (GPU-accelerated via NVENC/NVDEC)</TableCell>
    <TableCell>Wei per pixel of output</TableCell>
    <TableCell>`-pricePerUnit` flag</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>**Batch AI Inference**</TableCell>
    <TableCell>Processes single AI requests – image generation, audio transcription, captioning</TableCell>
    <TableCell>4–24 GB depending on pipeline</TableCell>
    <TableCell>Wei per pixel or per millisecond</TableCell>
    <TableCell>`aiModels.json`</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>**Cascade live-video AI**</TableCell>
    <TableCell>Applies AI to a live video stream frame-by-frame, continuously</TableCell>
    <TableCell>8 GB+ (model-dependent)</TableCell>
    <TableCell>`Per frame / per stream unit`</TableCell>
    <TableCell>`aiModels.json` + ComfyStream</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>**LLM Inference**</TableCell>
    <TableCell>Generates text responses using large language models</TableCell>
    <TableCell>8 GB (quantised 7–8B models)</TableCell>
    <TableCell>Custom token unit</TableCell>
    <TableCell>`aiModels.json` + Ollama runner</TableCell>
  </TableRow>
</StyledTable>

<CustomDivider />

## How routing works – and why it differs per job type

The routing mechanics differ significantly by job type. Understanding this is the key insight for operators deciding which workloads to prioritise.

### Video transcoding

Transcoding jobs are routed by Gateways using a multi-factor algorithm: **stake weight + price + performance score**. Gateways favour Orchestrators with more total stake (own + delegated), competitive pricing, and high historical success rates.

This means **new or low-stake Orchestrators are at a structural disadvantage for transcoding** – they compete against established nodes with large Delegator bases. Being in the Active Set (top 100 by stake) is a prerequisite, and even within the Active Set, high-stake nodes capture disproportionate transcoding volume.

### Batch AI inference

AI jobs route on **capability match + price ceiling**. The Gateway checks: does this Orchestrator support the requested pipeline and model? Is the price below the Gateway's `-maxPricePerCapability` limit? Stake plays a much smaller role.

This matters for operators: **a new Orchestrator with 24 GB VRAM and correctly configured AI pipelines competes for AI jobs immediately**, regardless of stake. The barrier to entry for AI earnings is hardware and configuration, with delegation history playing a much smaller role.

### Cascade live-video AI

Routing adds **latency** as a primary factor alongside capability and price. Persistent streaming jobs cannot tolerate high jitter or cold model loads, so Gateways select Orchestrators with the right workflow already warm and with low round-trip latency. Geographic proximity to Gateways matters here.

### LLM inference

Routes the same way as batch AI through capability match and price. The capability check targets a specific Ollama model ID instead of a diffusion pipeline. Operators running quantised 7B models on 8 GB cards receive LLM jobs without competing on the same axis as GPU-heavy diffusion operators.

<Note>
  **The practical upshot:** Low-stake nodes still earn AI fees while transcoding demand stays concentrated in higher-stake nodes. A capable GPU plus sound AI configuration is the faster route to active earnings.
</Note>

<CustomDivider />

## Video transcoding

Transcoding has been the Livepeer Network's core workload since 2017. When a broadcaster sends a live video stream to a Gateway, the Gateway routes individual segments – roughly 2 seconds each – to Orchestrators for conversion into multiple resolution and bitrate variants. Your node receives raw video, decodes it (NVDEC), re-encodes it to the requested output profiles (NVENC), and returns the results.

Sessions often run for hours. Your node processes dozens or hundreds of segments per active stream. GPU-accelerated transcoding via NVIDIA hardware is strongly recommended – CPU transcoding remains viable for tests but rarely stays cost-competitive at current network prices.

<Card title="Video Transcoding Guide" icon="film" href="/v2/orchestrators/guides/ai-and-job-workloads/video-transcoding-operations">
  Pricing configuration (wei and USD), session limits, NVENC caps, output rendition profiles, and benchmarking your setup.
</Card>

<CustomDivider />

## Batch AI inference

The AI Subnet launched in Q3 2024, adding single-request inference as a job category alongside transcoding. A batch AI job arrives as an HTTP request routed from a Gateway to your `ai-runner` Docker container. The container runs inference – generating an image, captioning a photo, transcribing audio – and returns the result. The session ends when the result is returned.

**The nine current pipelines:**

<StyledTable variant="bordered">
  <TableRow header>
    <TableCell header>Pipeline</TableCell>
    <TableCell header>What it produces</TableCell>
    <TableCell header>Min VRAM</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>`text-to-image`</TableCell>
    <TableCell>Image from text prompt</TableCell>
    <TableCell>24 GB</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>`image-to-image`</TableCell>
    <TableCell>Transformed image from input + prompt</TableCell>
    <TableCell>24 GB</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>`image-to-video`</TableCell>
    <TableCell>Short video clip from input image</TableCell>
    <TableCell>24 GB</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>`image-to-text`</TableCell>
    <TableCell>Caption or description of an image</TableCell>
    <TableCell>4 GB</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>`audio-to-text`</TableCell>
    <TableCell>Transcript from audio file</TableCell>
    <TableCell>12 GB</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>`upscale`</TableCell>
    <TableCell>High-resolution image from low-resolution input</TableCell>
    <TableCell>Model-dependent</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>`segment-anything-2`</TableCell>
    <TableCell>Segmentation masks from image</TableCell>
    <TableCell>6 GB</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>`text-to-speech`</TableCell>
    <TableCell>Speech audio from text</TableCell>
    <TableCell>Model-dependent</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>`llm`</TableCell>
    <TableCell>Text completion and chat (via Ollama runner)</TableCell>
    <TableCell>8 GB</TableCell>
  </TableRow>
</StyledTable>

For warm model recommendations and per-pipeline pricing guidance, see [AI Pipelines](/v2/Orchestrators/guides/ai-and-job-workloads/ai-inference-operations) and the [Model and VRAM Reference](/v2/Orchestrators/guides/ai-and-job-workloads/model-demand-reference).

<CardGroup cols={2}>
  <Card title="Batch AI Setup" icon="robot" href="/v2/orchestrators/guides/ai-and-job-workloads/diffusion-pipeline-setup">
    Install and configure the ai-runner container, aiModels.json, warm models, and pipeline pricing.
  </Card>

  <Card title="Model and VRAM Reference" icon="table" href="/v2/orchestrators/guides/ai-and-job-workloads/model-demand-reference">
    Per-pipeline VRAM requirements, recommended models, and pricing benchmarks.
  </Card>
</CardGroup>

<CustomDivider />

## Cascade live-video AI

Cascade live-video AI is architecturally distinct from batch inference. Instead of processing a single request and returning a result, your GPU is allocated to a **persistent, continuous stream** that receives live video frames, runs inference on each frame, and returns the transformed stream.

Cascade is the network's strategic name for live-video AI. The underlying technical implementation is [ComfyStream](https://github.com/livepeer/comfystream), which runs ComfyUI as an inference backend and applies ComfyUI workflows to live video frames. Cascade Phase 1 shipped in December 2024, and ComfyStream integrated with Livepeer Network payments in January 2025.

The latency constraint is what separates this from batch inference: a 30 fps video stream must process each frame in roughly 33 ms or less. This drives both hardware requirements – faster GPUs, more VRAM for resident tensors – and configuration requirements: the ComfyUI workflow must be compiled and warm throughout the stream.

Current use cases on the network include live avatar generation, style transfer overlays, live-video agents, and AI-enhanced scene analysis.

<Card title="Cascade Setup" icon="video" href="/v2/orchestrators/guides/ai-and-job-workloads/realtime-ai-setup">
  ComfyStream setup, workflow configuration, latency requirements, and troubleshooting.
</Card>

<CustomDivider />

## LLM inference

The LLM pipeline serves large language model inference - text completion, chat, and instruction-following - through an Ollama-based runner built by the Cloud SPE. Diffusion pipelines use the standard `ai-runner` Docker image, while LLM inference uses a separate `livepeer-ollama-runner` container.

Quantised LLMs are VRAM-efficient. A 4-bit quantised 7B model fits into 8 GB of VRAM and runs on hardware in the GTX 1080 / RTX 2060 class – machines that are too memory-constrained for most diffusion pipelines. This makes LLM inference the practical AI entry point for operators with older consumer GPUs.

The Ollama catalogue is broad. Start with a network-tested model such as `meta-llama/Meta-Llama-3.1-8B-Instruct`.

LLM jobs route via capability match and price, the same as batch AI. Hardware fit and configuration determine the primary advantage here.

<CustomDivider />

## What should I run?

Match your hardware to the workloads that fit. Focused coverage beats trying to run every workload poorly.

<AccordionGroup>
  <Accordion title="8–12 GB VRAM  -  entry-level GPU (GTX 1080, RTX 2060, 3060)" icon="server">
    The diffusion pipelines that drive most AI fee volume require 16–24 GB. Your best options:

    * **Transcoding** – modern NVIDIA GPUs handle video transcoding sessions competitively; NVENC session caps on consumer cards still apply. Active-set operators use transcoding as baseline earnings.
    * **LLM inference** – quantised 7–8B models run well at 8 GB. Low barrier to entry for AI earnings.
    * **`image-to-text`, `segment-anything-2`** – the two AI pipelines with sub-8 GB requirements. Lower fee volume than diffusion, but feasible on these cards.

    Skip: `text-to-image`, `image-to-image`, `image-to-video`, `audio-to-text` – all require 12–24 GB minimum.
  </Accordion>

  <Accordion title="16 GB VRAM  -  mid-range (RTX 3080, 4080, A4000)" icon="server">
    This tier supports the full batch AI suite except the most VRAM-heavy diffusion models:

    * **Transcoding** + **batch AI** (most pipelines)
    * `audio-to-text` (12 GB), `image-to-text` (4 GB), `segment-anything-2` (6 GB) all fit comfortably
    * `text-to-image` with smaller Lightning / Turbo variants (some fit at 16 GB)
    * **LLM inference** with 13B quantised models
    * **Cascade live-video AI** – lightweight workflows fit at 16 GB; heavier SDXL-based workflows stay tight

    Prioritise: get batch AI earning first on the lower-VRAM pipelines, then experiment with which diffusion models fit.
  </Accordion>

  <Accordion title="24 GB VRAM  -  high-end (RTX 3090, 4090, A5000, A6000)" icon="server">
    A 24 GB card runs the full suite:

    * **Transcoding** – full output ladder, higher `maxSessions`
    * **Full batch AI** – all pipelines including `text-to-image`, `image-to-image`, `image-to-video` with production SDXL models
    * **Cascade live-video AI** – most ComfyStream workflows fit; latency-optimised workloads are feasible
    * **LLM inference** – 13B quantised models comfortably; 70B quantised models require multiple cards

    Strategy: warm your highest-fee pipeline (`text-to-image` is typically the most sought-after), cold the rest. See [Model and VRAM Reference](/v2/Orchestrators/guides/ai-and-job-workloads/model-demand-reference) for per-pipeline earnings guidance.
  </Accordion>

  <Accordion title="Multiple GPUs or data-centre class" icon="server">
    * Pool architecture – route jobs across multiple workers, each on separate GPUs
    * Different GPUs serve different pipelines simultaneously (assign per-GPU in `aiModels.json`)
    * Fleet operations for multi-machine deployments
    * Cascade becomes highly competitive with dedicated GPU per stream

    See [Run a Pool](/v2/Orchestrators/guides/advanced-operations/pool-operators) and [Fleet Operations](/v2/Orchestrators/guides/advanced-operations/scale-operations).
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Setup guides

<CardGroup cols={2}>
  <Card title="Video Transcoding" icon="film" href="/v2/orchestrators/guides/ai-and-job-workloads/video-transcoding-operations">
    Configure pricing, session limits, and NVENC settings for transcoding.
  </Card>

  <Card title="AI Workloads Overview" icon="robot" href="/v2/orchestrators/guides/ai-and-job-workloads/ai-inference-operations">
    Pipeline overview, aiModels.json, warm model strategy.
  </Card>

  <Card title="Batch AI Setup" icon="layer-group" href="/v2/orchestrators/guides/ai-and-job-workloads/diffusion-pipeline-setup">
    Install the ai-runner and configure your first AI pipeline.
  </Card>

  <Card title="Cascade Setup" icon="video" href="/v2/orchestrators/guides/ai-and-job-workloads/realtime-ai-setup">
    ComfyStream setup for live video AI workloads.
  </Card>
</CardGroup>