livekit/agentsPublic

A framework for building realtime voice AI agents 🤖🎙️📹

AI summary: An advanced open-source framework designed to build, schedule, and orchestrate real-time, multi-modal voice AI agents.

Stars
15.3K
+47 today
Forks
4.2K
Watchers
101
Open issues
254
Open PRs
694
Contributors
~607
Commits
4.5K
Branches
360
Views (30d)
4

PythonApache-2.0Created Oct 19, 2023Last push 1d agoLatest release [email protected]+99 stars this week+422 this month

Quick answers

What is agents?
An advanced open-source framework designed to build, schedule, and orchestrate real-time, multi-modal voice AI agents.
What does agents do?
The LiveKit Agent Framework is a robust backend infrastructure explicitly engineered to develop programmable, highly conversational voice AI agents that operate seamlessly in real-time. It moves beyond simple text-based LLM wrappers by natively integrating deep telephony stacks, sophisticated Speech-To-Text (STT), and Text-To-Speech (TTS) pipelines alongside a powerful job scheduling and dispatch system. The framework is inherently multi-modal, allowing server-side agents to actively 'see, hear, and understand' end users via WebRTC streams, drastically reducing interruption friction through the use of specialized transformer models for semantic turn detection. By fully open-sourcing the entire stack, including the underlying media servers, it enables developers to construct massive, highly scalable voice AI applications capable of dynamically mixing and matching different proprietary model providers.
Who is agents for?
Backend developers and enterprise teams looking to build, scale, and self-host highly conversational, low-latency real-time voice and video AI agents. It integrates deep telephony stacks, sophisticated Speech-To-Text (STT), and Text-To-Speech (TTS) pipelines.
How do I get started with agents?
pip install "livekit-agents[openai,deepgram,cartesia]"
How popular is agents on GitHub?
livekit/agents has 15,282 stars and 4,165 forks on GitHub, and gained 99 stars in the last 7 days.
What license does agents use?
livekit/agents is released under the Apache-2.0 license.

Star history

since Aug 4, 2026
05K10K15KAug 2026Sep 2026Oct 2026Nov 2026
15.3K stars as of Nov 19, 2026. Measured daily since Aug 4, 2026; GitHub no longer exposes earlier star timestamps.

Update history

