LiveKit Agents vs Pipecat: Open-Source Voice Agent Frameworks Compared

You want to build a voice agent that you control, not a drag-and-drop bot on someone else's platform, and two repos keep showing up: LiveKit Agents and Pipecat. They look similar from the outside. Both are Python-first, both wire a speech-to-text model, an LLM and a text-to-speech model together, and both ship a model that decides when the caller has finished talking. Under the hood they make opposite bets about where the agent lives.

The short version: pick LiveKit Agents if your agent will live in WebRTC rooms or on phone lines and you want one vendor for the server, the SDKs, SIP and hosting. Pick Pipecat if you want to assemble the media pipeline yourself, swap the transport without touching bot logic, and keep the option to run it anywhere. The rest of this page is the evidence, checked against live docs, GitHub and pricing pages on Nov 11, 2026.

LiveKit's own video on building a production voice agent with the Agents SDK. It comes from the vendor, so watch it for the build flow, not as a neutral comparison.

The Short Answer

If you are still choosing between a framework and a hosted platform, start with our roundup of the best voice AI agent platforms in 2026. If your goal is specifically outbound or inbound phone calls, the step-by-step is in how to build an AI phone calling agent.

Master Comparison Table

Every cell below comes from a page we fetched on Nov 11, 2026: the two GitHub repos, the vendor docs, and the LiveKit and Pipecat Cloud pricing pages. Where something is not documented, the cell says so instead of guessing.

Two numbers deserve context. Stars favor Pipecat (17,201 against 15,180), but the LiveKit server repo, which the agent framework builds on, has 22,149 stars and is on v1.13.11 (Oct 25, 2026), so the combined LiveKit footprint is larger than the agents repo suggests. And both projects are active: the GitHub API showed pushes on both repos on Nov 11, 2026. Stars are a popularity signal, not a quality benchmark.

Architecture: Rooms vs Pipelines

This is the real difference, and everything else follows from it.

LiveKit Agents: the agent is a room participant

LiveKit's docs describe the framework as adding Python or Node.js programs to a LiveKit room as realtime participants. A user connects from a web or mobile app over WebRTC, the agent joins the same room, and the agent talks to your backend over HTTP or WebSockets. Operationally, an agent server registers with the LiveKit server and boots a job subprocess for every dispatch, which is how it scales to many calls: one process pool, one subprocess per conversation, all coordinated by the LiveKit server.

Inside a session, you pick one of three pipeline types according to LiveKit's pipeline docs: a cascaded STT, LLM and TTS pipeline; a turn-based realtime model such as the OpenAI Realtime API; or a full-duplex realtime model such as OpenAI GPT-Live, which listens and speaks at the same time. LiveKit's own guidance is that a cascaded pipeline is the right default for most production agents, because each stage can be swapped, logged and audited.

Pipecat: the agent is a pipeline of frames

Pipecat's unit is the frame. A Pipeline takes an ordered list of frame processors and connects them; frames are data containers (audio, text, images, control signals) that flow through. The docs split frames into SystemFrames, which are high priority and survive interruptions, and DataFrames and ControlFrames, which are queued and processed in order. That ordering guarantee is what makes interruption handling predictable: an InterruptionFrame is a system frame, so it can cut ahead of queued audio.

The transport is just another pair of processors, transport.input() and transport.output(). Pipecat's docs list transports for Daily, LiveKit, SmallWebRTC (direct peer-to-peer WebRTC with no cloud infrastructure), FastAPI WebSocket, a general WebSocket, WhatsApp voice calls, Media over QUIC, Vonage Video Connector and several avatar vendors including HeyGen, Tavus, LemonSlice and Beyond Presence. Because the transport is modular, the docs recommend P2P WebRTC for development and Daily for production with the same bot logic.

What the difference means in practice

With LiveKit, the room is the unit of scale and the unit of reconnection. Participants, tracks, data channels and SIP callers are all things the LiveKit server already knows how to route, so an agent joining a call to which a human, a supervisor or a second agent can also connect is the normal case, not an extension. With Pipecat, the pipeline is the unit of composition. You decide what happens between audio in and audio out, you can branch with ParallelPipelines and filters, and the room is whatever your chosen transport provides.

