Josh Allmann October 2026

Tagline: Workload isolation with delegated capacity management

Summary

The Live Runner makes it easier than ever to bring new capabilities to the Livepeer network, but those capabilities still have to be manually provisioned. That limits how quickly Livepeer can respond to new demand, scale successful applications, and turn ecosystem interest into sustained usage and network fees.

Capability management can be automated with a proposed gVisor sandbox and a container orchestration layer using the Live Runner. Beyond improving isolation, this gives Livepeer a way to bring new capacity online quickly, shift resources toward applications that are working, and make more frequent and ambitious demand bets without requiring every operator to manually install and maintain every new capability.

Orchestrators can delegate sandbox management authority to allocators, which decide what capabilities to run and where, coordinate capacity around demand, and provide observability across workloads and operators. Done well, this can make the network more responsive, easier to build on, and better able to convert new applications into meaningful economic value.

Background

Today, the Live Runner offers a relatively easy way for operators to make applications available on Livepeer. The architecture handles capability discovery, orchestrator selection, traffic routing, session management, and network payments. This already supports applications beyond a fixed collection of AI pipelines. For example, there is a StreamDiffusion integration that runs an unmodified third-party server behind Livepeer, communicating via WebSocket and MJPEG. https://github.com/livepeer/streamdiffusion-livepeer-runner The orchestrator registers the application through a configuration file, while the application itself contains no Livepeer code.

While the Live Runner architecture is already fairly general, it has two important shortcomings: workloads do not have a strong isolation and management boundary, and deployment and allocation are almost entirely manual. Both have straightforward technical solutions. The larger question is who should have the authority to assign workloads across a decentralized network.

Isolation and Management

Even workloads developed or approved by Livepeer contributors should be treated as potentially untrusted. Vulnerabilities are inevitable, and exploitation can quickly follow with AI assistance. Livepeer's combination of crypto, GPUs and compute paints a particularly attractive target.

Today there is no consistent security boundary around a Live Runner application:

There is also substantial operational variation between orchestrators. Logs and metrics may or may not be available; CUDA, drivers and other host software differ; and machines with the same nominal GPU may have different CPU, memory, storage and network characteristics. This makes end-to-end diagnosis difficult for developers and customers, and makes network-wide performance difficult to characterize.

Containers and Sandboxing

For most developers, a container is already a convenient packaging interface. Containers provide a portable way to define an application and its dependencies. These containers do not need to be Livepeer-aware.

But a container image alone does not describe how that application should run. Those concerns require an orchestration layer around the container; this is typically done with Docker Compose, Kubernetes, Nomad, or managed offerings such as GKE or EKS.

The sandbox can provide that layer for Livepeer. A sandbox deployment can combine a container image with an explicit execution policy: resource requirements, networking rules, supported hardware, health checks and lifecycle configuration. It should isolate workloads from the host and from one another, enforce CPU, GPU, memory and network policy, and expose consistent lifecycle and telemetry interfaces regardless of how the application itself is implemented.