3 recorded

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-16: 7 commits2025-11-17: 6 commits2025-11-18: 2 commits2025-11-19: 3 commits2025-11-20: 11 commits2025-11-21: 3 commits2025-11-22: 1 commit2025-11-23: 0 commits2025-11-24: 10 commits2025-11-25: 9 commits2025-11-26: 4 commits2025-11-27: 2 commits2025-11-28: 2 commits2025-11-29: 1 commit2025-11-30: 1 commit2025-12-01: 5 commits2025-12-02: 9 commits2025-12-03: 10 commits2025-12-04: 2 commits2025-12-05: 7 commits2025-12-06: 0 commits2025-12-07: 1 commit2025-12-08: 2 commits2025-12-09: 5 commits2025-12-10: 4 commits2025-12-11: 2 commits2025-12-12: 6 commits2025-12-13: 0 commits2025-12-14: 2 commits2025-12-15: 17 commits2025-12-16: 16 commits2025-12-17: 11 commits2025-12-18: 13 commits2025-12-19: 4 commits2025-12-20: 1 commit2025-12-21: 2 commits2025-12-22: 2 commits2025-12-23: 7 commits2025-12-24: 3 commits2025-12-25: 2 commits2025-12-26: 0 commits2025-12-27: 4 commits2025-12-28: 1 commit2025-12-29: 0 commits2025-12-30: 2 commits2025-12-31: 1 commit2026-01-01: 1 commit2026-01-02: 4 commits2026-01-03: 5 commits2026-01-04: 0 commits2026-01-05: 3 commits2026-01-06: 2 commits2026-01-07: 4 commits2026-01-08: 5 commits2026-01-09: 1 commit2026-01-10: 1 commit2026-01-11: 1 commit2026-01-12: 4 commits2026-01-13: 3 commits2026-01-14: 4 commits2026-01-15: 3 commits2026-01-16: 6 commits2026-01-17: 2 commits2026-01-18: 0 commits2026-01-19: 1 commit2026-01-20: 4 commits2026-01-21: 12 commits2026-01-22: 6 commits2026-01-23: 4 commits2026-01-24: 0 commits2026-01-25: 2 commits2026-01-26: 5 commits2026-01-27: 3 commits2026-01-28: 5 commits2026-01-29: 4 commits2026-01-30: 8 commits2026-01-31: 6 commits2026-02-01: 5 commits2026-02-02: 6 commits2026-02-03: 8 commits2026-02-04: 3 commits2026-02-05: 6 commits2026-02-06: 15 commits2026-02-07: 4 commits2026-02-08: 2 commits2026-02-09: 6 commits2026-02-10: 1 commit2026-02-11: 5 commits2026-02-12: 3 commits2026-02-13: 7 commits2026-02-14: 1 commit2026-02-15: 15 commits2026-02-16: 16 commits2026-02-17: 2 commits2026-02-18: 2 commits2026-02-19: 2 commits2026-02-20: 5 commits2026-02-21: 3 commits2026-02-22: 3 commits2026-02-23: 2 commits2026-02-24: 6 commits2026-02-25: 4 commits2026-02-26: 8 commits2026-02-27: 5 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 10 commits2026-03-03: 3 commits2026-03-04: 8 commits2026-03-05: 6 commits2026-03-06: 3 commits2026-03-07: 2 commits2026-03-08: 2 commits2026-03-09: 9 commits2026-03-10: 12 commits2026-03-11: 4 commits2026-03-12: 6 commits2026-03-13: 3 commits2026-03-14: 1 commit2026-03-15: 0 commits2026-03-16: 5 commits2026-03-17: 4 commits2026-03-18: 10 commits2026-03-19: 7 commits2026-03-20: 7 commits2026-03-21: 1 commit2026-03-22: 0 commits2026-03-23: 10 commits2026-03-24: 5 commits2026-03-25: 5 commits2026-03-26: 3 commits2026-03-27: 6 commits2026-03-28: 2 commits2026-03-29: 4 commits2026-03-30: 7 commits2026-03-31: 4 commits2026-04-01: 10 commits2026-04-02: 5 commits2026-04-03: 7 commits2026-04-04: 0 commits2026-04-05: 3 commits2026-04-06: 6 commits2026-04-07: 8 commits2026-04-08: 12 commits2026-04-09: 2 commits2026-04-10: 4 commits2026-04-11: 12 commits2026-04-12: 2 commits2026-04-13: 4 commits2026-04-14: 7 commits2026-04-15: 12 commits2026-04-16: 7 commits2026-04-17: 2 commits2026-04-18: 2 commits2026-04-19: 3 commits2026-04-20: 4 commits2026-04-21: 3 commits2026-04-22: 7 commits2026-04-23: 9 commits2026-04-24: 8 commits2026-04-25: 3 commits2026-04-26: 3 commits2026-04-27: 4 commits2026-04-28: 10 commits2026-04-29: 2 commits2026-04-30: 6 commits2026-05-01: 3 commits2026-05-02: 1 commit2026-05-03: 5 commits2026-05-04: 6 commits2026-05-05: 6 commits2026-05-06: 5 commits2026-05-07: 5 commits2026-05-08: 6 commits2026-05-09: 1 commit2026-05-10: 1 commit2026-05-11: 3 commits2026-05-12: 6 commits2026-05-13: 14 commits2026-05-14: 7 commits2026-05-15: 3 commits2026-05-16: 2 commits2026-05-17: 8 commits2026-05-18: 7 commits2026-05-19: 8 commits2026-05-20: 5 commits2026-05-21: 7 commits2026-05-22: 2 commits2026-05-23: 1 commit2026-05-24: 10 commits2026-05-25: 11 commits2026-05-26: 2 commits2026-05-27: 9 commits2026-05-28: 2 commits2026-05-29: 11 commits2026-05-30: 10 commits2026-05-31: 0 commits2026-06-01: 7 commits2026-06-02: 13 commits2026-06-03: 5 commits2026-06-04: 10 commits2026-06-05: 4 commits2026-06-06: 1 commit2026-06-07: 1 commit2026-06-08: 6 commits2026-06-09: 4 commits2026-06-10: 7 commits2026-06-11: 17 commits2026-06-12: 5 commits2026-06-13: 0 commits2026-06-14: 1 commit2026-06-15: 6 commits2026-06-16: 8 commits2026-06-17: 6 commits2026-06-18: 6 commits2026-06-19: 10 commits2026-06-20: 0 commits2026-06-21: 1 commit2026-06-22: 4 commits2026-06-23: 5 commits2026-06-24: 8 commits2026-06-25: 3 commits2026-06-26: 8 commits2026-06-27: 3 commits2026-06-28: 0 commits2026-06-29: 4 commits2026-06-30: 5 commits2026-07-01: 4 commits2026-07-02: 7 commits2026-07-03: 8 commits2026-07-04: 0 commits2026-07-05: 1 commit2026-07-06: 9 commits2026-07-07: 9 commits2026-07-08: 3 commits2026-07-09: 11 commits2026-07-10: 4 commits2026-07-11: 1 commit2026-07-12: 4 commits2026-07-13: 4 commits2026-07-14: 6 commits2026-07-15: 2 commits2026-07-16: 5 commits2026-07-17: 16 commits2026-07-18: 4 commits2026-07-19: 0 commits2026-07-20: 6 commits2026-07-21: 4 commits2026-07-22: 6 commits2026-07-23: 5 commits2026-07-24: 12 commits2026-07-25: 0 commits2026-07-26: 0 commits2026-07-27: 3 commits2026-07-28: 7 commits2026-07-29: 7 commits2026-07-30: 11 commits2026-07-31: 12 commits2026-08-01: 3 commits2026-08-02: 7 commits2026-08-03: 10 commits2026-08-04: 8 commits2026-08-05: 7 commits2026-08-06: 10 commits2026-08-07: 5 commits2026-08-08: 0 commits2026-08-09: 2 commits2026-08-10: 11 commits2026-08-11: 7 commits2026-08-12: 9 commits2026-08-13: 7 commits2026-08-14: 4 commits2026-08-15: 0 commits2026-08-16: 1 commit2026-08-17: 9 commits2026-08-18: 3 commits2026-08-19: 4 commits2026-08-20: 9 commits2026-08-21: 6 commits2026-08-22: 1 commit2026-08-23: 1 commit2026-08-24: 10 commits2026-08-25: 5 commits2026-08-26: 16 commits2026-08-27: 5 commits2026-08-28: 5 commits2026-08-29: 3 commits2026-08-30: 6 commits2026-08-31: 4 commits2026-09-01: 12 commits2026-09-02: 9 commits2026-09-03: 6 commits2026-09-04: 10 commits2026-09-05: 0 commits2026-09-06: 1 commit2026-09-07: 8 commits2026-09-08: 15 commits2026-09-09: 7 commits2026-09-10: 5 commits2026-09-11: 7 commits2026-09-12: 7 commits2026-09-13: 1 commit2026-09-14: 8 commits2026-09-15: 12 commits2026-09-16: 6 commits2026-09-17: 8 commits2026-09-18: 12 commits2026-09-19: 1 commit2026-09-20: 1 commit2026-09-21: 10 commits2026-09-22: 12 commits2026-09-23: 14 commits2026-09-24: 1 commit2026-09-25: 6 commits2026-09-26: 0 commits2026-09-27: 0 commits2026-09-28: 0 commits2026-09-29: 6 commits2026-09-30: 8 commits2026-10-01: 4 commits2026-10-02: 5 commits2026-10-03: 8 commits2026-10-04: 9 commits2026-10-05: 5 commits2026-10-06: 0 commits2026-10-07: 4 commits2026-10-08: 7 commits2026-10-09: 14 commits2026-10-10: 5 commits2026-10-11: 9 commits2026-10-12: 10 commits2026-10-13: 19 commits2026-10-14: 4 commits2026-10-15: 8 commits2026-10-16: 6 commits2026-10-17: 2 commits2026-10-18: 2 commits2026-10-19: 18 commits2026-10-20: 27 commits2026-10-21: 13 commits2026-10-22: 14 commits2026-10-23: 17 commits2026-10-24: 1 commit2026-10-25: 11 commits2026-10-26: 10 commits2026-10-27: 15 commits2026-10-28: 4 commits2026-10-29: 5 commits2026-10-30: 3 commits2026-10-31: 1 commit2026-11-01: 2 commits2026-11-02: 27 commits2026-11-03: 13 commits2026-11-04: 7 commits2026-11-05: 12 commits2026-11-06: 0 commits2026-11-07: 2 commits2026-11-08: 0 commits2026-11-09: 9 commits2026-11-10: 11 commits2026-11-11: 5 commits2026-11-12: 1 commit2026-11-13: 0 commits2026-11-14: 0 commits
1,989 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Widely adopted

    15,282 stars

  • Very active

    1,989 commits in 52 weeks

  • Community-driven

    ~607 contributors

  • Permissive license

    Apache-2.0

  • Continuous integration

    Automated checks passing

  • Repeat trending

    9 trending appearances

