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

# Operator Impact

> How Orchestrators shape the Livepeer protocol - governance weight, what gets voted on, the sovereign compute thesis, and why open video infrastructure matters.

export const BorderedBox = ({children, variant = "default", padding = "var(--lp-spacing-4)", borderRadius = "var(--lp-spacing-px-8)", margin = "", accentBar = "", style = {}, className = "", ...rest}) => {
  const variants = {
    default: {
      border: "1px solid var(--lp-color-border-default)",
      backgroundColor: "var(--lp-color-bg-card)"
    },
    accent: {
      border: "1px solid var(--lp-color-accent)",
      backgroundColor: "var(--lp-color-bg-card)"
    },
    muted: {
      border: "1px solid var(--lp-color-border-default)",
      backgroundColor: "transparent"
    }
  };
  const accentBarColors = {
    accent: "var(--lp-color-accent)",
    positive: "var(--green-9)"
  };
  return <div data-docs-bordered-box="" data-accent-bar={accentBarColors[accentBar] ? "" : undefined} className={className} style={{
    ...variants[variant],
    padding: padding,
    borderRadius: borderRadius,
    ...margin ? {
      margin
    } : {},
    ...accentBarColors[accentBar] ? {
      position: "relative",
      '--accent-bar-color': accentBarColors[accentBar]
    } : {},
    ...style
  }} {...rest}>
      {children}
    </div>;
};

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 ScrollableDiagram = ({children, title = '', maxHeight = '500px', minWidth = '100%', showControls = false, className = '', style = {}, ...rest}) => {
  const buildDiagramKey = (currentTitle = '', currentClassName = '') => {
    const source = `${currentTitle}|${currentClassName}|scrollable-diagram`;
    let hash = 0;
    for (let index = 0; index < source.length; index += 1) {
      hash = hash * 31 + source.charCodeAt(index) >>> 0;
    }
    return `docs-diagram-${hash.toString(36)}`;
  };
  const diagramKey = buildDiagramKey(title, className);
  const zoomName = `${diagramKey}-zoom`;
  const zoomLevels = [{
    label: '75%',
    value: 0.75
  }, {
    label: '100%',
    value: 1
  }, {
    label: '125%',
    value: 1.25
  }, {
    label: '150%',
    value: 1.5
  }];
  const containerStyle = {
    overflow: 'auto',
    maxHeight,
    border: '1px solid var(--lp-color-border-default)',
    borderRadius: "8px",
    padding: "var(--lp-spacing-4)",
    background: 'var(--lp-color-bg-card)',
    position: 'relative'
  };
  return <div className={className} style={{
    position: 'relative',
    marginBottom: "var(--lp-spacing-4)",
    ...style
  }} {...rest}>
      {title && <p style={{
    textAlign: 'center',
    fontStyle: 'italic',
    color: 'var(--lp-color-text-secondary)',
    marginBottom: "var(--lp-spacing-2)",
    fontSize: '0.875rem'
  }}>
          {title}
        </p>}

      {showControls ? <style>{`
          [data-docs-diagram-key="${diagramKey}"] [data-docs-diagram-content] {
            transform: scale(1);
            transform-origin: top left;
            width: max-content;
          }
          ${zoomLevels.map(zoomLevel => `
          #${diagramKey}-${zoomLevel.label.replace('%', '')}:checked ~ [data-docs-diagram-shell] [data-docs-diagram-content] {
            transform: scale(${zoomLevel.value});
          }
          #${diagramKey}-${zoomLevel.label.replace('%', '')}:checked ~ [data-docs-diagram-controls] label[for="${diagramKey}-${zoomLevel.label.replace('%', '')}"] {
            background: var(--lp-color-accent);
            color: var(--lp-color-on-accent);
            border-color: var(--lp-color-accent);
          }`).join('\n')}
        `}</style> : null}

      {showControls ? zoomLevels.map(zoomLevel => {
    const inputId = `${diagramKey}-${zoomLevel.label.replace('%', '')}`;
    return <input key={inputId} id={inputId} type="radio" name={zoomName} defaultChecked={zoomLevel.value === 1} style={{
      position: 'absolute',
      opacity: 0,
      pointerEvents: 'none'
    }} />;
  }) : null}

      <div data-docs-diagram-key={diagramKey} data-docs-diagram-shell style={containerStyle}>
        <div data-docs-diagram-content style={{
    minWidth,
    transformOrigin: 'top left',
    width: 'max-content'
  }}>
          {children}
        </div>
      </div>

      {showControls ? <div data-docs-diagram-controls style={{
    display: 'flex',
    justifyContent: 'flex-end',
    alignItems: 'center',
    gap: "var(--lp-spacing-2)",
    marginTop: "var(--lp-spacing-2)",
    flexWrap: 'wrap'
  }}>
          <span style={{
    fontSize: "0.75rem",
    color: 'var(--lp-color-text-muted)',
    marginRight: 'auto'
  }}>
            Scroll to pan
          </span>
          {zoomLevels.map(zoomLevel => {
    const inputId = `${diagramKey}-${zoomLevel.label.replace('%', '')}`;
    return <label key={inputId} htmlFor={inputId} style={{
      background: 'transparent',
      color: 'var(--lp-color-text-secondary)',
      border: '1px solid var(--lp-color-border-default)',
      borderRadius: "4px",
      padding: '4px 10px',
      cursor: 'pointer',
      fontSize: "0.75rem",
      fontWeight: '600'
    }}>
                {zoomLevel.label}
              </label>;
  })}
        </div> : null}
    </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>;
};

