> ## Documentation Index
> Fetch the complete documentation index at: https://na-36-changelog-go-livepeer-2026-05-18.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# The Livepeer Developer Landscape

> Explains the relationship between Studio, Daydream, the AI gateway API, ComfyStream, and the raw Livepeer protocol – so you can choose the right layer to build at.

export const CenteredContainer = ({children, maxWidth = "800px", padding = "0", preset = "default", width = "", minWidth = "", marginRight = "", marginBottom = "", textAlign = "", style = {}, className = "", ...rest}) => {
  const presets = {
    default: {},
    fitContent: {
      width: "fit-content",
      minWidth: "fit-content"
    },
    readable70: {
      width: "70%",
      minWidth: "fit-content"
    },
    readable80: {
      width: "80%",
      minWidth: "fit-content"
    },
    readable90: {
      width: "90%"
    },
    wide900: {
      maxWidth: "900px"
    }
  };
  const presetStyle = presets[preset] || presets.default;
  return <div className={className} style={{
    maxWidth: presetStyle.maxWidth || maxWidth,
    margin: "0 auto",
    padding: padding,
    ...presetStyle.width ? {
      width: presetStyle.width
    } : {},
    ...presetStyle.minWidth ? {
      minWidth: presetStyle.minWidth
    } : {},
    ...width ? {
      width
    } : {},
    ...minWidth ? {
      minWidth
    } : {},
    ...marginRight ? {
      marginRight
    } : {},
    ...marginBottom ? {
      marginBottom
    } : {},
    ...textAlign ? {
      textAlign
    } : {},
    ...style
  }} {...rest}>
      {children}
    </div>;
};

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>;
};

export const LinkArrow = ({href, label, description, newline = true, borderColor, className = '', style = {}, ...rest}) => {
  const linkArrowStyle = {
    display: 'inline-flex',
    alignItems: 'center',
    justifyContent: 'center',
    gap: "var(--lp-spacing-1)",
    width: 'fit-content',
    ...borderColor && ({
      borderColor
    })
  };
  return <span className={className} style={style} {...rest}>
      {newline && <br />}
      <span style={linkArrowStyle}>
        <a href={href} target="_blank" rel="noopener noreferrer">
          {label}
        </a>
        <Icon icon="arrow-up-right" size={14} color="var(--lp-color-accent)" />
      </span>
      {description && description}
      {description && <div style={{
    height: "var(--lp-spacing-3)"
  }} />}
    </span>;
};

Livepeer is a decentralised compute network for video and AI – not a single product or API. As a developer, you can access it at multiple layers, from a fully managed hosted API to running your own Gateway node to contributing to the protocol directly. Choosing the right layer before you write any code will save time and rework. Each layer so you can make that choice.

<Note>
  Studio and Daydream are separate products built **on top of** the Livepeer Network. Using Studio or Daydream does not mean you are building on Livepeer directly – you are using hosted services that run on it. This distinction matters when you start thinking about cost, control, and customisation.
</Note>

<CenteredContainer style={{ width: '90%' }}>
  <Tip>The Livepeer GitHub organisation hosts 173 public repositories. This page maps the ones that matter for developers – organised by stack layer, with the role each repo plays and where to start.</Tip>
</CenteredContainer>

<CustomDivider />

Every component of the Livepeer Network is built and maintained in the open. This page covers the repositories most relevant to developers building on, contributing to, or integrating with the Livepeer stack. Repos are grouped by the layer of the stack they belong to, following the same model described in <LinkArrow href="/v2/about/concepts/mental-model" label="The Livepeer mental model" newline={false} />.

Repositories marked **\[Official]** are maintained under the `livepeer/` GitHub organisation. Repositories marked **\[Community]** are maintained by ecosystem contributors outside the org.

For a focused view of OSS contribution paths, see <LinkArrow href="/v2/developers/concepts/oss-stack" label="The OSS stack" newline={false} />.

