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

# RFP Report

> Report on the Livepeer Documentation Restructure RFP

export const CustomCardTitle = ({icon, title, variant = "card", iconSize, style = {}, className = "", ...rest}) => {
  const variants = {
    card: {
      display: 'flex',
      alignItems: 'center',
      gap: "var(--lp-spacing-2)",
      marginBottom: "var(--lp-spacing-3)",
      color: 'var(--lp-color-text-primary)',
      fontSize: '1rem',
      fontWeight: 600
    },
    accordion: {
      display: 'inline-flex',
      alignItems: 'center',
      gap: "var(--lp-spacing-2)"
    },
    tab: {
      display: 'inline-flex',
      alignItems: 'center',
      gap: '0.4rem',
      fontSize: '0.875rem'
    }
  };
  const sizes = {
    card: 20,
    accordion: 18,
    tab: 14
  };
  const size = iconSize || sizes[variant] || 20;
  const baseStyle = variants[variant] || variants.card;
  return variant === 'card' ? <div className={className} style={{
    ...baseStyle,
    ...style
  }} {...rest}>
      {typeof icon === 'string' ? <Icon icon={icon} size={size} color="var(--lp-color-accent)" /> : icon}
      {title}
    </div> : <span className={className} style={{
    ...baseStyle,
    ...style
  }} {...rest}>
      {typeof icon === 'string' ? <Icon icon={icon} size={size} color="var(--lp-color-accent)" /> : icon}
      {title}
    </span>;
};

export const DownloadButton = ({label = 'Download', icon = 'download', downloadLink, rightIcon = '', border = false, className = "", style = {}, ...rest}) => {
  const [isVisible, setIsVisible] = React.useState(false);
  const ref = React.useRef(null);
  React.useEffect(() => {
    const observer = new IntersectionObserver(([entry]) => {
      if (entry.isIntersecting) {
        setIsVisible(true);
        observer.disconnect();
      }
    }, {
      threshold: 0.1
    });
    if (ref.current) {
      observer.observe(ref.current);
    }
    return () => observer.disconnect();
  }, []);
  downloadLink = downloadLink ? downloadLink : 'https://Livepeer.org';
  const handleDownload = () => {
    const a = document.createElement('a');
    a.href = downloadLink;
    a.download = '';
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
  };
  if (!isVisible) {
    return <span ref={ref} className={className} style={{
      minHeight: '20px',
      display: 'inline-block',
      ...style
    }} {...rest} />;
  }
  return <span ref={ref} className={className} style={{
    ...border ? {
      border: '1px solid grey',
      borderRadius: "6px",
      padding: '6px 10px',
      display: 'inline-block',
      cursor: 'pointer'
    } : {
      cursor: 'pointer'
    },
    ...style
  }} {...rest}>
      <Icon icon={icon} size={18} color="var(--lp-color-accent)" />
      <button onClick={handleDownload} style={{
    marginRight: 8,
    marginLeft: 8,
    background: 'none',
    border: 'none',
    color: 'inherit',
    cursor: 'pointer',
    textDecoration: 'underline',
    padding: 0,
    font: 'inherit'
  }}>
        {label}
      </button>
      {rightIcon && <Icon icon={rightIcon} style={{
    marginLeft: 8
  }} size={18} color="var(--lp-color-accent)" />}
    </span>;
};