<CustomDivider />

Governance weight is the part of the Orchestrator role that starts after the earnings model makes sense. Bonded stake determines how much influence you carry over protocol rules, treasury direction, and the case for open compute infrastructure.

Orchestrators hold **governance weight** proportional to their total bonded stake. Every LPT staked
to an Orchestrator - whether self-staked or delegated - becomes voting influence over the protocol
that shapes operator economics, network priorities, and the infrastructure Livepeer can support.

For the mechanics of staking and delegation, see <LinkArrow href="/v2/orchestrators/guides/staking-and-rewards/network-participation" label="Governance Guide" newline={false} />. For Delegator voting rights, see <LinkArrow href="/v2/orchestrators/guides/staking-and-rewards/delegate-operations" label="Attracting Delegators" newline={false} />.

<CustomDivider />

## How Votes Work

Livepeer governance uses a **stake-weighted voting system** built around Livepeer Improvement
Proposals (LIPs). Every active participant in the network - Orchestrators, Delegators, and LPT
holders - can influence protocol decisions through this mechanism.

```mermaid theme={"theme":{"light":"github-light","dark":"dark-plus"}}
%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#18794E', 'primaryTextColor': '#fff', 'primaryBorderColor': '#3CB540', 'lineColor': '#3CB540', 'mainBkg': '#18794E', 'nodeBorder': '#3CB540', 'clusterBkg': 'transparent', 'clusterBorder': '#3CB540', 'titleColor': '#3CB540', 'edgeLabelBackground': 'transparent', 'textColor': '#3CB540', 'nodeTextColor': '#fff'}}}%%
flowchart LR
    A["Proposal drafted\n(community discussion)"] --> B["LIP submitted\n(GitHub livepeer/LIPs)"]
    B --> C["On-chain poll created\n(costs 100 LPT)"]
    C --> D["Polling period\n(~10 rounds, ~10 days)"]
    D --> E{"Passes threshold?\n33.33% of staked LPT\n+ 50% of votes cast"}
    E -->|Yes| F["Protocol change\nimplemented"]
    E -->|No| G["Proposal fails\nor revised"]

    classDef default fill:#1a1a1a,color:#fff,stroke:#2d9a67,stroke-width:2px
```

Key mechanics:

* **Voting weight** equals total bonded stake (Orchestrator self-stake plus all delegated LPT)
* **Passing threshold** requires 33.33% of all staked LPT to support AND 50% of votes cast to approve
* **Delegator override** - Delegators can vote independently, overriding their Orchestrator's position on a specific LIP
* **Poll creation cost** - 100 LPT to create an on-chain poll, preventing low-effort or spam proposals

This design gives Orchestrators with large bonded stake substantial influence, while preserving
Delegator autonomy. An Orchestrator cannot vote on behalf of Delegators who choose to exercise
their own governance rights.

<CustomDivider />

## Scope of Governance