What agents does

The LiveKit Agent Framework is a robust backend infrastructure explicitly engineered to develop programmable, highly conversational voice AI agents that operate seamlessly in real-time. It moves beyond simple text-based LLM wrappers by natively integrating deep telephony stacks, sophisticated Speech-To-Text (STT), and Text-To-Speech (TTS) pipelines alongside a powerful job scheduling and dispatch system. The framework is inherently multi-modal, allowing server-side agents to actively 'see, hear, and understand' end users via WebRTC streams, drastically reducing interruption friction through the use of specialized transformer models for semantic turn detection. By fully open-sourcing the entire stack, including the underlying media servers, it enables developers to construct massive, highly scalable voice AI applications capable of dynamically mixing and matching different proprietary model providers.

Backend developers and enterprise teams looking to build, scale, and self-host highly conversational, low-latency real-time voice and video AI agents. It integrates deep telephony stacks, sophisticated Speech-To-Text (STT), and Text-To-Speech (TTS) pipelines.

  • Real-Time Multi-Modal Processing: Integrates audio and video WebRTC streams directly with LLMs to allow agents to interact naturally in highly conversational real-time environments.
  • Semantic Turn Detection: Employs a dedicated transformer model specifically trained to detect when a human speaker has finished their thought, vastly reducing awkward agent interruptions.
  • Native Telephony Integration: Interfaces seamlessly with standard SIP telephony stacks, enabling agents to effortlessly make outbound calls or route inbound phone traffic.
  • Built-in Job Scheduling: Ships with a robust, integrated dispatcher that handles load balancing, task distribution, and connecting thousands of concurrent end-users to agent instances.
  • Model Provider Agnosticism: Allows developers to rapidly swap between leading STT, TTS, and LLM providers like OpenAI, Deepgram, and Cartesia based on specific workflow requirements.
  • First-Class MCP Support: Provides native integration for the Model Context Protocol, enabling voice agents to trigger complex external tools and APIs rapidly.

Where teams use it

Automated Customer Support

Enterprises deploy the framework to build highly responsive, telephony-integrated voice agents that can handle thousands of concurrent inbound customer service calls instantly.

Interactive Voice Companions

Developers utilize the multi-modal WebRTC integration to create highly engaging, low-latency AI companions for mobile apps that can both see the user and hold fluid conversations.

Dynamic Meeting Transcription

Software teams embed the agents into video conferencing platforms to actively listen, generate structured transcripts, and intelligently answer participant queries during the call.

Programmatic Outbound Calling

Logistics companies trigger the native dispatch APIs to have an agent automatically call drivers to confirm schedules and parse their verbal responses directly into a database.

Getting started: pip install "livekit-agents[openai,deepgram,cartesia]"

README

main branch
The LiveKit icon, the name of the repository and some sample code in the background.

PyPI - Version PyPI Downloads Slack community Twitter Follow Ask DeepWiki for understanding the codebase License


Looking for the JS/TS library? Check out AgentsJS

What is Agents?

The Agent Framework is designed for building realtime, programmable participants that run on servers. Use it to create conversational, multi-modal voice agents that can see, hear, and understand.

Features

  • Flexible integrations: A comprehensive ecosystem to mix and match the right STT, LLM, TTS, and Realtime API to suit your use case.
  • Integrated job scheduling: Built-in task scheduling and distribution with dispatch APIs to connect end users to agents.
  • Extensive WebRTC clients: Build client applications using LiveKit's open-source SDK ecosystem, supporting all major platforms.
  • Telephony integration: Works seamlessly with LiveKit's telephony stack, allowing your agent to make calls to or receive calls from phones.
  • Exchange data with clients: Use RPCs and other Data APIs to seamlessly exchange data with clients.
  • Semantic turn detection: Uses a transformer model to detect when a user is done with their turn, helps to reduce interruptions.
  • MCP support: Native support for MCP. Integrate tools provided by MCP servers with one line of code.
  • Builtin test framework: Write tests and use judges to ensure your agent is performing as expected.
  • Open-source: Fully open-source, allowing you to run the entire stack on your own servers, including LiveKit server, one of the most widely used WebRTC media servers.