export const FrameQuote = ({children, author, source, href, frame = true, align = 'right', borderColor, img, spacing = true, className = "", style = {}, ...props}) => {
  const alignmentMap = {
    left: 'flex-start',
    center: 'center',
    right: 'flex-end'
  };
  const content = <blockquote style={{
    display: 'flex',
    flexDirection: 'column',
    padding: '0.75rem 1rem 0.25rem 1rem',
    gap: "var(--lp-spacing-1)",
    margin: 0
  }}>
      <div style={{
    borderLeft: `4px solid var(--lp-color-accent)`,
    paddingLeft: "var(--lp-spacing-4)",
    fontStyle: 'italic'
  }}>
        {children}
      </div>
      {(author || source) && <div style={{
    display: 'flex',
    justifyContent: alignmentMap[align] || 'flex-end',
    marginLeft: align === 'left' ? "var(--lp-spacing-6)" : 0
  }}>
          <div style={{
    textAlign: align === 'center' ? 'center' : 'left'
  }}>
            {author && <div>
                {spacing && <br />}
                <Icon icon="microphone" />{' '}
                <strong>
                  <em>{author}</em>
                </strong>
              </div>}
            {source && (href ? <a href={href} target="_blank" rel="noopener noreferrer">
                  <span style={{
    opacity: 0.7,
    fontStyle: 'italic',
    borderBottom: '1px solid var(--lp-color-accent)',
    fontSize: "1rem"
  }}>
                    {source}
                  </span>{' '}
                  <Icon icon="arrow-up-right" size={12} color="var(--lp-color-accent)" />
                </a> : <span style={{
    opacity: 0.7,
    fontStyle: 'italic',
    fontSize: "1rem"
  }}>
                  {source}
                </span>)}
          </div>
        </div>}
    </blockquote>;
  return frame ? <div className={className} style={{
    border: borderColor ? `1px solid ${borderColor}` : 'none',
    borderRadius: "8px",
    overflow: 'hidden',
    ...style
  }} {...props}>
      <Frame style={{
    border: 'none'
  }}>
        {img && <img src={img.src} alt={img.alt} />}
        {content}
      </Frame>
    </div> : content;
};

export const Quote = ({children, className = "", style = {}, ...rest}) => {
  const quoteStyle = {
    fontSize: "1rem",
    textAlign: 'center',
    opacity: 1,
    fontStyle: 'italic',
    color: 'var(--lp-color-accent)',
    border: '1px solid var(--lp-color-border-default)',
    borderRadius: "8px",
    padding: "var(--lp-spacing-4)",
    margin: '1rem 0',
    ...style
  };
  return <blockquote className={className} style={quoteStyle} {...rest}>{children}</blockquote>;
};

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

# Aims - Documentation Philosophy & RFP Aim Delivery

<Quote>"Restructure, refresh, and modernize Livepeer's documentation so that it is **stakeholder-focused**, **AI-first**, and **future-proofed**. It should cater to the core personas of the Livepeer project: developers, Delegators, Gateway operators and Orchestrators." - Livepeer Foundation RFP, September 2024 </Quote>

## Documentation Philosophy

This section articulates the philosophical framework that underpinned the v2 engagement and demonstrates, with full implementation evidence, how every element of the RFP's three stated aims - **stakeholder-focused**, **AI-first**, and **future-proofed** - was delivered across every layer of the system.

## Documentation Philosophy

1. Documentation is not static. It is infrastructure & must be built, maintained, and governed as such.
2. AI is the new search, and discoverable products are AI-first
3. Agents are the new docs consumers and users and information should be structured accordingly

