Pipecat vs. LiveKit: compare the framework, the transport and the host

"LiveKit" names a media server, an agent framework and a cloud. Pipecat is a framework that can run on that media server. Pick by layer, and by the stack you already run.

Duplex Compute · October 13, 2026 · Rates and versions checked October 13, 2026 (pipecat-ai 1.12, livekit-agents 1.8)

LiveKit has three products that people shorten to one word. The LiveKit server is an open-source WebRTC SFU that routes audio, video and data between participants in a room. LiveKit Agents is a framework for Python and Node.js that joins those rooms as a participant and runs your voice logic. LiveKit Cloud hosts both, and adds inference, telephony and observability on metered plans.

Pipecat is an open-source Python framework with client SDKs for JavaScript, React, React Native, iOS, Android and C++, a structured-conversation library called Flows, and a managed host called Pipecat Cloud. Pipecat does not need its own media server. It talks to users through a transport, and one of its transports is LiveKitTransport, which joins a LiveKit room on a self-hosted server or LiveKit Cloud.

So the fair comparison is Pipecat against LiveKit Agents. The LiveKit media server sits under either one.

Sources: LiveKit docs index for SDKs and components, Agents introduction for languages and licence, Pipecat supported services for transports, Pipecat docs index for client SDKs and hosting, and Pipecat's licence file.

Language and providers

If your backend is TypeScript, the choice is short. LiveKit Agents ships a Node.js SDK alongside the Python one; the quickstart requires Python 3.10+ or Node.js 20+. Pipecat's server framework is Python only. Its JavaScript packages are clients that connect a browser or app to a Python bot.

Both frameworks plug into the same speech and model vendors. Pipecat's catalogue lists STT, LLM, TTS, VAD and turn-detection services, and speech-to-speech models including OpenAI Realtime, GPT-Live, Gemini Live and AWS Nova Sonic. LiveKit has plugins for most major providers plus LiveKit Inference, which bills model usage through your LiveKit account with a single key. Provider coverage rarely decides this choice.

Tools behave differently on interruption

Both frameworks turn a Python function into a tool from its signature and docstring. They disagree about what happens to a running tool when the user talks over the agent.

In Pipecat, a tool is cancelled on interruption by default. Set cancel_on_interruption=False with the @tool_options decorator and the call becomes asynchronous: the conversation keeps going, and a late result is injected into the context as a developer message. Per-tool timeout_secs and an opt-in cancellable_by_llm flag sit on the same decorator.

In LiveKit, an interrupted tool keeps running in the background until it returns. To cancel, you wait on speech_handle.wait_if_not_interrupted() and cancel your own task. To block interruptions during an action that can't be undone, you call run_ctx.disallow_interruptions(). LiveKit also has async tools for long work.

Neither default is wrong. A refund or booking tool needs a deliberate choice in both frameworks, and the code for that choice looks different.

Context handling after an interruption matches. Pipecat commits only the words that were actually played to the assistant message. LiveKit truncates the agent's history to the speech the user heard. For end-of-turn detection, Pipecat defaults to its Smart Turn model on top of Silero VAD. LiveKit has its own turn detector model and adaptive interruption handling, both free for agents deployed to LiveKit Cloud.

Testing and observability exist on both sides

Pipecat has Pipecat Evals: scripted scenarios and simulated callers run against the agent you deploy, from the CLI or a Python library. Tracing goes through OpenTelemetry to whatever backend you use.

LiveKit has unit tests, Agent Simulations in LiveKit Cloud, and agent insights for production sessions. Agent insights record transcripts, traces, logs and audio. They require the LiveKit Agents SDK (Python 1.3.0+ or Node.js 1.0.18+) and LiveKit Cloud media servers.

The same agent in both

The two sketches below build one support agent: Deepgram STT, GPT-4.1, Cartesia TTS and one get_order_status tool. They are adapted from each project's current docs and trimmed for length. We did not run them, and they are not a benchmark. orders.lookup stands in for your backend.