Installation

To install the core Agents library, along with plugins for popular model providers:

pip install "livekit-agents[openai,deepgram,cartesia]"

Docs and guides

Documentation on the framework and how to use it can be found here

Building with AI coding agents

If you're using an AI coding assistant to build with LiveKit Agents, we recommend the following setup for the best results:

  1. Install the LiveKit Docs MCP server — Gives your coding agent access to up-to-date LiveKit documentation, code search across LiveKit repositories, and working examples.

  2. Install the LiveKit Agent Skill — Provides your coding agent with architectural guidance and best practices for building voice AI applications, including workflow design, handoffs, tasks, and testing patterns.

    npx skills add livekit/agent-skills --skill livekit-agents

The Agent Skill works best alongside the MCP server: the skill teaches your agent how to approach building with LiveKit, while the MCP server provides the current API details to implement it correctly.

Core concepts

  • Agent: An LLM-based application with defined instructions.
  • AgentSession: A container for agents that manages interactions with end users.
  • entrypoint: The starting point for an interactive session, similar to a request handler in a web server.
  • AgentServer: The main process that coordinates job scheduling and launches agents for user sessions.

Usage

Simple voice agent


from livekit.agents import (
    Agent,
    AgentServer,
    AgentSession,
    JobContext,
    RunContext,
    cli,
    function_tool,
    inference,
)


@function_tool
async def lookup_weather(
    context: RunContext,
    location: str,
):
    """Used to look up weather information."""

    return {"weather": "sunny", "temperature": 70}


server = AgentServer()


@server.rtc_session()
async def entrypoint(ctx: JobContext):
    session = AgentSession(
        vad=inference.VAD(),
        # any combination of STT, LLM, TTS, or realtime API can be used
        # this example shows LiveKit Inference, a unified API to access different models via LiveKit Cloud
        # to use model provider keys directly, replace with the following:
        # from livekit.plugins import deepgram, openai, cartesia
        # stt=deepgram.STT(model="nova-3"),
        # llm=openai.LLM(model="gpt-4.1-mini"),
        # tts=cartesia.TTS(model="sonic-3", voice="9626c31c-bec5-4cca-baa8-f8ba9e84c8bc"),
        stt=inference.STT("deepgram/nova-3", language="multi"),
        llm=inference.LLM("google/gemma-4-31b-it"),  # low-latency gemma, hosted on LiveKit
        tts=inference.TTS("cartesia/sonic-3", voice="9626c31c-bec5-4cca-baa8-f8ba9e84c8bc"),
    )

    agent = Agent(
        instructions="You are a friendly voice assistant built by LiveKit.",
        tools=[lookup_weather],
    )

    await session.start(agent=agent, room=ctx.room)
    await session.generate_reply(instructions="greet the user and ask about their day")


if __name__ == "__main__":
    cli.run_app(server)

You'll need the following environment variables for this example:

  • LIVEKIT_URL
  • LIVEKIT_API_KEY
  • LIVEKIT_API_SECRET

Multi-agent handoff


This code snippet is abbreviated. For the full example, see the LiveKit docs

...
class IntroAgent(Agent):
    def __init__(self) -> None:
        super().__init__(
            instructions=f"You are a story teller. Your goal is to gather a few pieces of information from the user to make the story personalized and engaging."
            "Ask the user for their name and where they are from"
        )

    async def on_enter(self):
        self.session.generate_reply(instructions="greet the user and gather information")

    @function_tool
    async def information_gathered(
        self,
        context: RunContext,
        name: str,
        location: str,
    ):
        """Called when the user has provided the information needed to make the story personalized and engaging.

        Args:
            name: The name of the user
            location: The location of the user
        """

        context.userdata.name = name
        context.userdata.location = location

        story_agent = StoryAgent(name, location)
        return story_agent, "Let's start the story!"


class StoryAgent(Agent):
    def __init__(self, name: str, location: str) -> None:
        super().__init__(
            instructions=f"You are a storyteller. Use the user's information in order to make the story personalized."
            f"The user's name is {name}, from {location}",
            # override the default model, switching to Realtime API from standard LLMs
            llm=openai.realtime.RealtimeModel(voice="echo"),
            chat_ctx=chat_ctx,
        )

    async def on_enter(self):
        self.session.generate_reply()


@server.rtc_session()
async def entrypoint(ctx: JobContext):
    userdata = StoryData()
    session = AgentSession[StoryData](
        vad=inference.VAD(),
        stt="deepgram/nova-3",
        llm="google/gemma-4-31b-it",  # low-latency gemma, hosted on LiveKit
        tts="cartesia/sonic-3:9626c31c-bec5-4cca-baa8-f8ba9e84c8bc",
        userdata=userdata,
    )

    await session.start(
        agent=IntroAgent(),
        room=ctx.room,
    )
...

Testing

Automated tests are essential for building reliable agents, especially with the non-deterministic behavior of LLMs. LiveKit Agents include native test integration to help you create dependable agents.

@pytest.mark.asyncio
async def test_no_availability() -> None:
    llm = google.LLM()
    async with AgentSession(llm=llm) as sess:
        await sess.start(MyAgent())
        result = await sess.run(
            user_input="Hello, I need to place an order."
        )
        result.expect.skip_next_event_if(type="message", role="assistant")
        result.expect.next_event().is_function_call(name="start_order")
        result.expect.next_event().is_function_call_output()
        await (
            result.expect.next_event()
            .is_message(role="assistant")
            .judge(llm, intent="assistant should be asking the user what they would like")
        )