<Tabs>
  <Tab title="Documentation As Infrastructure" icon="grid-round-2-minus">
    ## **Documentation As Infrastructure**

    The foundational premise of this engagement, articulated before a single page was written, is that documentation is not editorial output.

    ***It is infrastructure.***

    This principle reframes how investment in documentation should be understood, measured, and maintained.

    Infrastructure has properties that editorial content does not: it must be maintained under load, it degrades without active governance, it requires testing, automation, and versioning.

    The D.O.C.S. System™ developed as the strategic operating model for this engagement formalises this:

    * Distribution Infrastructure,
    * Operational Governance,
    * Composable Execution, and
    * Signal & System Feedback.

    The practical implication is that "documentation work" in this engagement meant building a documentation operating system - a complete apparatus for authoring, validating, publishing, automating, and governing content - not just writing pages.

    The 58-script test suite, 17 GitHub Actions workflows, lpd CLI, component library, and docs-guide governance system are all infrastructure.

    They are the scaffolding that makes every page reliable, maintainable, and improvable by anyone.

    <Frame caption="">
      <iframe height="200px" width="100%" frameborder="no" scrolling="no" seamless src="https://player.simplecast.com/f6d42d55-3e7d-4d92-8517-8d84c18386af?dark=true" title="Embedded content from player.simplecast.com" />
    </Frame>

    <Accordion title="Episode Details" icon="microphone">
      Inferact is a new AI infrastructure company founded by the creators and core maintainers of vLLM.

      Its mission is to build a universal, open-source inference layer that makes large AI models faster, cheaper, and more reliable to run across any hardware, model architecture, or deployment environment.

      Together, they broke down how modern AI models are actually run in production, why "inference" has quietly become one of the hardest problems in AI infrastructure, and how the open-source project vLLM emerged to solve it.

      The conversation also looked at why the vLLM team started Inferact and their vision for a universal inference layer that can run any model, on any chip, efficiently.

      <DownloadButton label="Download Transcript" downloadLink="" />
    </Accordion>

    <Frame caption="">
      <iframe height="200px" width="100%" frameborder="no" seamless src="https://player.simplecast.com/27863aa4-9767-4c51-a1b9-7d220bb0af69?dark=true" title="Embedded content from player.simplecast.com" />
    </Frame>

    <Accordion title="Episode Details" icon="microphone">
      In this episode of AI + a16z, dbt Labs founder and CEO Tristan Handy sits down with a16z's Jennifer Li and Matt Bornstein to explore the next chapter of data engineering — from the rise (and plateau) of the modern data stack to the growing role of AI in analytics and data engineering.

      Among other topics, they discuss how automation and tooling like SQL compilers are reshaping how engineers work with data; dbt's new Fusion Engine and what it means for developer workflows; and what to make of recent data-industry acquisitions and ambitious product launches.

      <DownloadButton label="Download Transcript" downloadLink="https://livepeer.notion.site/Docs-Philosophy-Transcript-5000c3190100412ea211119110111111" />
    </Accordion>

    <Card title={<CustomCardTitle icon="podcast" title="Y Combinator Podcast" />} href="https://creators.spotify.com/pod/profile/ycombinator/episodes/OpenClaw-And-The-Future-Of-Personal-AI-Agents-e3eonov/a-acf7n3i" arrow>
      OpenClaw And The Future Of Personal AI Agents
    </Card>

    <Accordion title="Episode Details" icon="microphone">
      Talks about Documentation as Infrastructure and how good documentation ensures AI surfaces the product, regardless of product capability.

      <DownloadButton label="Download Transcript" downloadLink="https://livepeer.notion.site/Docs-Philosophy-Transcript-5000c3190100412ea211119110111111" />
    </Accordion>

    <Accordion title="Documentation Frameworks & References" icon="frame">
      ## D.O.C.S (Documentation)

      The D.O.C.S principles focus on creating high-quality, effective, and user-focused technical content by ensuring it is clear, concise, comprehensive, and consistent.

      Key principles include writing from the user's perspective, using plain language, keeping documentation up-to-date, making it skimmable with structured formatting, and providing concrete, actionable examples.

      #### Core Documentation Principles

      * **Clear & Concise**: Use simple language to explain complex ideas, avoiding jargon. Get to the point quickly and remove unnecessary information.
      * **Comprehensive & Consistent**: Cover all necessary information (endpoints, variations, edge cases) and maintain consistent formatting and terminology throughout.
      * **Structured & Skimmable**: Use headings, subheadings, lists, and tables to make content easy to navigate. Place the most important information first.
      * **User-Focused**: Write from the reader's perspective, focusing on their tasks and goals instead of just technical features.
      * **Accurate & Updated**: Regularly review and update documentation to reflect the current state of the product.
      * **Concrete & Interactive**: Include real-world examples, code snippets, and tutorials to help users immediately apply the information.

      ## Docs as Code (Modern Approach)

      Modern documentation often follows a "Docs as Code" approach, treating documentation with the same rigor as software code.

      * **Integrated**: Documentation is part of the development lifecycle, not an afterthought.
      * **Version Control**: Stored alongside code in repositories (e.g., Git).
      * **Automation**: Automated testing and building of documentation.
      * **Collaboration**: Allows for pull requests and reviews, enabling both writers and developers to contribute.

      #### Best Practices

      * **Define Terms**: Define acronyms and technical terms.
      * **Inclusive Language**: Use language that is welcoming to a diverse audience.
      * **Identify Audience Needs**: Map documentation to specific user tasks (e.g., tutorials, how-to guides, API reference).
      * **Record Rationale**: Explain why something was done, beyond what was done.

      ## **Diátaxis Framework**

      The Diátaxis framework is a systematic approach that organizes documentation into four distinct quadrants based on two axes: **Action vs. Reflection** and **Learning vs. Working**.

      #### The Four Quadrants of Diátaxis

      * **Tutorials (Learning-Oriented):** Hands-on lessons that guide a beginner through a series of steps to achieve a result. Their primary goal is to provide a successful learning experience, beyond solve a problem.
      * **How-To Guides (Task-Oriented):** Practical directions that help an experienced user complete a specific, real-world task. They focus on the "how" and assume the user already has basic competence.
      * **Reference (Information-Oriented):** Technical descriptions of the machinery-API keys, classes, commands, and schemas. They must be neutral, accurate, and easy to consult quickly.
      * **Explanation (Understanding-Oriented):** Discussions that clarify and illuminate a particular topic. They provide context, background, and rationale ("the why") instead of instructions.

      The core principle is to keep these four types separate. Mixing them — such as putting long technical explanations inside a step-by-step tutorial — confuses the reader and makes the documentation harder to maintain.

      **References:**

      <Columns cols={2}>
        <Card title={<CustomCardTitle icon="blog" title="Stackoverflow Blog" />} href="https://stackoverflow.blog/2024/11/26/your-docs-are-your-infrastructure/" arrow> Your docs are your infrastructure </Card>
        <Card title={<CustomCardTitle icon="podcast" title="Y Combinator Podcast" />} href="https://creators.spotify.com/pod/profile/ycombinator/episodes/OpenClaw-And-The-Future-Of-Personal-AI-Agents-e3eonov/a-acf7n3i" arrow> OpenClaw And The Future Of Personal AI Agents</Card>
        <Card title={<CustomCardTitle icon="youtube" title="Kong Docs" />} href="https://www.youtube.com/watch?v=9yLIPZ4iBLw" arrow> Docs as Code</Card>
        <Card title={<CustomCardTitle icon="github" title="Github Blog" />} href="https://github.blog/developer-skills/documentation-done-right-a-developers-guide/#:~:text=Keep%20it%20clear,where%20to%20find%20specific%20information" arrow> D.O.C.S (Documentation Principles)</Card>
      </Columns>
    </Accordion>
  </Tab>

  <Tab title="AI Is the New Search" icon="searchengin">
    ## **AI Is the New Search**

    <FrameQuote author="Chris Dixon" source="Managing Partner, a16z" spacing={false}> "AI is not going to end the world-but it is going to end the web as we've known it. AI is already upending the economic covenant of the internet that's existed since the advent of search." </FrameQuote>

    For over a decade, SEO - optimising for Google - was the primary lever for documentation discoverability.

    ***That paradigm is being rapidly displaced.***

    LLMs now index, summarise, and recommend infrastructure products at scale. Developers increasingly begin their research with ChatGPT, Claude, Perplexity, or Gemini instead of a search engine.

    This means documentation is now being read, evaluated, and cited by machines before it reaches humans.

    **The implication is structural**, not cosmetic.

    Semantic headings, stable canonical URLs, machine-readable frontmatter, OpenAPI spec integration, AEO, AI-integrated pipelines and llms.txt files are not "nice to have" - they are the new minimum viable distribution layer.

    Answer Engine Optimization (AEO) is the evolution of SEO for this era. This engagement built Livepeer's AEO layer from first principles.
  </Tab>

  <Tab title="Agents Are the New Users" icon="user-robot">
    ## **Agents Are the New Users**

    The next wave beyond AI-assisted search is **AI agent consumption**: automated systems that query documentation to generate code, answer support tickets, configure infrastructure, or build integrations without human intervention.

    These agents require documentation that is not merely readable but executable - with explicit preconditions, invariants, verification steps, and failure modes.

    It requires specifically serving content designed for agent consumption and context windows.

    The ["Get AI to Set Up the Gateway"](/v2/gateways/quickstart/AI-prompt) page is a direct instantiation of this principle: a page written for AI agent consumption, not human browsing.

    The llms.txt file, repository `AGENTS.md`, and the native adapter files under `.github/`, `.claude/`, `.cursor/`, and `.windsurf/` extend this philosophy into the development workflow itself - making the entire repository legible to AI coding assistants.

    See the 21 items for AI-First Docs implemented in the [AI-First Report](/v2/internal/rfp/reports/livepeer-ai-first-docs-plan.pdf)
  </Tab>