Governance is not a side topic. It reaches directly into operator economics, network direction, and
the conditions under which future workloads become viable.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Category</TableCell>
      <TableCell header>Examples</TableCell>
      <TableCell header>Orchestrator relevance</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>**Protocol parameters**</TableCell>
      <TableCell>Inflation rate targets, Active Set size, unbonding periods, slashing conditions</TableCell>
      <TableCell>Directly affects earnings (inflation) and competitive dynamics (Active Set size)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Fee structures**</TableCell>
      <TableCell>Ticket pricing models, payment ticket mechanics, fee distribution</TableCell>
      <TableCell>Affects how ETH service fees flow from Gateways to Orchestrators</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Technical upgrades**</TableCell>
      <TableCell>New workload types, contract upgrades, AI subnet integration, capability expansions</TableCell>
      <TableCell>Determines which workloads the network supports and how they are priced</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Treasury allocation**</TableCell>
      <TableCell>SPE grants, development funding, ecosystem programmes, infrastructure support</TableCell>
      <TableCell>Funds that support Orchestrator tooling, community pools, and ecosystem growth</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Governance process**</TableCell>
      <TableCell>Quorum thresholds, voting periods, Foundation structure, DAO operations</TableCell>
      <TableCell>Shapes how future decisions are made</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

The Livepeer Foundation, launched in 2025, coordinates ecosystem development and stewards the
long-term protocol vision. It does not replace stake-weighted governance over protocol parameters.
Operators with large bonded stake remain consequential participants in major protocol decisions.