Neither design is better in the abstract. The room model removes decisions and gives you a platform; the pipeline model keeps the decisions and gives you a toolkit. If you need to bolt a custom processor in front of the LLM, such as a profanity filter, a context compactor or a second model judging the first, Pipecat's model makes that a one-line list change. If you need a supervisor to whisper to the agent or a human to take over mid-call, LiveKit's room model makes that a participant join.

LiveKit Agents in Detail

LiveKit Agents is an Apache-2.0 framework for realtime voice AI agents, created in October 2023 and at 15,180 stars on Nov 11, 2026. The latest release we saw was [email protected] on Nov 5, 2026, and that one release alone added a Responses API route through LiveKit Inference, plus new STT and TTS providers such as Zoom Scribe, Kalpa, Rime and Fish Audio.

What you get

• Python and Node.js SDKs. The quickstart ships the same agent in both languages, with starter templates for each.
• A CLI for the whole loop. lk agent init scaffolds, lk agent dev prints an Agent Console link where you can talk to the agent, and lk agent create deploys.
• Agent Builder. A no-code browser tool for prototyping and deploying voice agents. LiveKit says it is not as feature-rich as the full SDK, so treat it as a starting point.
• Multi-agent handoff and tasks. Agents can hand a session to another agent, and LiveKit documents task and task-group primitives for structured data collection.
• Behavioral testing. The quickstart points at behavioral tests and simulation scenarios for agent logic.
• Telephony inside the platform. SIP trunks, dispatch rules, SIP participants and phone numbers, covered below.

Weaknesses and trade-offs

• The framework is built around LiveKit rooms. If you want a different transport, you are working against the grain, and the docs we read do not describe one.
• Cloud usage is metered across several dimensions (agent minutes, WebRTC minutes, SIP, recordings, events), so the bill takes a calculator, not mental arithmetic.
• Concurrency is a plan limit on LiveKit Cloud: 5 on Build and 20 on Ship as of Nov 11, 2026. Production traffic pushes you toward Scale from $500 per month.
• The surface area is large. Agents, tasks, sessions, rooms, jobs, dispatch and inference are many concepts to learn before the first call goes live.

Best for: teams that want phone, web and mobile voice agents on one platform, want Node.js as an option, and would rather buy the infrastructure than assemble it.

Minimal agent (from the official quickstart)

# Install the CLI, sign in, scaffold, run (from the LiveKit quickstart)
brew install livekit-cli
lk cloud auth
lk agent init my-agent --template agent-starter-python
cd my-agent
lk agent dev        # prints an Agent Console link to talk to the agent
lk agent create     # deploy to LiveKit Cloud

# agent.py (trimmed from the quickstart appendix)
from dotenv import load_dotenv
from livekit import agents
from livekit.agents import AgentServer, AgentSession, Agent, inference, room_io, TurnHandlingOptions

load_dotenv(".env.local")

class Assistant(Agent):
    def __init__(self) -> None:
        super().__init__(instructions="You are a helpful voice AI assistant. Keep answers short.")

server = AgentServer()

@server.rtc_session(agent_name="my-agent")
async def my_agent(ctx: agents.JobContext):
    session = AgentSession(
        stt=inference.STT(model="assemblyai/universal-3-6-pro", language="en"),
        llm=inference.LLM(model="google/gemma-4-31b-it"),
        tts=inference.TTS(model="fishaudio/s2.1-pro", voice="fa4c9eb3dccc4806b382b40d61c6b10a"),
        turn_handling=TurnHandlingOptions(turn_detection=inference.TurnDetector()),
    )
    await session.start(room=ctx.room, agent=Assistant(), room_options=room_io.RoomOptions())
    await session.generate_reply(instructions="Greet the user and offer your assistance.")

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

This uses LiveKit Inference model strings, so no provider keys are needed during development; credits are included with the plan. Swap in a plugin instance, for example the OpenAI plugin via uv add "livekit-agents[openai]~=1.8", when you want your own keys.

Pipecat in Detail