</Tabs>

## Docs-As-Infrastructure Repo Features

This update separates the repo product from the public content rewrite. The documentation repo now contains a docs-as-infrastructure system: governance docs, validators, generators, repair paths, component and style systems, data integrations, AI-facing artifacts, and maintainer tooling. Current evidence is tracked in `workspace/plan/active/REPO-FEATURES-DOCS-AUDIT/`.

| Feature area                    | Current status      | Evidence                                                                                                                                | Remaining gap or community-help area                                                                                    |
| ------------------------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| AI features and pipelines       | Completed with gaps | Agent adapters, AI tools registry, skills, `llms.txt`, AI sitemap workflow, and AI feature docs exist.                                  | Static counts drift from live inventory; generated skill indexes should become the count source.                        |
| UI and component system         | Completed with gaps | Component registry, usage map, component catalogue, templates, global style governance, and JSX component library exist.                | Archived components and count drift need classification before the UI system can be called fully consolidated.          |
| Automations                     | Completed with gaps | GitHub Actions, script taxonomy, generated catalogue, validators, remediators, and dispatch workflows exist.                            | Workflow and script counts drift; some legacy workflow/archive paths remain and need governed cleanup.                  |
| Data integrations               | Completed with gaps | OpenAPI/reference paths, contracts pipeline, release/changelog workflows, exchanges data, and social/community feed integrations exist. | Each feed still needs a confirmed source, owner, validator, repair path, and retention policy.                          |
| Adaptive architecture           | Partially complete  | Ownerless governance surfaces, generated artifact manifest, validators, remediators, hooks, and repair concepts exist.                  | Governance map drift, v2 lane cleanup, report retention, and script metadata compliance remain open.                    |
| Contributor tools               | Completed with gaps | `lpd`, local hooks, scoped preview tooling, editor tooling, contribution docs, and validation commands exist.                           | PATH discovery for non-interactive shells and stale tooling references need tightening.                                 |
| Content operating system        | Partially complete  | Content-writing framework, page/frontmatter taxonomy, style standards, research workflows, and review packet workflows exist.           | Workspace review packets and active/complete plans need consolidation into canonical docs-guide evidence.               |
| Governance and ownerless repo   | Partially complete  | Governance index, source-of-truth policy, quality gates, framework/policy set, decisions, and root governance files exist.              | Locked docs-guide IA decisions are not fully implemented; duplicate authority files and stale top-level folders remain. |
| Community contribution pathways | Completed with gaps | Contribution guide, issue templates, Discord/GitHub intake concepts, review workflows, and docs tooling exist.                          | Gap queue should be made public-facing only after verification and owner assignment.                                    |