<CustomDivider middleText="Hosted products" />

## Hosted products

Managed services that abstract protocol and network complexity. No node operation required.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Repo</TableCell>
      <TableCell header>What it does</TableCell>
      <TableCell header>Language</TableCell>
      <TableCell header>Live at</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>[Livepeer/studio](https://github.com/livepeer/studio) \[Official]</TableCell>
      <TableCell>The full Livepeer Studio monolith -- auth, billing, API keys, multistream, recording, signing keys, Prometheus metrics, and the Studio API that the SDKs wrap</TableCell>
      <TableCell>TypeScript</TableCell>
      <TableCell>[Livepeer.studio](https://livepeer.studio)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>Daydream \[Official]</TableCell>
      <TableCell>Hosted real-time AI video API and consumer app. Built on ComfyStream running on the Livepeer AI subnet. The SDK is at `sdk.daydream.monster`.</TableCell>
      <TableCell>-</TableCell>
      <TableCell>[Daydream.live](https://daydream.live)</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider middleText="Application SDKs and UI" />

## Application SDKs and UI

Consume Studio or the AI Gateway API from your application.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Repo</TableCell>
      <TableCell header>What it does</TableCell>
      <TableCell header>Language</TableCell>
      <TableCell header>Role in the stack</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>[livepeer/livepeer-js](https://github.com/livepeer/livepeer-js) \[Official]</TableCell>
      <TableCell>JavaScript/TypeScript SDK for the Livepeer Studio API. Covers stream, asset, access control, metrics, multistream, transcode, and webhook resources. Speakeasy-generated from the OpenAPI spec. Go, Python, Java, Ruby, and PHP variants exist in parallel repos.</TableCell>
      <TableCell>TypeScript</TableCell>
      <TableCell>Application layer -- Studio API consumer</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[livepeer/livepeer-ai-js](https://github.com/livepeer/livepeer-ai-js) \[Official]</TableCell>
      <TableCell>JavaScript/TypeScript SDK for the Livepeer AI Gateway API. Exposes text-to-image, image-to-image, image-to-video, upscale, audio-to-text, and LLM endpoints.</TableCell>
      <TableCell>TypeScript</TableCell>
      <TableCell>Application layer -- AI Gateway consumer</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[livepeer/livepeer-ai-python](https://github.com/livepeer/livepeer-ai-python) \[Official]</TableCell>
      <TableCell>Python SDK for the Livepeer AI Gateway API. Speakeasy-generated. Use for ML workflows and Python-stack applications dispatching inference jobs.</TableCell>
      <TableCell>Python</TableCell>
      <TableCell>Application layer -- AI Gateway consumer (Python)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/ui-kit](https://github.com/livepeer/ui-kit) \[Official]</TableCell>
      <TableCell>React component library providing composable Player and Broadcast primitives. WebRTC/HLS, low-latency, and WAI-ARIA accessibility built in. Independent of the AI and protocol stack.</TableCell>
      <TableCell>TypeScript / React</TableCell>
      <TableCell>Application layer -- React video components</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider middleText="AI Gateway API and developer tooling" />

## AI Gateway API and developer tooling

Direct inference access, operator portals, and identity and billing infrastructure.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Repo / resource</TableCell>
      <TableCell header>What it does</TableCell>
      <TableCell header>Language</TableCell>
      <TableCell header>Live at</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>AI Gateway API \[Official]</TableCell>
      <TableCell>REST API for direct AI inference access on the Livepeer Network. Two hosted providers: the Livepeer Studio Gateway (production) and the Livepeer Cloud Community Gateway (free, for experimentation). No Studio account required for the community Gateway.</TableCell>
      <TableCell>-</TableCell>
      <TableCell>[AI quickstart](/v2/developers/get-started)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/naap](https://github.com/livepeer/naap) \[Official]</TableCell>
      <TableCell>Network as a Platform -- a micro-frontend portal shell for the Livepeer AI Compute Network. Next.js 15 host that loads independent plugins at runtime, each with their own UI, API routes, and PostgreSQL schema. Ships with 12 core plugins. Build and publish your own plugin using `@naap/plugin-sdk`.</TableCell>
      <TableCell>TypeScript</TableCell>
      <TableCell>[operator.livepeer.org](https://operator.livepeer.org) / [docs](https://operator.livepeer.org/docs)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[eliteprox/pymthouse](https://github.com/eliteprox/pymthouse) \[Community]</TableCell>
      <TableCell>Hosted identity, billing, and payment signing infrastructure for Livepeer-powered applications. Full OIDC provider (RFC 8693 token exchange), multi-tenant billing plans (free/subscription/usage-based), and a managed `go-livepeer` remote signer proxy. Open source and self-hostable. Integrates with NaaP's Developer API Manager via OAuth.</TableCell>
      <TableCell>TypeScript</TableCell>
      <TableCell>[pymthouse.com](https://pymthouse.com) / [docs](https://docs.pymthouse.com)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[livepeer/livepeer-data-mcp](https://github.com/livepeer/livepeer-data-mcp) \[Official]</TableCell>
      <TableCell>MCP (Model Context Protocol) server for Livepeer platform data. Enables AI agents and LLM tooling to query network data via the MCP standard. Backed by a ClickHouse data warehouse and dbt semantic models. Internal operations tool, actively stabilising its API surface.</TableCell>
      <TableCell>TypeScript</TableCell>
      <TableCell>Internal / data-mcp.sre.Livepeer.technology</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider middleText="Core runtime" />

## Core runtime

The node binary that implements every network role, and the ingest and media plane layer above it.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Repo</TableCell>
      <TableCell header>What it does</TableCell>
      <TableCell header>Language</TableCell>
      <TableCell header>Role in the stack</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>[livepeer/go-livepeer](https://github.com/livepeer/go-livepeer) \[Official]</TableCell>
      <TableCell>The reference Livepeer node -- implements Orchestrator, Gateway, Transcoder, and Broadcaster roles. When AI inference is enabled, go-livepeer spawns ai-runner Docker containers per GPU and proxies inference requests to them via a local REST interface. Everything else in the stack depends on or connects to this binary.</TableCell>
      <TableCell>Go</TableCell>
      <TableCell>Core runtime -- all stack layers depend on this</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/catalyst](https://github.com/livepeer/catalyst) + [catalyst-api](https://github.com/livepeer/catalyst-api) \[Official]</TableCell>
      <TableCell>Livepeer's decentralised media server. Handles ingest, segment upload to S3/Storj/IPFS, and the network-side media plane. The decentralised successor to MistServer integration.</TableCell>
      <TableCell>Go</TableCell>
      <TableCell>Ingest and media plane above go-livepeer</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/task-runner](https://github.com/livepeer/task-runner) \[Official]</TableCell>
      <TableCell>Background service that executes tasks from the Livepeer Studio API, primarily for VOD processing. Runs alongside Studio in production.</TableCell>
      <TableCell>Go</TableCell>
      <TableCell>Studio operations -- VOD task execution</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider middleText="AI inference and video processing" />

## AI inference and video processing

The containerised runtimes that perform the actual AI and video compute work.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Repo</TableCell>
      <TableCell header>What it does</TableCell>
      <TableCell header>Language</TableCell>
      <TableCell header>Role in the stack</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>[Livepeer/ai-runner](https://github.com/livepeer/ai-runner) \[Official]</TableCell>
      <TableCell>The AI inference runtime. A containerised FastAPI service that loads models into GPU memory and exposes REST endpoints to the go-livepeer AI worker. Defines the production pipeline set: audio-to-text, image-to-image, image-to-text, image-to-video, LLM, segment-anything-2, text-to-image, text-to-speech, upscale, frame-interpolation, and `live_video_to_video` (LV2V -- the pipeline powering Daydream and Storyboard real-time effects). go-livepeer generates its Go client bindings from ai-runner's OpenAPI spec.</TableCell>
      <TableCell>Python</TableCell>
      <TableCell>AI inference -- spawned per job by go-livepeer</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/lpms](https://github.com/livepeer/lpms) \[Official]</TableCell>
      <TableCell>Livepeer media server. Go library providing video processing primitives built on FFmpeg -- transcoding, segment processing, and codec operations. Used internally by go-livepeer for the video transcoding path.</TableCell>
      <TableCell>Go</TableCell>
      <TableCell>Video processing -- transcoding pipeline</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider middleText="Real-time pipeline tooling" />

## Real-time pipeline tooling

Build live-video-to-video workflows and BYOC (Bring Your Own Container) pipelines.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Repo</TableCell>
      <TableCell header>What it does</TableCell>
      <TableCell header>Language</TableCell>
      <TableCell header>Role in the stack</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>[Livepeer/ComfyStream](https://github.com/livepeer/comfystream) \[Official]</TableCell>
      <TableCell>ComfyUI custom node package that turns ComfyUI workflows into a real-time video streaming backend. A workflow that processes images in ComfyUI becomes a live-video-to-video pipeline when run via ComfyStream. Daydream itself is built on ComfyStream. Supports Docker deployment to RunPod, TensorDock, and other GPU providers.</TableCell>
      <TableCell>Python</TableCell>
      <TableCell>Real-time pipeline -- ComfyUI workflows as LV2V backends</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/ComfyUI-Stream-Pack](https://github.com/livepeer/ComfyUI-Stream-Pack) \[Official]</TableCell>
      <TableCell>Suite of custom ComfyUI nodes for building real-time video and audio workflows using ComfyStream. Adds real-time I/O nodes for video, audio, and tensor streaming into ComfyUI's node graph. Use when building custom real-time workflows that go beyond ComfyStream's default pipeline.</TableCell>
      <TableCell>Python</TableCell>
      <TableCell>Real-time pipeline -- ComfyUI real-time I/O nodes</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/pytrickle](https://github.com/livepeer/pytrickle) \[Official]</TableCell>
      <TableCell>Python SDK for the trickle streaming protocol -- the low-latency HTTP-based frame transport used by ComfyStream and BYOC containers. Provides the `FrameProcessor` base class and `StreamServer` HTTP control API. Implement `FrameProcessor` to build a custom BYOC pipeline that plugs directly into the Livepeer AI subnet. Supports up to 60 FPS with async video and audio processing and real-time parameter updates.</TableCell>
      <TableCell>Python</TableCell>
      <TableCell>Transport layer -- trickle protocol SDK for BYOC and ComfyStream</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider middleText="Creative agent tooling" />

## Creative agent tooling

Agent SDKs and frameworks built on top of the full Livepeer compute stack.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Repo</TableCell>
      <TableCell header>What it does</TableCell>
      <TableCell header>Language</TableCell>
      <TableCell header>Role in the stack</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>[Livepeer/storyboard](https://github.com/livepeer/storyboard) \[Official]</TableCell>
      <TableCell>Agent-powered creative workspace live at `storyboard-rust.vercel.app`. Orchestrates 40+ AI models -- text-to-image, image-to-video, talking head, lipsync, 3D, and real-time LV2V -- on an infinite canvas. Ships two reusable packages: `@livepeer/agent` (provider-agnostic agent runtime supporting Gemini, Claude, OpenAI, and a unified Livepeer provider via one Daydream API key) and `@livepeer/creative-kit` (canvas state, command router, capability resolver with automatic model fallback chains, and UI components). Also includes Creative Lab, an educational creative app for children aged 8-16.</TableCell>
      <TableCell>TypeScript</TableCell>
      <TableCell>Creative agent layer -- @livepeer/agent and @livepeer/creative-kit SDKs</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<Note>
  `@livepeer/agent` and `@livepeer/creative-kit` are not yet published to npm. Use the monorepo directly: `git clone https://github.com/livepeer/storyboard.git`.
</Note>

<CustomDivider middleText="On-chain protocol" />

## On-chain protocol

The cryptoeconomic contracts that coordinate the network, deployed on Arbitrum One.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Repo</TableCell>
      <TableCell header>What it does</TableCell>
      <TableCell header>Language</TableCell>
      <TableCell header>Role in the stack</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>[Livepeer/protocol](https://github.com/livepeer/protocol) \[Official]</TableCell>
      <TableCell>Solidity smart contracts governing staking, bonding, reward distribution, on-chain job settlement, and treasury management. Deployed on Arbitrum One (the `confluence` branch is the deployed version). go-livepeer calls these contracts for all on-chain operations. The `streamflow` branch covers the Ethereum L1 contracts (LivepeerToken and BridgeMinter only -- all other core protocol contracts are paused on L1).</TableCell>
      <TableCell>Solidity</TableCell>
      <TableCell>Protocol layer -- all on-chain coordination</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/Arbitrum-LPT-bridge](https://github.com/livepeer/arbitrum-lpt-bridge) \[Official]</TableCell>
      <TableCell>Bridge contracts handling LPT movement between Ethereum L1 and Arbitrum One. Includes L2LPTGateway and L1 Escrow. Required for Delegators and operators moving LPT across layers.</TableCell>
      <TableCell>Solidity / TypeScript</TableCell>
      <TableCell>Protocol layer -- L1 to Arbitrum LPT bridge</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider middleText="Community and governance tooling" />

## Community and governance tooling

Orchestrator operations, analytics, and protocol governance -- mostly community-maintained.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Repo / resource</TableCell>
      <TableCell header>What it does</TableCell>
      <TableCell header>Maintainer</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>[Livepeer/LIPs](https://github.com/livepeer/LIPs) \[Official]</TableCell>
      <TableCell>Livepeer Improvement Proposals. The canonical record of accepted protocol changes. Each LIP is immutable once marked Final.</TableCell>
      <TableCell>Livepeer Foundation</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/coordination](https://github.com/livepeer/coordination) \[Official]</TableCell>
      <TableCell>Async-first governance coordination repo (Oct 2025). Replaces meeting-driven coordination with GitHub-issue-driven async processes. Each team submits sub-issues before scheduled meetings, enabling decision-focused agendas.</TableCell>
      <TableCell>Livepeer Foundation</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/roadmap](https://github.com/livepeer/roadmap) \[Official]</TableCell>
      <TableCell>Community-visible roadmap using GitHub Projects.</TableCell>
      <TableCell>Livepeer Foundation</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[livepeer/livepeer-monitoring](https://github.com/livepeer/livepeer-monitoring) \[Official]</TableCell>
      <TableCell>Prometheus metrics exporters and Grafana dashboard configurations for go-livepeer nodes. The starting point for operator observability stacks.</TableCell>
      <TableCell>Livepeer Inc</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[transcodeninja/livepeer-exporter](https://github.com/transcodeninja/livepeer-exporter) \[Community]</TableCell>
      <TableCell>Enhanced Prometheus exporter for Livepeer Network and Orchestrator metrics. Extends the official monitoring stack with additional signal coverage.</TableCell>
      <TableCell>transcodeninja</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[rickstaa/livepeer-reward-watcher](https://github.com/rickstaa/livepeer-reward-watcher) \[Community]</TableCell>
      <TableCell>Monitors an Orchestrator and alerts when it is at risk of missing a reward call.</TableCell>
      <TableCell>rickstaa</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Stronk-Tech ecosystem](https://stronk.rocks/livepeer) \[Community]</TableCell>
      <TableCell>Suite of community operator tools: OrchestratorTracker, LivepeerPerformanceAI, LivepeerPerformanceTranscoder, LivepeerExplorer, LivepeerStats, StronkAI (jobs dashboard), and the StronkController/StronkLive/StronkPlayer stack.</TableCell>
      <TableCell>Captain Stronk</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>[Livepeer/awesome-Livepeer](https://github.com/livepeer/awesome-livepeer) \[Community-curated]</TableCell>
      <TableCell>Curated list of projects, tutorials, demos, and resources across the Livepeer ecosystem. The community compass for what the network does in production. Also accessible at `livepeer.cool`.</TableCell>
      <TableCell>Community</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider middleText="How the layers connect" />

## How the layers connect

The stack is a dependency chain: every layer above depends on the layers below it, but each layer can be accessed directly without building at the layers above.

* **go-livepeer** is the foundation. Every other official repo either depends on it, generates clients for its APIs, or provides tooling around it.
* **ai-runner** is spawned by go-livepeer per GPU per pipeline. go-livepeer generates its Go client bindings from ai-runner's OpenAPI spec (`make ai_worker_codegen`).
* **ComfyStream and pytrickle** sit above ai-runner on the real-time path. ComfyStream uses pytrickle's trickle protocol to exchange frames with an Orchestrator. A BYOC developer using pytrickle directly implements the same `FrameProcessor` interface that ComfyStream uses internally.
* **The AI Gateway API** is the standard REST interface that all SDK consumers reach through. Calling `livepeer-ai-js` or `livepeer-ai-python` sends requests to a Gateway node, which routes them through go-livepeer to the relevant Orchestrators.
* **storyboard** is at the top of the AI path. It consumes the full stack via the Daydream SDK (`sdk.daydream.monster`), which routes through the AI Gateway API. The `@livepeer/agent` Livepeer provider routes all LLM calls through `/api/llm/chat` -- one Daydream API key drives every model in the stack.
* **livepeer-js and ui-kit** are independent of the AI and protocol path. They are application SDKs for the Studio API (streaming, VOD, asset management). They do not interact with go-livepeer directly.

<CustomDivider />

## Next steps

<CardGroup cols={3}>
  <Card title="OSS stack" icon="code-branch" href="/v2/developers/concepts/oss-stack" arrow horizontal>
    Contribution paths for each repo -- where to start for your first PR.
  </Card>

  <Card title="NaaP plugin development" icon="grid-2" href="/v2/developers/guides/naap" arrow horizontal>
    Build and publish a plugin for the official Livepeer Network portal.
  </Card>

  <Card title="Ecosystem projects" icon="telescope" href="/v2/developers/guides/ecosystem-projects" arrow horizontal>
    Active projects, applications, and tools across the ecosystem.
  </Card>
</CardGroup>

## The Developer Ecosystem at a Glance

| Layer          | What it is                                                       | Best for                                                           | Where to start                                                              |
| -------------- | ---------------------------------------------------------------- | ------------------------------------------------------------------ | --------------------------------------------------------------------------- |
| Studio API     | Hosted video infrastructure (livestream, transcode, VOD, player) | Video streaming apps, media platforms                              | [Studio docs](https://docs.livepeer.studio)                                 |
| Daydream API   | Hosted real-time AI video API, built on Livepeer's AI network    | Real-time AI effects, interactive video, world model apps          | [Daydream docs](https://pipelines.livepeer.org)                             |
| AI Gateway API | Direct REST access to the Livepeer AI inference network          | Custom AI apps, self-hosted cost control, non-Daydream workflows   | [AI quickstart](/v2/developers/get-started/ai-quickstart)                   |
| ComfyStream    | Open-source ComfyUI plugin for real-time AI video pipelines      | Custom AI workflows, VTubing, generative effects, BYOC deployments | [ComfyStream quickstart](/v2/developers/get-started/ComfyStream-quickstart) |
| Protocol layer | go-livepeer, Solidity contracts, ai-worker                       | Contributing to the network, running nodes, custom pipeline types  | [OSS stack](/v2/developers/concepts/oss-stack)                              |

<CustomDivider />

## Studio

Studio is a full-featured, hosted video platform for developers operated by Livepeer Inc. It abstracts the Livepeer Network entirely behind a clean REST API and set of SDKs, giving you live streaming, transcoding, video-on-demand, an embeddable player, webhooks, and usage analytics – without any blockchain or decentralised infrastructure concerns on your end.

Studio is the right choice if your goal is to add video streaming or transcoding to an application and you want a managed service with standard API-key auth, dashboard access, and predictable pricing.

What you give up: you have no control over which Orchestrators process your video, cannot deploy custom AI inference workflows through Studio, and are bound to Studio's feature set instead of the full protocol surface. Costs are lower than traditional cloud providers (up to 80–90% savings) but higher than running your own Gateway at scale.

**SDKs:** TypeScript/JavaScript (`@livepeer/sdk`), Go, Python, and others – [Studio SDK docs](https://docs.livepeer.studio)
**Auth:** API key from the [Studio dashboard](https://livepeer.studio)

[//]: # "REVIEW: Confirm whether Studio exposes any AI endpoints (e.g. Content moderation, clip generation) – if so, the above description needs qualification"

<CustomDivider />

## Daydream

Daydream is an open-source toolkit for world models and real-time AI video, built by Livepeer Inc. It runs on the Livepeer Network for decentralised, low-latency AI inference. It is two related things at once: a consumer app at [Daydream.live](https://daydream.live) where anyone can apply text-prompt-driven AI effects to a live webcam feed, and an API and developer toolkit that you can build on directly.

Daydream is itself built using ComfyStream (Livepeer's open-source ComfyUI plugin – see below). This means the Daydream API is a hosted, managed layer on top of real-time AI pipelines running on Livepeer's GPU network. When you build on the Daydream API, you get the full workflow infrastructure without managing ComfyStream yourself.

Daydream is the right choice if you want to build real-time AI video applications quickly, using Daydream's hosted inference infrastructure, without provisioning GPU compute or managing pipeline deployment.

**Docs:** [pipelines.livepeer.org](https://pipelines.livepeer.org)
**Community:** [Discord – Daydream community](https://discord.gg/livepeer)

[//]: # "REVIEW: Confirm whether the \"Daydream API\" requires a separate account/key from the Studio Gateway, or whether it shares Studio auth. Clarify with Peter or Joseph."

<CustomDivider />

## AI Gateway API

The Livepeer AI Gateway API is the underlying REST API that powers AI inference on the Livepeer Network. Any application can call it directly – you do not need to go through Daydream or Studio to use it. Multiple hosted Gateway providers are available in the ecosystem, including the Livepeer Studio Gateway (production-ready) and the Livepeer Cloud Community Gateway (free, for experimentation).

The API accepts standard JSON over HTTP and supports pipelines including text-to-image, image-to-image, image-to-video, upscaling, audio-to-text, and more. For developers who want full control over which Gateway they use, or who want to self-host a Gateway node for cost savings, this is the direct access path.

<Note>
  Daydream is one product built on the AI Gateway API. If you are using the Daydream API, you are already using the AI Gateway API through Daydream's infrastructure. The difference is that calling the Gateway directly gives you choice of provider, no Daydream-specific branding, and the option to eventually run your own Gateway.
</Note>

As your usage scales, the natural next step is running your own Gateway – reducing per-inference costs and gaining full control over Orchestrator selection. This is the graduation path described in the [Nov 2025 Network Vision](https://blog.livepeer.org/a-real-time-update-to-the-livepeer-network-vision/): just as companies move from Heroku to AWS to their own infrastructure as they scale, developers move from hosted Gateway access to self-hosted Gateways as their usage and requirements grow.

**API reference:** [docs.livepeer.org/ai/api-reference](/v2/Gateways/resources/reference/technical/api-reference/AI-API/ai)
**Available Gateways:** [docs.livepeer.org/ai/builders/Gateways](/v2/Gateways/guides/operator-considerations/production-Gateways)

[//]: # "REVIEW: Confirm exact endpoint URL for the hosted Studio Gateway AI API (separate from Studio video API). Clarify with Rick or Mehrdad."

[//]: # "REVIEW: Confirm whether \"AI Jobs API\" is deprecated terminology – current evidence says yes but needs go-livepeer README confirmation."

<CustomDivider />

## ComfyStream

ComfyStream is an open-source ComfyUI plugin (maintained at `github.com/livepeer/comfystream`) that enables real-time video and audio workflows in ComfyUI. It turns ComfyUI – the most widely used open-source AI workflow tool – into a real-time inference engine for live video instead of a batch image generator.

Daydream itself is built on ComfyStream. When you build with ComfyStream directly, you are working at the same layer that Daydream operates at, with full access to ComfyUI's node graph, custom model loading, and workflow composition – but managing your own infrastructure.

ComfyStream is the right choice if you need custom AI video workflows that go beyond what a hosted API offers: chaining multiple models, using fine-tuned LoRAs, building interactive VTubing setups, or contributing new pipeline types to the network via BYOC (Bring Your Own Container).

**Deployment options:** local, Docker (`livepeer/comfystream`), RunPod, TensorDock, Ansible
**Docs:** [docs.ComfyStream.org](https://docs.comfystream.org) / [pipelines.livepeer.org](https://pipelines.livepeer.org)
**Repo:** [github.com/Livepeer/ComfyStream](https://github.com/livepeer/comfystream)

<CustomDivider />

## Protocol Layer

The protocol layer is the foundation that all the above layers run on. It consists of the `go-livepeer` node software, the `livepeer/protocol` Solidity smart contracts managing on-chain economic coordination, and the `livepeer/ai-worker` container that executes AI inference jobs on GPU nodes.

Building at the protocol layer means running and operating network infrastructure (Gateway nodes, Orchestrator nodes, or AI worker nodes), contributing new pipeline types or capabilities to the network itself, and participating in on-chain governance. This is the right path if your goal is to strengthen the network, earn LPT rewards, or build capabilities that currently do not exist anywhere on the stack.

**Primary repos:** `livepeer/go-livepeer`, `livepeer/protocol`, `livepeer/ai-worker`, `livepeer/comfystream`

[//]: # "REVIEW: Verify go-livepeer README developer-facing API surface description – not directly checked in this research session due to domain restrictions."

<CustomDivider />

## Choosing Your Layer

| If your goal is...                                                | Use                 | Where to start                                                              |
| ----------------------------------------------------------------- | ------------------- | --------------------------------------------------------------------------- |
| Add video streaming or transcoding to an app                      | Studio API          | [Studio quickstart](https://docs.livepeer.studio)                           |
| Add real-time AI video effects to an app                          | Daydream API        | [Daydream quickstart](https://pipelines.livepeer.org)                       |
| Call the AI inference API directly, choose your Gateway provider  | AI Gateway API      | [AI quickstart](/v2/developers/get-started/ai-quickstart)                   |
| Build custom AI video pipelines with ComfyUI workflows            | ComfyStream         | [ComfyStream quickstart](/v2/developers/get-started/ComfyStream-quickstart) |
| Reduce inference costs by self-hosting a Gateway                  | Self-hosted Gateway | [When to run your own Gateway](/v2/developers/concepts/running-a-Gateway)   |
| Contribute to the network, run nodes, or build new pipeline types | Protocol layer      | [OSS stack](/v2/developers/concepts/oss-stack)                              |

<CustomDivider />

## Next Steps

<CardGroup cols={2}>
  <Card title="Set Up Your Path" href="/v2/developers/get-started/setup-paths">
    Choose your quickstart path and make your first successful call or pipeline run.
  </Card>

  <Card title="Choose Your Developer Journey" href="/v2/developers/navigator">
    See the full journey mapped out for your developer type.
  </Card>
</CardGroup>