# Pipecat 1.12: tool + pipeline (adapted from "Your First Agent" and "Function Calling")
from pipecat.adapters.schemas.direct_function import tool_options
from pipecat.services.llm_service import FunctionCallParams

@tool_options(timeout_secs=10)          # cancelled on interruption by default
async def get_order_status(params: FunctionCallParams, order_id: str):
    """Look up the status of an order.

    Args:
        order_id: The order number the caller read out.
    """
    await params.result_callback({"status": await orders.lookup(order_id)})

stt = DeepgramSTTService(api_key=os.environ["DEEPGRAM_API_KEY"])
llm = OpenAILLMService(api_key=os.environ["OPENAI_API_KEY"],
    settings=OpenAILLMService.Settings(model="gpt-4.1",
        system_instruction="You are a support agent. Keep answers short."))
tts = CartesiaTTSService(api_key=os.environ["CARTESIA_API_KEY"],
    settings=CartesiaTTSService.Settings(voice=VOICE_ID))

context = LLMContext(tools=[get_order_status])
agg = LLMContextAggregatorPair(context,
    user_params=LLMUserAggregatorParams(vad_analyzer=SileroVADAnalyzer()))
pipeline = Pipeline([transport.input(), stt, agg.user(), llm, tts,
                     transport.output(), agg.assistant()])
# then: PipelineWorker(pipeline) added to a WorkerRunner

# LiveKit Agents 1.8: agent class + session (adapted from the voice AI quickstart)
from livekit import agents
from livekit.agents import Agent, AgentServer, AgentSession, RunContext, function_tool
from livekit.plugins import cartesia, deepgram, openai

class Support(Agent):
    def __init__(self):
        super().__init__(instructions="You are a support agent. Keep answers short.")

    @function_tool()                    # keeps running if the user interrupts
    async def get_order_status(self, context: RunContext, order_id: str) -> str:
        """Look up the status of an order.

        Args:
            order_id: The order number the caller read out.
        """
        return await orders.lookup(order_id)

server = AgentServer()

@server.rtc_session(agent_name="support")
async def entry(ctx: agents.JobContext):
    session = AgentSession(
        stt=deepgram.STT(model="nova-3", language="en"),
        llm=openai.responses.LLM(model="gpt-4.1"),
        tts=cartesia.TTS(model="sonic-3", voice=VOICE_ID))
    await session.start(room=ctx.room, agent=Support())

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

The shapes differ more than the line counts. Pipecat makes the frame pipeline explicit, so you see where a filter or a second model would go. LiveKit hides the pipeline inside AgentSession and puts behavior on an Agent class, which suits multi-agent handoffs. LiveKit owns dispatch: the agent server waits for a room. In Pipecat you or your host start a bot per session.

Hosting and the meters you pay

Sources: LiveKit pricing and its plain-text version, which notes that self-hosted agents count against WebRTC minutes; Pipecat Cloud pricing; Pipecat Cloud scaling for one session per instance and the pool limit.

The two headline rates match at $0.01 per minute, but they meter different things. A Pipecat Cloud instance bills while it is reserved even with no caller. LiveKit's plans include minutes and then charge per agent-session minute. Neither number includes STT, the LLM or TTS. Our LiveKit pricing note adds those lines into two full monthly bills.

Which one fits your stack

Neither framework's name tells you response time. Latency depends on the models, regions and turn settings you pick. Measure the same agent on both with repeated runs before you treat one as faster.

Both frameworks accept speech-to-speech models in place of the STT, LLM and TTS chain. Duplex Compute is a full-duplex voice API with tool calling at $0.01 per connected minute. We have not published a Pipecat or LiveKit plugin, so wiring it into either framework today means writing a service adapter.

Related notes

• LiveKit pricing for voice agents
• Voice agent pricing: calculator and billing formulas
• Silero VAD and Smart Turn
• Why your Realtime agent keeps talking after an interruption
• Vapi alternatives for developers