Honest delivery status: the repo has moved beyond a documentation rewrite into a maintainable infrastructure product, but not every feature is fully consolidated or self-remediating yet. The current handoff priority is to verify every feature, collapse docs-guide into the locked IA, update generated inventories, and publish a reviewed help-needed queue for unresolved ownerless-governance gaps.

<StyledTable variant="bordered">
  <thead>
    <tr className="lp-table-row-accent">
      <th className="lp-table-heading-cell">Deliverable</th>
      <th className="lp-table-heading-cell">Status</th>
      <th className="lp-table-heading-cell">Notes</th>
      <th className="lp-table-heading-cell">Details</th>
    </tr>
  </thead>

  <tbody>
    {/* (i) Present Documentation Strategy */}

    <tr className="lp-table-row-accent">
      <td colSpan="4" className="lp-table-section-cell">(i) Present Documentation Strategy</td>
    </tr>

    <tr className="lp-table-row-card">
      <td colSpan="4" className="lp-table-note-cell">Create a new outline for Livepeer documentation, including full map of current documentation, a clear information architecture and timeline for writing new documents.</td>
    </tr>

    <TableRow hover>
      <TableCell>Identify core stakeholder groups (Livepeer Foundation, Livepeer Inc, AI SPE, Cloud SPE, Streamplace, Frameworks and more)</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Conduct audit of all docs pages with status recommendations across the 4 categories (Developers, Delegators, Orchestrators, Gateway Operators)</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Developers: clean up deprecated sections and plan integrations with new Gateway products</TableCell>
      <TableCell>Completed</TableCell>
      <TableCell>Platforms</TableCell>

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Orchestrators: simplify documentation to easy onboarding with plan for support in Discord</TableCell>
      <TableCell>Completed/Blocked</TableCell>
      <TableCell>Access to Discord not provided</TableCell>

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Delegators: integrate new video content to make it easy to delegate</TableCell>
      <TableCell>Blocked</TableCell>
      <TableCell>No video content provided</TableCell>

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Gateways: streamline documentation and workflows with support from the Foundation</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Create plan for an updated sidebar, taxonomy, and breadcrumb structure</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Consolidation of multiple changelogs into a single canonical feed</TableCell>
      <TableCell>Cancelled</TableCell>
      <TableCell>Foundation to manage</TableCell>

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Onboard stakeholders to project management process</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    {/* (ii) Re-Write Documentation */}

    <tr className="lp-table-row-accent">
      <td colSpan="4" className="lp-table-section-cell">(ii) Re-Write Documentation</td>
    </tr>

    <tr className="lp-table-row-card">
      <td colSpan="4" className="lp-table-note-cell">Systematically edit and rewrite new content to meet stakeholder needs with consistent accuracy and depth.</td>
    </tr>

    <TableRow hover>
      <TableCell>Work with core stakeholders to rewrite documentation</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Make the documentation easily consumable by AI systems and empower users with an embedded assistant</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Integrate embedded natural-language search or AI assistant (leveraging Mintlify features)</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Rewrite quickstarts for both AI Jobs and Transcoding Jobs</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Migration guides for Studio users</TableCell>
      <TableCell>Blocked</TableCell>
      <TableCell>Migration to where?</TableCell>

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Integrate goal-based tutorials for each stakeholder type where possible</TableCell>
      <TableCell>Incomplete</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Work with existing groups to incorporate starter repos, examples, snippets and full API/SDK/CLI references with updated coverage (including realtime + BYOC APIs)</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Conduct review with core stakeholders with a clear RFC</TableCell>
      <TableCell>Completed</TableCell>
      <TableCell>Review process provided over multiple months</TableCell>

      <TableCell />
    </TableRow>

    {/* (iii) V1 Documentation Live */}

    <tr className="lp-table-row-accent">
      <td colSpan="4" className="lp-table-section-cell">(iii) V1 Documentation Live</td>
    </tr>

    <tr className="lp-table-row-card">
      <td colSpan="4" className="lp-table-note-cell">Deliver a technically sound and reliable documentation site.</td>
    </tr>

    <TableRow hover>
      <TableCell>Implement redesigned IA and content in the current docs stack (Mintlify/Docusaurus)</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Set up redirects, SEO and AEO optimisation, and accessibility compliance (WCAG)</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Integrate multilingual readiness and analytics tracking</TableCell>
      <TableCell>Completed</TableCell>
      <TableCell>3 translations available</TableCell>

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Integrate the documentation into the website</TableCell>
      <TableCell>Cancelled/Blocked</TableCell>
      <TableCell>Website cancelled</TableCell>

      <TableCell />
    </TableRow>

    {/* (iv) Public Workflow for Maintenance and Community Contributions */}

    <tr className="lp-table-row-accent">
      <td colSpan="4" className="lp-table-section-cell">(iv) Public Workflow for Maintenance and Community Contributions</td>
    </tr>

    <tr className="lp-table-row-card">
      <td colSpan="4" className="lp-table-note-cell">Create a consistent tone and a scalable contribution process.</td>
    </tr>

    <TableRow hover>
      <TableCell>Work with the Livepeer Foundation Technical Director to establish a unified voice and style guide</TableCell>
      <TableCell>Blocked then Completed</TableCell>
      <TableCell>None provided - completed on own</TableCell>

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Create contribution guidelines and PR workflow for community involvement</TableCell>
      <TableCell>Completed</TableCell>

      <TableCell />

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Define and handover ownership and review process for maintaining quality</TableCell>
      <TableCell>Completed</TableCell>
      <TableCell>Fully automated</TableCell>

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Integrate multilingual readiness and analytics tracking</TableCell>
      <TableCell>Completed/Blocked</TableCell>
      <TableCell>No analytics provider given</TableCell>

      <TableCell />
    </TableRow>

    <TableRow hover>
      <TableCell>Provide a clear ticketing system for reporting problems and patching fixes</TableCell>
      <TableCell>Completed</TableCell>
      <TableCell>Multi-issue template with automated index overview</TableCell>

      <TableCell />
    </TableRow>
  </tbody>
</StyledTable>