A voice agent is three models in a loop: speech-to-text, an LLM, text-to-speech — plus the hard part nobody writes about, which is knowing when the human stopped talking. In 2026 two open-source projects own that problem: LiveKit Agents (13k+ GitHub stars, from the team behind the LiveKit WebRTC server) and Pipecat (14k+ stars, maintained by Daily). This guide covers which one to build an open source voice AI agent on, and — more usefully — exactly which parts of the stack you can run at $0 without violating a license.

LiveKit Agents vs Pipecat: the real difference

They solve the same problem from opposite ends. Pipecat models a conversation as a pipeline of frame processors you assemble yourself and is transport-agnostic. LiveKit models the agent as a participant that joins a room, so reconnection, barge-in, multi-party audio, and SIP telephony come from the WebRTC layer instead of being bolted on.

One license footnote worth knowing before you ship: LiveKit's turn-detector model is not Apache 2.0 — it ships under the separate "LiveKit Model License." The lightweight v1-mini (under 500 MB RAM, CPU-only) is free to use in any context; the full v1 runs on LiveKit Inference servers and is free only for agents deployed to LiveKit Cloud. The framework code is open; that one model is not.

What the code actually looks like

LiveKit's minimal agent — the session object wires the three models together and joins a room:

from livekit import agents
from livekit.agents import AgentServer, AgentSession, Agent, inference

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

server = AgentServer()

@server.rtc_session(agent_name="my-agent")
async def my_agent(ctx: agents.JobContext):
    session = AgentSession(
        stt=inference.STT(model="deepgram/nova-3", language="multi"),
        llm=inference.LLM(model="google/gemma-4-31b-it"),
        tts=inference.TTS(model="inworld/inworld-tts-2", voice="Ashley"),
    )
    await session.start(room=ctx.room, agent=Assistant())

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

Note inference.*: that's LiveKit Inference, a Cloud-billed passthrough to Deepgram/Cartesia/ElevenLabs and friends so you don't manage six API keys. You are not locked into it — the plugin path (livekit.plugins.deepgram.STT()) takes your own provider keys and your own free tiers.

Pipecat is explicit about the chain instead — you build the list, so you can insert your own processor anywhere in it:

pipeline = Pipeline([
    transport.input(),      # receive audio
    stt,                    # DeepgramSTTService(...)
    user_aggregator,        # append to context
    llm,                    # OpenAI / Groq / Gemini / Anthropic
    tts,                    # CartesiaTTSService(...)
    transport.output(),     # send audio back
    assistant_aggregator,
])

Both start with one command: lk agent init my-agent --template agent-starter-python for LiveKit, or uv tool install "pipecat-ai[cli]" && pipecat init quickstart for Pipecat.

The part that isn't free: STT, LLM, and TTS

This is where voice agent tutorials quietly mislead. Every figure below is from the provider's own pricing or docs page — and the column that matters most is the last one.

Read that bottom half twice. The two TTS engines every voice-agent quickstart defaults to — Cartesia and ElevenLabs — hand you a free tier that is explicitly personal, non-commercial use only. That is fine for a demo and a license violation the moment your agent answers a customer. Both fix it for $5–$6 a month, which is the cheapest line item in this entire article; the mistake is not noticing.

The $0 stack you can legally ship

• STT — Groq's whisper-large-v3-turbo: 28,800 audio seconds a day is eight hours of conversation, free, no card. See our free Whisper API comparison for accuracy and latency trade-offs.
• LLM — Groq or Gemini free tiers. Voice replies are short, so token caps bind far later than you'd expect; latency, not quota, is your constraint.
• TTS — Kokoro-82M on your own machine. Apache 2.0 weights, 54 voices, under 2 GB VRAM, faster than real time on CPU. No quota, no per-character fee, commercial use explicitly welcomed by the author. Trade-off: fixed preset voices and no cloning. Alternatives are in our free text-to-speech API guide.
• Turn detection — LiveKit's v1-mini locally, or Pipecat's VAD. Both CPU-only.