Examples

For more examples and detailed setup instructions, see the examples directory. For even more examples, see the python-agents-examples repository.

🎙️ Starter Agent

A starter agent optimized for voice conversations.

Code

☎️ Outbound caller

Agent that makes outbound phone calls

Code

🔌 MCP support

Use tools from MCP servers

Code

📝 Multi-user transcriber

Produce transcriptions from all users in the room

Code

🎥 Video avatars

Add an AI avatar with Tavus, Bithuman, LemonSlice, and more

Code

👁️ Gemini Live vision

Full example (including iOS app) of Gemini Live agent that can see.

Code

Running your agent

Testing in terminal

python myagent.py console

Runs your agent in terminal mode, enabling local audio input and output for testing. This mode doesn't require external servers or dependencies and is useful for quickly validating behavior.

Developing with LiveKit clients

python myagent.py dev

Starts the agent server and enables hot reloading when files change. This mode allows each process to host multiple concurrent agents efficiently.

The agent connects to LiveKit Cloud or your self-hosted server. Set the following environment variables:

  • LIVEKIT_URL
  • LIVEKIT_API_KEY
  • LIVEKIT_API_SECRET

You can connect using any LiveKit client SDK or telephony integration. To get started quickly, try the Agents Playground.

Running for production

python myagent.py start

Runs the agent with production-ready optimizations.

License

The Agents framework is licensed under Apache-2.0. The LiveKit turn detection models are licensed under the LiveKit Model License.

Contributing

The Agents framework is under active development in a rapidly evolving field. We welcome and appreciate contributions of any kind, be it feedback, bugfixes, features, new plugins and tools, or better documentation. You can file issues under this repo, open a PR, or chat with us in the LiveKit community.

Development setup

This project uses uv for package management. To install dependencies for development:

uv sync --all-extras --dev

Examples

This project includes many examples in the examples directory. To run them, create the file examples/.env with credentials for LiveKit Server and any necessary model providers (see examples/.env.example), then run:

uv run examples/voice_agents/basic_agent.py dev

For more information, see the examples README.

Tests

Unit tests are in the tests directory and can be run with:

uv run pytest --unit

Integration tests for each plugin require various API credentials and run automatically in GitHub CI for PRs submitted by project maintainers. See the tests workflow for details.

Formatting

This project uses ruff for formatting and linting:

uv run ruff format
uv run ruff check --fix

Documentation

To generate docs locally with pdoc:

uv sync --all-extras --group docs
uv run --active pdoc --skip-errors --html --output-dir=docs livekit


LiveKit Ecosystem
Agents SDKsPython · Node.js
LiveKit SDKsBrowser · Swift · Android · Flutter · React Native · Rust · Node.js · Python · Unity · Unity (WebGL) · ESP32 · C++
Starter AppsPython Agent · TypeScript Agent · React App · SwiftUI App · Android App · Flutter App · React Native App · Web Embed
UI ComponentsReact · Android Compose · SwiftUI · Flutter
Server APIsNode.js · Golang · Ruby · Java/Kotlin · Python · Rust · PHP (community) · .NET (community)
ResourcesDocs · Docs MCP Server · CLI · LiveKit Cloud
LiveKit Server OSSLiveKit server · Egress · Ingress · SIP
CommunityDeveloper Community · Slack · X · YouTube
View on GitHub

Recent activity

commits and pull requests

Releases and announcements