Pipecat describes itself as an open source framework for voice agents, multimodal apps and realtime AI, maintained by Daily and the community. It is BSD-2-Clause, was created in December 2023, and had 17,201 stars on Nov 11, 2026. The latest release we saw was v1.15.0 on Oct 29, 2026, which among other things added ClassifierUserTurnStopStrategy, a way to let a classifier decide whether the user's turn is complete.

What you get

• Frame-level control. You can see and change every frame between transport input and output.
• Many transports and services. The intro docs cite 150+ AI services; the Pipecat Cloud pricing page cites 80+ providers for LLM, STT and TTS. Both numbers are the vendor's own and count differently, so read them as a range.
• Client SDKs. JavaScript, React, React Native, iOS, Android and C++ clients connect users to your agent.
• A scaffolding CLI. pipecat init quickstart scaffolds a starter project and also writes AGENTS.md and CLAUDE.md for coding agents.
• Pipecat Cloud. Managed hosting by Daily, with pipecat cloud deploy, secrets, regions and scaling controls.
• Open turn detection. Smart Turn is a separate BSD-2-Clause repo with weights, data and training scripts.

Weaknesses and trade-offs

• The server framework is Python only. There is no documented Node.js equivalent in what we fetched.
• You own more decisions: which transport, which hosting, which noise filter. That is flexibility if you want it and homework if you do not.
• Its own docs state the WebSocket telephony route has no advanced call center features like transfers or reconnects, and that WebSocket is TCP-based, so it is less resilient to packet loss and jitter than WebRTC.
• On Pipecat Cloud each instance runs one active session at a time, so bigger agent profiles give one session more CPU and memory, not more sessions per instance.

Best for: teams that want to own the pipeline, run anywhere, and mix transports, and that are comfortable with Python.

Minimal bot (from the official quickstart)

# Install the CLI, scaffold, run, deploy (from the Pipecat quickstart)
uv tool install "pipecat-ai[cli]"
pipecat init quickstart
cd pipecat-quickstart
cp .env.example .env     # DEEPGRAM_API_KEY, OPENAI_API_KEY, CARTESIA_API_KEY
uv sync
uv run bot.py            # opens a local WebRTC client at http://localhost:7860/client
pipecat cloud auth login
pipecat cloud secrets set pipecat-quickstart-secrets --file .env
pipecat cloud deploy

# bot.py (trimmed from the quickstart repo)
stt = DeepgramSTTService(api_key=os.getenv("DEEPGRAM_API_KEY"))
tts = CartesiaTTSService(api_key=os.getenv("CARTESIA_API_KEY"),
    settings=CartesiaTTSService.Settings(voice="71a7ad14-091c-4e8e-a314-022ece01c121"))
llm = OpenAILLMService(api_key=os.getenv("OPENAI_API_KEY"),
    settings=OpenAILLMService.Settings(system_instruction="You are a friendly AI assistant."))

context = LLMContext()
user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
    context, user_params=LLMUserAggregatorParams(vad_analyzer=SileroVADAnalyzer()))

pipeline = Pipeline([
    transport.input(),   # user audio in
    stt,
    user_aggregator,     # turn detection lives here
    llm,
    tts,
    transport.output(),  # bot audio out
    assistant_aggregator,
])
task = PipelineTask(pipeline, params=PipelineParams(enable_metrics=True))

The quickstart needs Python 3.11 or later, uv, and three keys (Deepgram for STT, OpenAI for the LLM, Cartesia for TTS). The first run takes about 20 seconds while models download.

A talk by Daily's Kwindla Hultman Kramer on the AI Engineer channel (published July 31, 2025, so some product details have moved on). It is a vendor talk; use it for the Pipecat mental model and how Daily positions Pipecat Cloud.

Providers and Models

Both frameworks are provider-neutral, and both keep up with new models fast. The difference is how you reach them.

LiveKit: plugins plus LiveKit Inference

LiveKit offers two paths. LiveKit Inference gives STT, LLM, TTS and realtime models from providers including OpenAI, Google, AssemblyAI, Deepgram, Cartesia and Inworld through one LiveKit Cloud account, with no extra plugin install. The open-source plugins connect directly to a wider set of providers with your own keys; for Python they are optional dependencies such as livekit-agents[openai]. Any OpenAI-compatible endpoint works by overriding base_url and api_key. You can mix both and change models during a session.