That combination has no monthly ceiling you can hit by talking, and nothing in it forbids revenue.

Where you run it

Self-hosting either framework costs whatever your server costs — a small VPS is enough for a handful of concurrent sessions, since the models run elsewhere. If you'd rather not, the two managed options are not comparable:

• LiveKit Cloud (Build plan) — 1,000 agent session minutes/month, 5 concurrent sessions, 1 agent deployment, 5,000 participant connection minutes, 100 concurrent connections, 50 GB bandwidth, one free US phone number with 50 inbound minutes, and $2.50 of LiveKit Inference credit (~50 minutes). No credit card required. That is a real free tier, not a trial.
• Pipecat Cloud — no published free monthly allowance; billing starts at $0.01 per running agent-minute (reserved instances go far lower), with Daily WebRTC included free for 1:1 voice sessions. Generous as pay-as-you-go, but budget for it.

Deploying yourself instead? Any always-on container host works — see our rundown of free hosts that don't cold-start, because a voice agent that sleeps is a voice agent that drops the first two seconds of every call.

Limits to know

• Latency is a budget, not a feature. Sub-second response means STT + LLM first token + TTS first byte + network all fit inside ~800 ms. Free tiers rarely promise latency SLAs, and a queued request feels like a broken call.
• Free tiers throttle concurrency, not just volume. Cartesia's free plan allows 2 concurrent TTS requests; LiveKit's Build plan allows 5 concurrent agent sessions. Ten simultaneous callers breaks both long before any monthly quota does.
• Phone calls are never free. SIP trunking and per-minute carrier charges sit outside every free tier here except LiveKit's 50 introductory inbound minutes.
• Both APIs still move. LiveKit's AgentServer/inference surface and Pipecat's service classes have both changed shape in 2026 — pin your versions and read the changelog before upgrading.

Frequently Asked Questions

Is LiveKit Agents free for commercial use?

Yes — the framework is Apache 2.0, with no revenue cap and no obligation to open-source your agent. The exception is the full v1 turn-detector model, which is under the separate LiveKit Model License and free only on LiveKit Cloud; the v1-mini version is free anywhere.

Can I build a voice AI agent with no API keys at all?

Almost. TTS (Kokoro), turn detection, and VAD run fully locally. STT and the LLM can too — Whisper plus a local model via Ollama — but on consumer hardware the round trip usually lands above two seconds, which is past the point where a conversation feels natural. Free hosted STT/LLM tiers are the practical compromise.

Which is easier to get running: LiveKit or Pipecat?

LiveKit, if you use LiveKit Cloud — the starter template plus a card-free account gives you a working phone-callable agent in minutes. Pipecat is easier to reason about, because the pipeline is an explicit Python list you can print, reorder, and instrument.

Do I need WebRTC to build a voice agent?

Not for a prototype — a WebSocket stream from the browser works. You need WebRTC once real networks are involved: it handles packet loss, jitter, echo cancellation, and reconnection, which is precisely the plumbing LiveKit gives you for free and Pipecat expects you to choose.

The verdict

Neither framework is where your money goes, so choose on architecture. LiveKit Agents is the shorter path to a production call: real WebRTC, native SIP, local turn detection, and the only managed free tier in this space that doesn't ask for a card. Pipecat is the better tool when you want to see and tune every stage of the loop, or when you intend to self-host anyway and don't need a media server. Then spend ten minutes on the licence column above — swapping a non-commercial TTS free tier for Kokoro or a $5 plan is the difference between a demo and something you can charge for.

Related Reads

• Browser Use: The Free AI Browser Agent Framework
• Mem0 vs Zep vs Letta: Free AI Agent Memory Compared
• CrewAI vs AutoGPT vs LangGraph: Free Agent Frameworks
• Free Code Sandbox for AI Agents: E2B vs Daytona
• Langfuse: Free Open-Source LLM Observability
• Free Speech-to-Speech API: Gemini Live and 3 Others