382 total
  1. ## Responses API through LiveKit Inference You can now use the Responses API with your LiveKit Inference credentials, including structured output and web search. REST is the default; opt into WebSocket transport to reuse connections across turns. ```python from livekit.agents import inference llm = inference.responses.LLM("openai/gpt-4.1", use_websocket=True) ``` ## New providers and models - **Zoom AI**: Zoom Scribe STT with live streaming and per-utterance recognition. - **Kalpa**: `kalpa-tts-1` streaming TTS in English and Hindi. - **Rime**: STT and Prism speech-to-speech through the standard realtime interface; both require Python 3.11+, and STT requires the `stt` extra. - **Fish Audio**: `transcribe-stream-1` realtime STT with word timings and recognition context. - **OpenAI**: `gpt-realtime-translate` through the beta translation interface, with `gpt-realtime-whisper` input transcription. - **Google**: `gemini-3.5-live-translate-preview` translation through Gemini API and Vertex AI. - **Respeecher**: public Swedish, Brazilian Portuguese, German, and Arabic TTS models. ## Security - **Respeecher**: moves WebSocket API keys from request URLs to handshake headers, keeping

  2. ## Recording bitrate control You can use constant-bitrate recording to avoid misleading duration estimates in players such as QuickLook, or match Egress’s 128 kb/s encoding. `RecorderIO` now lets you set the bitrate and encoding mode; defaults are unchanged. ```python RecorderIO(agent_session=session, bit_rate=128_000, constant_bit_rate=True) ``` ## New providers and models - **Reson8**: new STT plugin for batch and realtime transcription, including server-side turn detection. - **Mistral Voxtral 3**: adds `voxtral-mini-transcribe-3`, `voxtral-small-transcribe-3`, `voxtral-mini-transcribe-realtime-3`, and `voxtral-mini-tts-3`, plus 36 TTS voice presets. - **Inworld**: adds `inworld-tts-2-flash` through the plugin and LiveKit Inference. - **AssemblyAI**: adds typed LiveKit Inference TTS support for `assemblyai` and `assemblyai/assemblyai-tts-1`. ## Breaking changes - **Mistral**: `api_mode` is now ignored; migrate Chat Completions usage to Conversations. For `recognize()`, explicitly select a batch model; replace removed known IDs `voxtral-mini-latest` and `voxtral-mini-2507`. Without VAD or server-side turn detection, standalone realtime streams need `stream.flush()`. ## Beh

  3. ## Decisions through LiveKit Inference You can evaluate named decisions with LiveKit credentials instead of a provider key. `inference.DecisionModel` batches evaluations and reports refusals per decision without discarding the other answers. Access requires a project feature flag. ```python model = inference.DecisionModel("openai/gpt-6-luna-decisions") response = await model.evaluate( input=chat_ctx, decisions={"handoff": llm.Probability("The caller requests a human.")}, ) ``` ## Custom LLM request attributes You can attach prompt metadata directly to the provider’s `llm_request` span from your custom `llm_node`, without a custom OpenTelemetry processor. Attributes stay scoped to that node’s calls. ```python async def llm_node(self, chat_ctx, tools, model_settings): gen_ai.set_llm_request_attributes( {"langfuse.observation.prompt.name": "support-agent"} ) async for chunk in Agent.default.llm_node( self, chat_ctx, tools, model_settings ): yield chunk ``` ## Silent tool progress You can record background-tool progress without prompting a spoken response. Final background-tool results can now trigger follow-up tool calls. ```pyth

  4. ## GPT-Live through LiveKit Inference You can now run GPT-Live with your LiveKit credentials instead of a separate OpenAI key. `inference.DuplexModel` handles its protocol, and you can adopt it directly with a model string: ```python session = AgentSession(llm="openai/gpt-live-1") ``` ## New providers and models - **OpenAI GPT-Live 1**: now available through LiveKit Inference. - **Google Gemini Live**: adds Inference model-string support for `google/gemini-3.8-live`, `google/gemini-3.8-live-extended-thinking`, and `google/gemini-live`. - **xAI Grok Voice 3.0**: replaces Think Fast 2.0 in the Inference and xAI plugin model lists. - **TypeSafe Jev**: a new decision-model plugin supports `jev-1.13.0` and OpenRouter’s Decisions API for background probability, choice, and score evaluations without delaying replies. ## Breaking changes - **OpenAI realtime**: `inference.RealtimeModel` no longer subclasses the plugin’s `openai.realtime.RealtimeModel`; update `isinstance` checks. Incidental wildcard exports such as `realtime_model.logger` are no longer available. - **GPT-Live voices**: `cedar` replaces the unsupported `aster` voice; update voice selections. ## Behavior changes - **L

  5. ## Realtime E2E latency You can now measure realtime replies from the last detected user speech to first assistant playback when you configure local VAD. Read the latency from assistant message metrics: ```python @session.on("conversation_item_added") def on_message(event): if event.item.type == "message" and event.item.role == "assistant": print(event.item.metrics.get("e2e_latency")) ``` ## New providers and models - **Claude Opus 5, Opus 5.5 and Sonnet 5.5**: model support through the Anthropic SDK upgrade. ## Breaking changes - **Telemetry**: fallback attributes `lk.fallback.label` and `lk.fallback.index` move to adapter request spans; update trace queries for the flattened hierarchy. - **Anthropic**: custom SDK HTTP clients must use `httpx2`, not `httpx`. - **OpenTelemetry**: replace the removed Events API with `LogRecord(event_name=...)`; custom `Logger` subclasses must implement `enabled()`. ## Behavior changes - **Dependencies**: now requires `openai>=3.19,<4`, `mcp>=2.2,<3`, `websockets>=17.1,<17.2`, and OpenTelemetry `>=1.45,<1.46`; Anthropic requires `>=1.8,<2`, and turn detection requires `onnxruntime>=1.30,<1.31`. - **TLS**: contexts are cached per t

Code frequency

