# LiveKit Agents: features, protocols, quickstart

## TL;DR

LiveKit Agents is LiveKit's Apache-2.0 Python framework for realtime voice and video agents that join LiveKit rooms as participants. It combines speech-to-text, LLM and text-to-speech or realtime models with turn detection, agent handoffs, tasks, MCP tools and telephony. It suits teams building phone or in-app voice agents, self-hosted or on LiveKit Cloud.

## Key facts

| Field | Value |
| --- | --- |
| Type | Framework |
| Languages / SDKs | Python |
| License | Apache-2.0 |
| Pricing model | [Open core](https://livekit.com/pricing) |
| Orchestration pattern | Handoff |
| GitHub stars | 14,431 (as of 2026-09-30) |
| GitHub forks | 3,826 |
| Last push | 2026-09-30 |
| Latest release | livekit-agents@1.8.3 |
| Repository | [livekit/agents](https://github.com/livekit/agents) |
| Website | [livekit.com](https://livekit.com) |
| Documentation | [docs.livekit.io](https://docs.livekit.io/agents/) |
| Last verified | 2026-09-30 |

## Key features

- `AgentSession` runs a voice pipeline built from any mix of VAD, STT, LLM and TTS plugins, or a realtime speech model, for one user session. ([source](https://docs.livekit.io/agents/logic/sessions/))
- Agent handoffs: a function tool returns a new `Agent` (optionally with the current `chat_ctx`) to transfer control of the conversation. ([source](https://docs.livekit.io/agents/logic/agents-handoffs/))
- `AgentTask` and `TaskGroup` for short-lived steps that return a typed result, with the option to revisit earlier steps in a group. ([source](https://docs.livekit.io/agents/logic/tasks/))
- Prebuilt tasks for collecting names, emails, addresses, dates of birth, phone numbers, card details and DTMF input, plus warm transfer to a human. ([source](https://docs.livekit.io/agents/prebuilt/tasks/))
- Supervisor pattern in which one agent keeps the session and routes work to specialist tasks. ([source](https://docs.livekit.io/agents/logic/patterns/supervisor/))
- Turn detection with a transformer-based end-of-turn model, VAD and adaptive interruption handling. ([source](https://docs.livekit.io/agents/logic/turns/))
- MCP tools through `mcp.MCPToolset` wrapping HTTP or stdio MCP servers (Python SDK). ([source](https://docs.livekit.io/agents/logic/tools/mcp/))
- Built-in test framework with LLM judges, plus job dispatch through `AgentServer` and SIP telephony. ([source](https://github.com/livekit/agents/blob/main/README.md))

## Architecture and orchestration pattern

Pattern: Handoff.

A LiveKit Agents program is an `AgentServer` process that registers with a LiveKit server and receives jobs through dispatch. For each job, an entrypoint joins a LiveKit room and starts an `AgentSession`, which wires audio and video to a pipeline of VAD, speech-to-text, LLM and text-to-speech plugins, or to a realtime speech model. The agent is a participant in the room, so clients connect through LiveKit's WebRTC SDKs or by phone over SIP.

Within a session, one `Agent` is active at a time. An agent holds instructions, tools and optionally its own models; a tool can return another agent to hand off control, and the docs describe passing `chat_ctx` to keep history or starting fresh. Tasks take temporary control to complete one objective and return a typed result, and task groups chain tasks with backtracking. The docs present these as combinable patterns: single agent with tools, supervisor with tasks, subagent delegation to a background model, and handoffs.

Conversation history lives in the session's `ChatContext`, and custom per-session state goes in a typed `userdata` object. Long-term knowledge and actions come from tools, RAG or MCP servers. The same framework exists for Node.js in a separate repository (AgentsJS).

### Human in the loop

Because the user is live on the call, the main human controls are conversational: turn detection lets the user interrupt the agent mid-sentence, and adaptive interruption handling separates real interruptions from backchannel sounds. `WarmTransferTask` hands a call to a human operator over SIP, plays hold music, and gives the operator a context summary before connecting the caller. Tool calls can be forwarded to the user's frontend over RPC, so the client app fulfils or confirms them, and tasks can collect explicit consent before the flow continues. The docs do not describe a separate approval queue for tool calls outside the conversation.

## Protocols

| Protocol | Support | Evidence | Note |
| --- | --- | --- | --- |
| MCP | Yes (checked 2026-09-30) | [link](https://docs.livekit.io/agents/logic/tools/mcp/) | Client: `mcp.MCPToolset` wraps HTTP or stdio MCP servers as agent tools in the Python SDK; the page marks MCP as not available in the Node.js SDK. |
| A2A | Unknown (checked 2026-09-30) | — | Not in the README, the agents docs index (llms.txt) or released code; only open, unmerged pull requests were found. |
| AG-UI | Unknown (checked 2026-09-30) | — | Not in the README, docs index or repository code, and LiveKit is not listed in the AG-UI README. |

## Best for

- Voice support agents that route callers between specialists and can warm-transfer to a human ([shortlist](https://multiagentguide.top/best/customer-support.md))
- Running the full voice stack, including the LiveKit media server, on your own infrastructure ([shortlist](https://multiagentguide.top/best/self-hosted-local.md))
- Phone agents that place or receive calls over SIP
- Structured voice data collection, such as intake forms, with prebuilt tasks

## Not for

- Text-only or batch agents that never join a realtime session
- Node.js projects that need MCP, which the docs mark as Python-only
- Systems that need A2A endpoints today

## Quickstart

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

Install not yet verified by this site.

```python
from livekit.agents import Agent, AgentServer, AgentSession, JobContext, RunContext, cli, function_tool, inference
class BillingAgent(Agent):
    def __init__(self) -> None:
        super().__init__(instructions="You handle billing questions. Keep answers short.")
class FrontDesk(Agent):
    def __init__(self) -> None:
        super().__init__(instructions="Greet the caller and find out what they need.")
    @function_tool
    async def transfer_to_billing(self, context: RunContext):
        """Called when the caller asks about invoices or payments."""
        return BillingAgent(chat_ctx=self.chat_ctx), "Transferring you to billing."
server = AgentServer()
@server.rtc_session()
async def entrypoint(ctx: JobContext):
    session = AgentSession(vad=inference.VAD(), stt="deepgram/nova-3", llm="google/gemma-4-31b-it", tts="cartesia/sonic-3:9626c31c-bec5-4cca-baa8-f8ba9e84c8bc")
    await session.start(agent=FrontDesk(), room=ctx.room)
if __name__ == "__main__":
    cli.run_app(server)
```

### Common pitfalls

- Requires Python >= 3.10 (`requires-python = ">=3.10,<3.15"`); the Node.js edition is a separate package and repository.
- The agent needs a LiveKit server: set `LIVEKIT_URL`, `LIVEKIT_API_KEY` and `LIVEKIT_API_SECRET` for LiveKit Cloud or a self-hosted server.
- Model strings such as `deepgram/nova-3` use LiveKit Inference on LiveKit Cloud; to call providers with your own keys, use plugin classes (for example `openai.LLM`) instead.
- MCP needs the `mcp` extra (`livekit-agents[mcp]`); the older `mcp_servers` parameter is deprecated in favour of `MCPToolset` in `tools`.
- 1.8.0 changed OpenTelemetry output (conversation content moved from span events to attributes), which breaks dashboards built on the old events.

Official quickstart: https://github.com/livekit/agents/blob/main/README.md

## Pros

- Voice turn-taking is built in: an end-of-turn model, VAD and interruption handling that tells backchannel noises from real interruptions. ([source](https://docs.livekit.io/agents/logic/turns/))
- STT, LLM, TTS and realtime providers can be swapped per agent through plugins or LiveKit Inference. ([source](https://github.com/livekit/agents/blob/main/README.md))
- Prebuilt tasks cover common voice steps, including an agent-assisted warm transfer to a human. ([source](https://docs.livekit.io/agents/prebuilt/tasks/warm-transfer/))
- The whole stack, including the LiveKit media server, can run on your own servers. ([source](https://github.com/livekit/agents/blob/main/README.md))
- Frequent releases: livekit-agents 1.8.0 to 1.8.3 shipped in September 2026. ([source](https://github.com/livekit/agents/releases))

## Cons

- MCP support is only available in the Python SDK, not in the Node.js edition. ([source](https://docs.livekit.io/agents/logic/tools/mcp/))
- The `mcp_servers` parameter on `Agent` and `AgentSession` is deprecated, so older MCP code needs changing. ([source](https://docs.livekit.io/agents/logic/tools/mcp/))
- Version 1.8.0 made breaking changes to OpenTelemetry spans and attributes. ([source](https://github.com/livekit/agents/releases/tag/livekit-agents%401.8.0))
- The quickstart assumes LiveKit Cloud, and deployment, inference and observability beyond the free Build plan are paid. ([source](https://livekit.com/pricing))

## Alternatives

- [OpenAI Agents SDK (Python)](https://multiagentguide.top/tools/openai-agents-sdk.md)
- [OpenAI Agents SDK (JavaScript/TypeScript)](https://multiagentguide.top/tools/openai-agents-js.md)
- [Google ADK (Python)](https://multiagentguide.top/tools/google-adk.md)
- [Agent Development Kit (ADK) for Java](https://multiagentguide.top/tools/google-adk-java.md)

## FAQ

### Does LiveKit Agents support MCP?

Yes, in Python. `mcp.MCPToolset` wraps an HTTP or stdio MCP server and passes its tools to an agent. The docs mark MCP as unavailable in the Node.js SDK.

### Is LiveKit Agents free?

The framework is Apache-2.0 and can run against a self-hosted LiveKit server. LiveKit Cloud has a free Build plan and paid plans for deployment, inference and observability at larger scale.

### What languages does LiveKit Agents support?

This repository is the Python SDK (Python 3.10 to 3.14). A separate AgentsJS repository provides the Node.js edition, with some features, such as MCP, missing there.

### How do multiple agents work together in LiveKit Agents?

One agent is active per session. A tool can return another agent to hand off control, tasks take temporary control and return typed results, and a supervisor agent can route work to tasks.

### Is there help for building LiveKit agents with coding assistants?

The README points coding assistants to a LiveKit Docs MCP server and an installable agent skill. These are documentation aids, not an integration that runs coding agents.

## Sources

- [LiveKit Agents GitHub repository](https://github.com/livekit/agents)
- [LiveKit Agents README](https://github.com/livekit/agents/blob/main/README.md)
- [LiveKit Agents LICENSE](https://github.com/livekit/agents/blob/main/LICENSE)
- [livekit-agents pyproject.toml](https://github.com/livekit/agents/blob/main/livekit-agents/pyproject.toml)
- [LiveKit Agents releases](https://github.com/livekit/agents/releases)
- [livekit-agents 1.8.0 release notes](https://github.com/livekit/agents/releases/tag/livekit-agents%401.8.0)
- [AgentsJS (Node.js edition) repository](https://github.com/livekit/agents-js)
- [LiveKit Agents docs](https://docs.livekit.io/agents/)
- [Voice AI quickstart (docs)](https://docs.livekit.io/agents/start/voice-ai/)
- [Agent sessions (docs)](https://docs.livekit.io/agents/logic/sessions/)
- [Agents and handoffs (docs)](https://docs.livekit.io/agents/logic/agents-handoffs/)
- [Workflows (docs)](https://docs.livekit.io/agents/logic/workflows/)
- [Tasks and task groups (docs)](https://docs.livekit.io/agents/logic/tasks/)
- [Prebuilt tasks (docs)](https://docs.livekit.io/agents/prebuilt/tasks/)
- [Supervisor pattern (docs)](https://docs.livekit.io/agents/logic/patterns/supervisor/)
- [Turns overview (docs)](https://docs.livekit.io/agents/logic/turns/)
- [Model Context Protocol (docs)](https://docs.livekit.io/agents/logic/tools/mcp/)
- [Forwarding tool calls to the frontend (docs)](https://docs.livekit.io/agents/logic/tools/forwarding/)
- [WarmTransferTask (docs)](https://docs.livekit.io/agents/prebuilt/tasks/warm-transfer/)
- [Testing overview (docs)](https://docs.livekit.io/testing/overview/)
- [LiveKit pricing](https://livekit.com/pricing)
- [AG-UI README, supported integrations](https://github.com/ag-ui-protocol/ag-ui/blob/main/README.md)
- [LiveKit homepage](https://livekit.com)

## Unknown fields

protocols.a2a: searched the README, https://docs.livekit.io/agents/llms.txt and a GitHub code search of livekit/agents (only an unrelated hit in a plugin README). Open, unmerged pull requests propose A2A support (for example https://github.com/livekit/agents/pull/7317, a draft), so nothing is released. protocols.agui: same sources plus the AG-UI README integration list; no mention.

Corrections or removal requests: support@multiagentguide.top

---

Data as of 2026-09-30. Not affiliated with listed projects. HTML version: https://multiagentguide.top/tools/livekit-agents