<Note>
  Governance proposals and active LIPs are tracked on the [Livepeer Forum](https://forum.livepeer.org/c/governance/17)
  and the [Livepeer/LIPs GitHub repository](https://github.com/livepeer/LIPs). Following these is
  a practical prerequisite for informed governance participation.
</Note>

<CustomDivider />

## Stake as Governance Capital

For operators, stake is both economic capital and political capital inside the network. It determines
not only reward exposure, but how much influence an operator carries when the protocol changes.

```mermaid theme={"theme":{"light":"github-light","dark":"dark-plus"}}
%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#18794E', 'primaryTextColor': '#fff', 'primaryBorderColor': '#3CB540', 'lineColor': '#3CB540', 'mainBkg': '#18794E', 'nodeBorder': '#3CB540', 'clusterBkg': 'transparent', 'clusterBorder': '#3CB540', 'titleColor': '#3CB540', 'edgeLabelBackground': 'transparent', 'textColor': '#3CB540', 'nodeTextColor': '#fff'}}}%%
flowchart LR
    A["Operate well\n(uptime, performance,\nfair cut settings)"] --> B["Attract more\ndelegated stake"]
    B --> C["Higher total\nbonded stake"]
    C --> D["Greater governance\nvote weight"]
    D --> E["Influence protocol\ndecisions that affect\noperator economics"]
    E --> A

    classDef default fill:#1a1a1a,color:#fff,stroke:#2d9a67,stroke-width:2px
```

This creates a direct link between operating well and carrying more influence. Orchestrators who
deliver reliable service, maintain competitive pricing, and build trust with Delegators accumulate
more bonded stake over time - and with it, more governance weight.

The concentration of stake matters. Active Orchestrators represent the majority of staked LPT in
the network. On any contested governance vote, the position taken by large Orchestrators is often
decisive.

<Warning>
  Governance weight comes with governance responsibility. Orchestrators that hold large stake and vote
  on proposals affect outcomes for all network participants - Delegators who trusted them with LPT,
  Gateways that depend on the network for their products, and the broader Livepeer ecosystem. Most
  Delegators do not vote independently; their stake defaults to their Orchestrator's position.
</Warning>

<CustomDivider />

## Beyond Earnings: Sovereign Compute

The economic case for running a Livepeer Orchestrator is covered in <LinkArrow href="/v2/orchestrators/guides/operator-considerations/operator-rationale" label="Operating Rationale" newline={false} />. The non-financial case starts with a different question: who should control the infrastructure that serves video and AI workloads?

The dominant alternative is centralised cloud compute. AWS, Azure, and GCP provide the GPU
infrastructure that powers the majority of video transcoding and AI inference globally. This
concentration creates:

* **Single points of control** - a policy change at a major provider affects all its customers
  simultaneously
* **Censorship vectors** - centralised providers can and do restrict access to certain content or
  customers under legal or commercial pressure
* **Vendor lock-in** - platforms built on proprietary cloud infrastructure cannot easily migrate
  away
* **Pricing power** - without competitive alternatives, cloud providers set the terms

Livepeer Orchestrators collectively run the alternative. A decentralised network of GPU operators,
governed by token holders themselves, leaves no single provider able to suspend, censor, or price out
the entire market.

<AccordionGroup>
  <Accordion title="For independent media" icon="video">
    Video infrastructure controlled by centralised platforms is subject to those platforms' content
    policies. Independent creators in jurisdictions with restrictive internet governance, or producing
    content that falls into contested categories, have limited recourse when a cloud provider
    terminates service.

    A permissionless compute network with no single controller provides a meaningfully different
    infrastructure substrate. Orchestrators are the physical embodiment of that alternative.
  </Accordion>

  <Accordion title="For AI researchers" icon="microchip">
    AI research increasingly requires GPU access at scale. Centralised providers gatekeep this through
    pricing, account verification, acceptable use policies, and geographic restrictions. Researchers
    in emerging markets or working on models that touch policy-sensitive domains face additional
    barriers.

    Livepeer's permissionless AI inference network lowers these barriers. Any application can access
    GPU compute by paying the market rate in ETH - no account approval, no content policy review,
    no geographic restriction.
  </Accordion>

  <Accordion title="For platforms avoiding lock-in" icon="building">
    Platforms built on proprietary cloud infrastructure are subject to that provider's pricing and
    availability. A provider raising GPU pricing by 30%, or deprecating a service, creates immediate
    operational risk.

    Building on an open, permissionless network with multiple competing Orchestrators distributes
    that risk. No single Orchestrator's failure or pricing change can disrupt a well-configured Gateway.
  </Accordion>

  <Accordion title="For developers building on open compute" icon="code">
    Open compute infrastructure enables applications that would not exist on centralised platforms:
    uncensorable media archives, AI applications with no usage monitoring, platforms operating across
    jurisdictions where centralised services are blocked.

    The developer community building on Livepeer depends on Orchestrators to make this infrastructure
    available. An Orchestrator is more than an earning node - it is part of the substrate that makes these
    applications possible.
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Practical Governance Participation

If the motivation case is clear, the practical question becomes what an operator actually does with
that influence. Governance participation means more than showing up on voting day. The most
consequential work happens before a proposal reaches an on-chain poll.

**Follow active proposals.** The [Livepeer Forum governance category](https://forum.livepeer.org/c/governance/17)
is where proposals develop before reaching an on-chain vote. Early discussion shapes what ends up
being voted on. Orchestrators with specific operational perspectives - pricing mechanics, hardware
requirements for new workload types, impact on earnings - provide signal that proposal authors and
the broader community need.

**Vote on LIPs.** Voting can be done via the [Livepeer Explorer](https://explorer.livepeer.org/voting).
Orchestrators that hold large stake but consistently abstain reduce the effective quorum
available for passing beneficial proposals and signal low engagement to their Delegators.

**Communicate governance positions to Delegators.** Since Delegators default to their Orchestrator's
vote unless they vote independently, Orchestrators with large delegated stake have an obligation to
communicate how they intend to vote on major proposals. Transparent governance communication is
a quality signal that influences delegation decisions.

**Engage with SPE proposals.** The Strategic Priority Enabler (SPE) framework allocates treasury
resources to specific ecosystem initiatives. SPE proposals affect what infrastructure, tooling, and
growth programmes get funded. Orchestrators who benefit from or are affected by specific SPE programmes
have direct interest in these votes.

<CustomDivider />

## Related Pages

<CardGroup cols={2}>
  <Card title="Operating Rationale" icon="scale-balanced" href="/v2/orchestrators/guides/operator-considerations/operator-rationale" arrow horizontal>
    The financial case for running a node - costs, revenue, and decision matrix.
  </Card>

  <Card title="Governance Guide" icon="vote-yea" href="/v2/orchestrators/guides/staking-and-rewards/network-participation" arrow horizontal>
    How to participate in governance - voting steps, proposal process, and Explorer guide.
  </Card>

  <Card title="Attracting Delegators" icon="users" href="/v2/orchestrators/guides/staking-and-rewards/delegate-operations" arrow horizontal>
    How to grow delegated stake and build the governance weight that comes with it.
  </Card>

  <Card title="LPT Token Overview" icon="coins" href="/v2/delegators/concepts/overview" arrow horizontal>
    The role of LPT in governance, staking, and the broader Livepeer Protocol.
  </Card>
</CardGroup>