On realtime models, LiveKit's docs list OpenAI GPT Realtime and GPT-Live, Gemini Live and SpaceXAI Grok Voice through Inference, and LiveKit's Oct 15, 2026 post says all three pipeline styles now run on LiveKit Inference.

Pipecat: provider services in the framework

Pipecat ships a service class per provider (for example DeepgramSTTService, CartesiaTTSService and OpenAILLMService in the quickstart), and you bring your own API keys. There is no framework-level inference reseller in the docs we read; Pipecat Cloud offers enterprise integrated billing by email. Its docs say you can swap one provider for another (Deepgram for Soniox, OpenAI for Anthropic, Cartesia for ElevenLabs) without changing the rest of the code, and an LLMSwitcher can change LLM providers mid-session.

If you are choosing the models themselves, our best speech-to-text APIs and best text-to-speech APIs roundups apply to both frameworks equally.

Practical takeaway: if you want one invoice and one key, LiveKit Inference is the only first-party option here. If you already have enterprise contracts with Deepgram, ElevenLabs or OpenAI, both frameworks use them equally well.

Turn Detection and VAD

Knowing when the caller has finished is the difference between an agent that feels natural and one that talks over people. Both frameworks combine a fast VAD with a model that reads the content of speech.

LiveKit

AgentSession uses LiveKit's turn detector together with VAD data to decide when the user is done; the docs describe the turn detector as audio and text models that detect end of turn from the meaning of speech. Other documented modes: rely on a realtime model's built-in server-side detection, VAD only (minimal latency, or a language the model does not cover), STT endpointing (for example AssemblyAI or Deepgram Flux), and manual control for push-to-talk. On top of the mode you can tune endpointing delay with min_delay and max_delay, dynamic endpointing (Python only), adaptive interruption handling that can tell backchanneling from a real interruption, and noise cancellation.

Pipecat

Pipecat decides turn start and turn end with pluggable user turn strategies. Turn start can use VAD, a transcription fallback, or a minimum word count. Turn end defaults to a turn detection model: the defaults are TurnAnalyzerUserTurnStopStrategy with LocalSmartTurnAnalyzerV3 and Silero VAD with stop_secs=0.2. Alternatives are a speech timeout after transcription, a turn-completeness check by an LLM or classifier, and custom strategies. Silero VAD runs locally on CPU with minimal overhead, and the docs say local VAD is 150 to 200 ms faster than a remote VAD service.

Smart Turn itself is an open, native-audio model. Its README says v3.2 supports 23 languages, comes in an 8 MB quantized CPU build and a 32 MB GPU build, and runs in as little as 10 ms on some CPUs and under 100 ms on most cloud instances. Those are the project's own figures. Pipecat's docs also report around 65 ms on a standard 1x Pipecat Cloud instance, which is Pipecat's own number as well.

Who is ahead?

We cannot call it. We found no independent benchmark that compares the two turn detectors on the same audio, and a fair one would need accented, noisy, telephone-band speech in each target language. Both approaches are credible, both are open for you to inspect (Smart Turn fully; LiveKit documents its model on the turns page), and both let you fall back to simpler modes. Record twenty real calls and replay them through each. That one afternoon will tell you more than any chart.

Telephony

If your agent answers or places phone calls, this section can decide the whole comparison. We cover the mechanics in depth in our phone calling agent guide.

LiveKit

LiveKit's docs describe SIP trunks, dispatch rules and SIP participants as parts of the platform, plus Connectors for WhatsApp Business and Twilio. Tested providers listed are Twilio, Telnyx, Exotel, Plivo, Wavix, Sinch, didlogic and DIDWW. Supported call features include DTMF, cold transfer using SIP REFER, warm transfer and SRTP, with Krisp noise cancellation available. The docs also say there is no SIP REGISTER support. On LiveKit Cloud you can buy US local and toll-free numbers through LiveKit Phone Numbers; for self-hosting, the SIP service is deployed separately.

Pipecat

Pipecat gives you three routes, per its telephony overview: WebSocket (Twilio, Telnyx, Plivo, Exotel), where the docs say to use WebSocket for telephony and WebRTC for clients; WebRTC through Daily with PSTN integration for dial-in and dial-out; and SIP, which the docs say gives full call control including transfers, forwarding and multi-party calls. You can run several providers in the same bot. The honest limit is the one Pipecat states itself: WebSocket telephony lacks transfers and reconnects.