additions and deletions
+56.2K-56.2KWeek of 2025-11-16: +5,728 linesWeek of 2025-11-16: -4,411 linesWeek of 2025-11-23: +5,322 linesWeek of 2025-11-23: -4,568 linesWeek of 2025-11-30: +3,022 linesWeek of 2025-11-30: -848 linesWeek of 2025-12-07: +922 linesWeek of 2025-12-07: -145 linesWeek of 2025-12-14: +15,978 linesWeek of 2025-12-14: -12,813 linesWeek of 2025-12-21: +2,442 linesWeek of 2025-12-21: -1,204 linesWeek of 2025-12-28: +103 linesWeek of 2025-12-28: -65 linesWeek of 2026-01-04: +2,115 linesWeek of 2026-01-04: -795 linesWeek of 2026-01-11: +6,541 linesWeek of 2026-01-11: -5,857 linesWeek of 2026-01-18: +3,309 linesWeek of 2026-01-18: -635 linesWeek of 2026-01-25: +9,480 linesWeek of 2026-01-25: -5,684 linesWeek of 2026-02-01: +10,894 linesWeek of 2026-02-01: -8,792 linesWeek of 2026-02-08: +5,264 linesWeek of 2026-02-08: -8,396 linesWeek of 2026-02-15: +3,469 linesWeek of 2026-02-15: -2,242 linesWeek of 2026-02-22: +4,905 linesWeek of 2026-02-22: -945 linesWeek of 2026-03-01: +4,018 linesWeek of 2026-03-01: -769 linesWeek of 2026-03-08: +5,162 linesWeek of 2026-03-08: -993 linesWeek of 2026-03-15: +11,239 linesWeek of 2026-03-15: -4,540 linesWeek of 2026-03-22: +6,634 linesWeek of 2026-03-22: -670 linesWeek of 2026-03-29: +8,080 linesWeek of 2026-03-29: -4,682 linesWeek of 2026-04-05: +6,278 linesWeek of 2026-04-05: -3,485 linesWeek of 2026-04-12: +6,276 linesWeek of 2026-04-12: -1,123 linesWeek of 2026-04-19: +4,196 linesWeek of 2026-04-19: -1,482 linesWeek of 2026-04-26: +6,520 linesWeek of 2026-04-26: -3,053 linesWeek of 2026-05-03: +5,686 linesWeek of 2026-05-03: -3,454 linesWeek of 2026-05-10: +9,085 linesWeek of 2026-05-10: -6,192 linesWeek of 2026-05-17: +7,166 linesWeek of 2026-05-17: -2,773 linesWeek of 2026-05-24: +10,279 linesWeek of 2026-05-24: -4,277 linesWeek of 2026-05-31: +12,048 linesWeek of 2026-05-31: -4,962 linesWeek of 2026-06-07: +8,251 linesWeek of 2026-06-07: -3,535 linesWeek of 2026-06-14: +10,255 linesWeek of 2026-06-14: -1,866 linesWeek of 2026-06-21: +7,549 linesWeek of 2026-06-21: -1,905 linesWeek of 2026-06-28: +5,733 linesWeek of 2026-06-28: -325 linesWeek of 2026-07-05: +6,798 linesWeek of 2026-07-05: -2,226 linesWeek of 2026-07-12: +8,185 linesWeek of 2026-07-12: -10,858 linesWeek of 2026-07-19: +7,405 linesWeek of 2026-07-19: -1,840 linesWeek of 2026-07-26: +7,031 linesWeek of 2026-07-26: -1,527 linesWeek of 2026-08-02: +14,131 linesWeek of 2026-08-02: -3,155 linesWeek of 2026-08-09: +4,835 linesWeek of 2026-08-09: -937 linesWeek of 2026-08-16: +5,807 linesWeek of 2026-08-16: -1,414 linesWeek of 2026-08-23: +15,109 linesWeek of 2026-08-23: -2,293 linesWeek of 2026-08-30: +12,737 linesWeek of 2026-08-30: -5,140 linesWeek of 2026-09-06: +22,302 linesWeek of 2026-09-06: -1,325 linesWeek of 2026-09-13: +14,088 linesWeek of 2026-09-13: -4,768 linesWeek of 2026-09-20: +11,256 linesWeek of 2026-09-20: -963 linesWeek of 2026-09-27: +7,524 linesWeek of 2026-09-27: -710 linesWeek of 2026-10-04: +10,998 linesWeek of 2026-10-04: -1,784 linesWeek of 2026-10-11: +13,018 linesWeek of 2026-10-11: -2,773 linesWeek of 2026-10-18: +18,923 linesWeek of 2026-10-18: -1,960 linesWeek of 2026-10-25: +13,636 linesWeek of 2026-10-25: -4,229 linesWeek of 2026-11-01: +34,320 linesWeek of 2026-11-01: -4,856 linesWeek of 2026-11-08: +56,183 linesWeek of 2026-11-08: -46,309 linesNov 16, 2025Nov 8, 2026
+498.2K lines added, -206.6K removed over the last year.

Commits per week

