LiveKit: Realtime Server for Voice, Video and AI Agents

What LiveKit is

LiveKit is an open-source platform for building voice, video and physical AI agents, and this repository is its core: the LiveKit server. The README describes it as a scalable, distributed WebRTC SFU (Selective Forwarding Unit) that moves realtime audio, video and data between people, devices and AI models. It is written in Go on top of the Pion WebRTC implementation.

WebRTC is hard to run at scale. Peer-to-peer calls fall apart beyond a handful of participants, NAT traversal needs TURN, and every client platform has its own media stack. An SFU solves the fan-out problem by receiving each participant's streams once and forwarding them selectively to everyone else. LiveKit packages that server together with SDKs for web, mobile, desktop, embedded and server environments, so application developers work with rooms, participants and tracks instead of raw WebRTC plumbing.

The project has shifted toward AI over time. Its current README leads with voice AI, and the key idea is that an AI agent joins a room as a participant in the same way a browser or phone does. That makes LiveKit the transport layer for the companion LiveKit Agents framework, while remaining a general-purpose media server for conferencing, livestreaming and robotics.

How LiveKit works

The model is built around rooms. Clients connect to a room with an access token, a JWT that encodes their identity and the permissions they have been granted, then publish and subscribe to audio, video and data tracks. The server forwards media between participants, handling simulcast layers and selective subscription so each subscriber receives only what it needs.

Agents are just another participant. With agent dispatch, the server can route an agent into a room automatically or on demand. An agent built with LiveKit Agents (Python or Node.js) subscribes to a user's audio, runs it through speech-to-text, a language model and text-to-speech, and publishes the response back into the room. The README's example wires up an AgentSession with STT, LLM, TTS and a turn detector in a few lines of Python.

Around the core server sit separate open-source services listed in the README's ecosystem table under LiveKit Server OSS: Egress, Ingress and SIP, the last of which provides telephony over SIP. For multi-node deployments the server supports distributed and multi-region setups.

Key features

• Distributed WebRTC SFU: a scalable media server that forwards streams selectively instead of mixing them.
• Agents as participants: people, devices and AI agents share the same room model, with agent dispatch for routing agents in.
• SDKs everywhere: browser, Swift, Android, Flutter, React Native, Rust, Node.js, Python, Unity, Unity WebGL, ESP32 and C++ client SDKs, plus server SDKs for Go, Node.js, Ruby, Java/Kotlin, Python and Rust, with community PHP and .NET versions.
• JWT authentication: tokens carry identity and per-room permissions.
• Robust connectivity: UDP, TCP and TURN for clients behind restrictive networks.
• Simulcast and SVC codecs: VP9 and AV1 scalable video coding alongside simulcast for adaptive quality.
• Speaker detection and selective subscription: useful for large rooms and active-speaker layouts.
• Moderation APIs and webhooks: server-side control over participants plus event notifications.
• End-to-end encryption: available as a documented feature.
• Data tracks: low-latency data channels aimed at telemetry and teleoperation.
• SIP telephony: connect phone calls into rooms, which is how voice agents answer real phone numbers.
• Simple deployment: a single binary, Docker or Kubernetes, with official Docker images and Helm charts.

Getting started

Install the server on macOS with Homebrew:

brew install livekit

Or on Linux with the install script:

curl -sSL https://get.livekit.io | bash

Windows builds are available from the releases page. The README recommends installing the LiveKit CLI alongside the server, since it creates tokens, calls server APIs, generates test traffic and scaffolds agents.

Run the server in development mode with livekit-server --dev. It uses a placeholder key pair:

API Key: devkey
API Secret: secret

Generate a token for a test user:

lk token create \
    --api-key devkey --api-secret secret \
    --join --room my-first-room --identity user1 \
    --valid-for 24h

Paste that token into the hosted example app to join the room, then simulate a second participant publishing a looped demo video:

lk room join \
    --url ws://localhost:7880 \
    --api-key devkey --api-secret secret \
    --identity bot-user1 \
    --publish-demo \
    my-first-room

To add an AI agent, follow the Voice AI quickstart in the docs. An agent connects to a self-hosted server the same way it connects to LiveKit Cloud; without Cloud, the README notes you use model plugins in place of LiveKit Inference. Building the server from source requires Go 1.26 or newer and uses ./bootstrap.sh followed by mage.

Use cases

• Voice AI agents: realtime assistants, support agents and phone agents that combine STT, LLM and TTS over WebRTC or SIP.
• Video conferencing: the LiveKit Meet demo is an open-source example of a full meeting app.
• Livestreaming: the examples include streaming from OBS Studio into a room.
• Spatial audio and virtual spaces: there is a spatial audio demo with source available.
• Robotics and teleoperation: data tracks for low-latency telemetry, plus video from devices. The README cites Polymath Robotics as a customer story.
• Telephony bridges: bring PSTN callers into rooms with people or agents via SIP.

How it compares

Other open-source SFUs such as Jitsi Videobridge, mediasoup and Janus occupy the same layer of the stack, and each takes a different approach to packaging and APIs. LiveKit's distinguishing choices, based on its README, are the breadth of first-party SDKs, a room-and-token model that hides most WebRTC detail, a first-party agents framework, and companion services for egress, ingress and SIP. Teams that want low-level control of media routing in their own server process may prefer a library-style SFU; teams that want a complete platform with client SDKs tend to look at LiveKit.

On the hosted side, LiveKit competes with commercial realtime video APIs. The difference is that the server itself is Apache-2.0 and self-hostable, with LiveKit Cloud as an optional managed option.

Things to know before adopting

• Self-hosted versus Cloud: the open-source server covers media routing. The README says LiveKit Cloud adds agent hosting, model inference, telephony and observability on top, and runs in 19+ regions. LiveKit Inference, which supplies models without per-provider keys, is a Cloud feature; self-hosted agents use model plugins instead.
• Operational work: the dev-mode server is a starting point only; production setups are covered separately in the self-hosting and deployment docs, including distributed and multi-region topologies. Expect more networking work than for a stateless HTTP service, since clients connect over UDP, TCP or TURN.
• Several repos, not one: Egress, Ingress and SIP live in separate repositories and are deployed alongside the server when needed.
• Dev mode keys: --dev uses the fixed devkey/secret pair and is for local testing only.
• Maturity: the repository dates to September 2020, and the README lists production users including Salesforce, Nvidia, Oracle, SAP, Spotify and Coursera, and claims billions of calls a year.

Project activity

As of October 2026 the repository has roughly 21,200 stars. It was created on 30 September 2020, is written primarily in Go, and is licensed under Apache-2.0. The source is at github.com/livekit/livekit and documentation lives at docs.livekit.io, which also offers a Docs MCP server for coding agents. The community gathers on Slack and in the LiveKit developer community forum.