Verdict on phones

For a simple inbound line on Twilio, either works and Pipecat's WebSocket route is quick. For real call-center behavior (transfers, DTMF menus, SIP interconnect, many numbers) the LiveKit stack is more self-contained, and Pipecat plus Daily SIP is the comparable path. Both stacks name Twilio, Telnyx, Plivo and Exotel, so check number availability with the carrier in your target country before you commit to either.

Deployment and Hosting

LiveKit Cloud

You deploy with one CLI command (lk agent create, then lk agent deploy for updates). LiveKit Cloud builds the container from your Dockerfile, injects secrets, scales and load-balances up to your plan limits, and gives you a dashboard with session counts, error tracking, logs and log drains to Datadog, CloudWatch, Sentry or New Relic. Agent deployments are counted per plan (1, 2 and 4 on Build, Ship and Scale as of Nov 11, 2026), and LiveKit announced on Sep 2, 2026 that a staging deployment can run next to production with the same image and secrets. For other environments, the docs describe self-hosted deployments and Kubernetes compatibility.

Pipecat Cloud

pipecat cloud deploy creates a managed pool of instances for your agent, with secrets set through pipecat cloud secrets set. Each instance runs one session at a time. Controls include min-agents (warm instances, default 0, which cost money even when idle), max-agents (hard limit that returns HTTP 429 at capacity) and max-session-duration as a runaway-session safety net, plus a spend limit in the dashboard or CLI. Daily-hosted regions are us-west (Oregon), us-east (Virginia), eu-central (Frankfurt) and ap-south (Mumbai), on arm64. Self-hosted regions in your own Kubernetes cluster are part of Pipecat Enterprise. Secrets and image pull secrets are region-specific, so a multi-region setup repeats them per region.

Running it yourself

Either framework runs in your own containers on any VPS or Kubernetes cluster. For LiveKit that means running the LiveKit server (Apache-2.0, Go) alongside the agent workers, plus the SIP service if you want phones. For Pipecat that means your own container with a transport such as SmallWebRTC or WebSocket, or Daily as a hosted transport. If you want a box for this, see our best VPS for AI agents guide. Remember that voice agents are latency-sensitive: put the workers near your users and near your model providers.

Live Pricing

Prices below are from the vendors' pricing pages as of Nov 11, 2026. They exclude model costs (STT, LLM, TTS) unless stated, and vendors change them, so confirm on the source before budgeting.

A worked example, with the caveats

LiveKit's own calculator for a phone call shows $0.0672 per minute all in: agent session $0.0100, telephony $0.0100, LLM $0.0014, STT $0.0058, TTS $0.0300 and observability $0.0100. That is LiveKit's example with its chosen models, so your number will move with your TTS choice most of all. For Pipecat, our arithmetic on listed rates: agent-1x active $0.01 plus Daily PSTN $0.018 comes to $0.028 per minute before LLM, STT, TTS, Krisp (free under 10k minutes) and recording. Those two figures are not apples to apples: LiveKit's includes observability and a US local inbound number, and Pipecat's excludes any model spend. Use them as a shape, not a verdict.

The pricing shapes differ more than the totals. LiveKit is plan-based: a free Build tier (no card, 1,000 free agent minutes monthly), then included minutes and concurrency that step up by plan. Pipecat Cloud is pure usage: no plan fee is listed, you pay per active minute plus any reserved capacity. Light and spiky usage tends to suit usage-based billing, steady high volume tends to suit plans with included minutes. Whichever you pick, GPU and model spend dominates at scale, so see our TTS pricing roundup, and if you self-host open models, our GPU cloud guide.

Benchmarks and Independent Data

We looked for neutral, reproducible comparisons of the two frameworks (latency, concurrency per core, interruption accuracy) and did not find any we could stand behind. What exists is vendor material:

• Pipecat Smart Turn (vendor-reported): 23 languages, as little as 10 ms on some CPUs, under 100 ms on most cloud instances, 8 MB CPU model.
• LiveKit docs (vendor-reported): conversations feel natural when end-to-end response latency stays under one second. Pipelines accumulate latency across stages but reduce it through streaming, while realtime models combine stages for a lower baseline.
• Pipecat STT claim: a Sep 11, 2026 post by Pipecat's maintainer says Meta's Muse Voice Transcribe has the lowest semantic word error rate of any model they tested, using their public open-source test suite. That is a claim about a speech model from the framework maintainer, not about either framework.

Your latency depends mostly on the model providers, the region and the network path, not on the framework loop. The right test is your own: same prompt, same models, same region, 50 calls each, measuring time from end of user speech to first bot audio. For the deeper view on picking models, read our voice platforms roundup.

Alternatives

If neither framework fits, three other routes are worth knowing. Prices are as of Nov 11, 2026, from the vendors' pages we fetched for our voice-platform roundup.

• Vapi (hosted platform). Pay-as-you-go with a $0.05 per minute hosting fee, models passed through at cost, $5 free credits and 4 concurrent calls on the free tier. You configure assistants instead of writing a framework. Best for: fast launches where you accept less control.
• Retell (hosted platform). Pay-as-you-go from $0.07 to $0.31 per minute on its pricing page, 20 concurrent calls included. Best for: teams that want a polished call-center product and per-minute budgeting.
• OpenAI Realtime API (model, not a framework). A speech-to-speech model API; gpt-realtime-2.1 audio is listed at $32 per 1M input tokens and $64 per 1M output tokens, with a mini variant at $10 and $20. You would still need transport, telephony and hosting, which is exactly what LiveKit and Pipecat supply, and both support it as a model.

If you are an engineer exploring voice for your own coding workflow instead, our Antigravity voice mode guide covers a different problem. And if a coding agent will write your voice agent for you, the Pipecat quickstart scaffolds AGENTS.md and CLAUDE.md files for it; see our best AI coding agents.

How to Choose

A fast way to decide. Build the same two-minute demo in both. It takes less than an hour each with the quickstarts above. Then ask three questions. Which one made it easier to add a custom tool and a handoff? Which one made it easier to see what happened on a bad turn? Which one would your team be comfortable being paged for at 2 a.m.? Teams that answer “LiveKit” are usually buying the platform; teams that answer “Pipecat” are usually buying control.

Retrieval-heavy agents need a knowledge store as well; our vector database comparison covers that layer, and it is the same for both frameworks.

How We Evaluated

We read the official docs, repos and pricing pages for both frameworks and their clouds on Nov 11, 2026, queried the GitHub API for stars, forks, licenses and latest releases, and checked each vendor claim against its first-party source. We did not run our own latency benchmarks, so we report none as fact. We label figures as vendor-reported when the vendor is the only source. There is no paid placement, no affiliate link and no sponsorship in this comparison. Where a detail is not publicly documented, we say so rather than fill the gap. Both projects ship quickly (new releases landed within days of our check), so treat version numbers and prices as a snapshot.

FAQ

Sources

All fetched on Nov 11, 2026 unless noted.

• GitHub: livekit/agents (stars, license, releases)
• GitHub: pipecat-ai/pipecat (stars, license, releases)
• GitHub: livekit/livekit (media server)
• GitHub: pipecat-ai/smart-turn
• LiveKit docs: Voice AI quickstart
• LiveKit docs: Pipeline types
• LiveKit docs: Models overview
• LiveKit docs: Turns overview
• LiveKit docs: Agent deployment overview
• LiveKit pricing
• Pipecat docs: Introduction
• Pipecat docs: Quickstart
• Pipecat docs: Pipeline and frame processing
• Pipecat docs: Transports
• Pipecat docs: Speech input and turn detection
• Pipecat docs: Telephony overview
• Pipecat Cloud docs: Scaling
• Pipecat Cloud docs: Regions
• Pipecat Cloud pricing (Daily)
• Release notes: livekit-agents 1.8.11
• Release notes: Pipecat v1.15.0
• AI Engineer: Pipecat Cloud talk (published July 31, 2025)
• LiveKit: Build Production-Ready Voice AI Agents
• Vapi pricing, Retell pricing, OpenAI API pricing