last 52 weeks
920Week of 2025-11-16: 33 commitsWeek of 2025-11-23: 28 commitsWeek of 2025-11-30: 34 commitsWeek of 2025-12-07: 20 commitsWeek of 2025-12-14: 64 commitsWeek of 2025-12-21: 20 commitsWeek of 2025-12-28: 14 commitsWeek of 2026-01-04: 16 commitsWeek of 2026-01-11: 23 commitsWeek of 2026-01-18: 27 commitsWeek of 2026-01-25: 33 commitsWeek of 2026-02-01: 47 commitsWeek of 2026-02-08: 25 commitsWeek of 2026-02-15: 45 commitsWeek of 2026-02-22: 28 commitsWeek of 2026-03-01: 32 commitsWeek of 2026-03-08: 37 commitsWeek of 2026-03-15: 34 commitsWeek of 2026-03-22: 31 commitsWeek of 2026-03-29: 37 commitsWeek of 2026-04-05: 47 commitsWeek of 2026-04-12: 36 commitsWeek of 2026-04-19: 37 commitsWeek of 2026-04-26: 29 commitsWeek of 2026-05-03: 34 commitsWeek of 2026-05-10: 36 commitsWeek of 2026-05-17: 38 commitsWeek of 2026-05-24: 55 commitsWeek of 2026-05-31: 40 commitsWeek of 2026-06-07: 40 commitsWeek of 2026-06-14: 37 commitsWeek of 2026-06-21: 32 commitsWeek of 2026-06-28: 28 commitsWeek of 2026-07-05: 38 commitsWeek of 2026-07-12: 41 commitsWeek of 2026-07-19: 33 commitsWeek of 2026-07-26: 43 commitsWeek of 2026-08-02: 47 commitsWeek of 2026-08-09: 40 commitsWeek of 2026-08-16: 33 commitsWeek of 2026-08-23: 45 commitsWeek of 2026-08-30: 47 commitsWeek of 2026-09-06: 50 commitsWeek of 2026-09-13: 48 commitsWeek of 2026-09-20: 44 commitsWeek of 2026-09-27: 31 commitsWeek of 2026-10-04: 44 commitsWeek of 2026-10-11: 58 commitsWeek of 2026-10-18: 92 commitsWeek of 2026-10-25: 49 commitsWeek of 2026-11-01: 63 commitsWeek of 2026-11-08: 26 commitsNov 16, 2025Nov 8, 2026
2K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 16 commitsSun 1:00 — 7 commitsSun 2:00 — 8 commitsSun 3:00 — 8 commitsSun 4:00 — 5 commitsSun 5:00 — 4 commitsSun 6:00 — 1 commitsSun 7:00 — 4 commitsSun 8:00 — 4 commitsSun 9:00 — 3 commitsSun 10:00 — 11 commitsSun 11:00 — 16 commitsSun 12:00 — 20 commitsSun 13:00 — 15 commitsSun 14:00 — 20 commitsSun 15:00 — 11 commitsSun 16:00 — 19 commitsSun 17:00 — 20 commitsSun 18:00 — 13 commitsSun 19:00 — 18 commitsSun 20:00 — 12 commitsSun 21:00 — 21 commitsSun 22:00 — 29 commitsSun 23:00 — 19 commitsMon 0:00 — 11 commitsMon 1:00 — 18 commitsMon 2:00 — 11 commitsMon 3:00 — 7 commitsMon 4:00 — 8 commitsMon 5:00 — 0 commitsMon 6:00 — 1 commitsMon 7:00 — 12 commitsMon 8:00 — 19 commitsMon 9:00 — 40 commitsMon 10:00 — 47 commitsMon 11:00 — 48 commitsMon 12:00 — 54 commitsMon 13:00 — 51 commitsMon 14:00 — 82 commitsMon 15:00 — 59 commitsMon 16:00 — 53 commitsMon 17:00 — 54 commitsMon 18:00 — 27 commitsMon 19:00 — 26 commitsMon 20:00 — 44 commitsMon 21:00 — 24 commitsMon 22:00 — 32 commitsMon 23:00 — 29 commitsTue 0:00 — 31 commitsTue 1:00 — 17 commitsTue 2:00 — 5 commitsTue 3:00 — 16 commitsTue 4:00 — 7 commitsTue 5:00 — 2 commitsTue 6:00 — 10 commitsTue 7:00 — 13 commitsTue 8:00 — 17 commitsTue 9:00 — 34 commitsTue 10:00 — 46 commitsTue 11:00 — 49 commitsTue 12:00 — 53 commitsTue 13:00 — 51 commitsTue 14:00 — 64 commitsTue 15:00 — 67 commitsTue 16:00 — 62 commitsTue 17:00 — 60 commitsTue 18:00 — 47 commitsTue 19:00 — 33 commitsTue 20:00 — 41 commitsTue 21:00 — 53 commitsTue 22:00 — 29 commitsTue 23:00 — 44 commitsWed 0:00 — 25 commitsWed 1:00 — 16 commitsWed 2:00 — 10 commitsWed 3:00 — 10 commitsWed 4:00 — 4 commitsWed 5:00 — 7 commitsWed 6:00 — 5 commitsWed 7:00 — 9 commitsWed 8:00 — 22 commitsWed 9:00 — 33 commitsWed 10:00 — 44 commitsWed 11:00 — 45 commitsWed 12:00 — 38 commitsWed 13:00 — 51 commitsWed 14:00 — 67 commitsWed 15:00 — 50 commitsWed 16:00 — 58 commitsWed 17:00 — 52 commitsWed 18:00 — 38 commitsWed 19:00 — 48 commitsWed 20:00 — 49 commitsWed 21:00 — 37 commitsWed 22:00 — 59 commitsWed 23:00 — 35 commitsThu 0:00 — 27 commitsThu 1:00 — 26 commitsThu 2:00 — 13 commitsThu 3:00 — 11 commitsThu 4:00 — 5 commitsThu 5:00 — 8 commitsThu 6:00 — 8 commitsThu 7:00 — 9 commitsThu 8:00 — 10 commitsThu 9:00 — 45 commitsThu 10:00 — 67 commitsThu 11:00 — 50 commitsThu 12:00 — 47 commitsThu 13:00 — 51 commitsThu 14:00 — 51 commitsThu 15:00 — 74 commitsThu 16:00 — 46 commitsThu 17:00 — 36 commitsThu 18:00 — 26 commitsThu 19:00 — 31 commitsThu 20:00 — 30 commitsThu 21:00 — 32 commitsThu 22:00 — 37 commitsThu 23:00 — 21 commitsFri 0:00 — 21 commitsFri 1:00 — 31 commitsFri 2:00 — 23 commitsFri 3:00 — 13 commitsFri 4:00 — 4 commitsFri 5:00 — 6 commitsFri 6:00 — 3 commitsFri 7:00 — 10 commitsFri 8:00 — 26 commitsFri 9:00 — 35 commitsFri 10:00 — 46 commitsFri 11:00 — 32 commitsFri 12:00 — 48 commitsFri 13:00 — 57 commitsFri 14:00 — 64 commitsFri 15:00 — 48 commitsFri 16:00 — 39 commitsFri 17:00 — 38 commitsFri 18:00 — 32 commitsFri 19:00 — 19 commitsFri 20:00 — 24 commitsFri 21:00 — 22 commitsFri 22:00 — 31 commitsFri 23:00 — 16 commitsSat 0:00 — 15 commitsSat 1:00 — 18 commitsSat 2:00 — 9 commitsSat 3:00 — 6 commitsSat 4:00 — 8 commitsSat 5:00 — 5 commitsSat 6:00 — 3 commitsSat 7:00 — 5 commitsSat 8:00 — 10 commitsSat 9:00 — 9 commitsSat 10:00 — 12 commitsSat 11:00 — 13 commitsSat 12:00 — 8 commitsSat 13:00 — 12 commitsSat 14:00 — 15 commitsSat 15:00 — 10 commitsSat 16:00 — 15 commitsSat 17:00 — 13 commitsSat 18:00 — 10 commitsSat 19:00 — 8 commitsSat 20:00 — 4 commitsSat 21:00 — 10 commitsSat 22:00 — 7 commitsSat 23:00 — 14 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.
DateListRankStars gained
Aug 31, 2026daily#15+254
Aug 30, 2026daily#15+254
Aug 29, 2026daily#14+256
Aug 28, 2026daily#14+14
Aug 11, 2026weekly#11+1,138
Aug 10, 2026weekly#11+1,138
Aug 6, 2026daily#10+432
Aug 5, 2026daily#10+432
Aug 4, 2026daily#12+148