Retell vs. Vapi vs. LiveKit for voice AI agents: A comparison for developers

Let’s be honest, there isn’t a one-size-fits-all platform for developing voice agents. And to make matters a bit more blurry, if you’re an engineer comparing Retell, Vapi, and LiveKit, each is going to easily handle the standard voice AI demo.

We believe the differences between each platform begin to show themselves after the demo: when someone goes to iterate on the agent or once the agent is deployed at production scale.

Instead of doing a giant feature comparison between each, we’ve attempted to simplify the comparison into four key questions for engineering teams:

1. Will engineers keep iterating on the agent after launch, or does it need to be iterated and updated without them?
2. What happens when a requirement or optimization falls outside the defaults?
3. Will the agent need to work beyond phone calls, on web, mobile, video, devices or WhatsApp?
4. Is cost at scale a relevant concern?

Quick comparison#

We’ve included a high-level table below to outline some of the differences between Retell, Vapi, and LiveKit, but we suggest you dive into the details to understand the nuance.

Four questions to help you evaluate Retell vs. Vapi vs. LiveKit#

1. Will engineers keep iterating on it after launch, or does it need to run without them?#

The reality is that, even for seemingly straightforward tasks, there's no such thing as the perfect AI voice agent out of the box. Any use beyond the demo will surface things the demo didn't such as:

• A caller who pauses mid-sentence and gets cut off
• A tool that takes three seconds at p95 and leaves dead air
• A voicemail that gets a full sales pitch
• A transfer to a human that drops the conversation context.

If you want to optimize your agent to achieve its goal, every agent you build with any platform will inevitably need to be tweaked in month two. The question is who makes them and what a change looks like.

2. What happens when a requirement or optimization falls outside the defaults?#

Defaults and packaged integrations help teams get standard workflows running quickly. In some cases, though, they come at the cost of developer experience: the engineers responsible for improving the agent end up working inside a “black box.”

For basic scheduling, FAQ and lead-qualification agents, defaults are often the right trade, and both Retell and Vapi add packaged helpers like Retell's managed knowledge base and eleven first-party connectors for CRMs, calendars, helpdesks and knowledge sources or Vapi's “Campaigns” feature. The question is what happens when a requirement sits half a step outside the default workflow. In those instances, developers (and their coding agents) reap the benefits of a fully flexible open source framework like LiveKit’s.

Below is a non-comprehensive list meant to illustrate examples of what we mean by “configuration” and “defaults” versus “flexibility”.

Compare the code: five real-world scenarios#

The table above outlines some examples of defaults vs. flexibility of the platforms, but developers know push comes to shove when you need to actually implement, read, and iterate the code. To help developers understand in more detail what it’s like to work with each platform, we’ve outlined a few of the scenarios below with some example code.

1
// PATCH https://api.retellai.com/update-agent/{agent_id}
2
{
3
  "responsiveness": 0.6,
4
  "interruption_sensitivity": 0.7,
5
  "enable_dynamic_responsiveness": true,
6
  "stt_mode": "custom",
7
  "custom_stt_config": { "provider": "deepgram", "endpointing_ms": 800 }
8
}
9
// Agent-level: applies to every turn.
10
// A Conversation Flow node can override responsiveness and stt_mode for one step.

1
// PATCH https://api.vapi.ai/assistant/{assistant_id}
2
{
3
  "startSpeakingPlan": {
4
    "waitSeconds": 0.4,
5
    "smartEndpointingPlan": { "provider": "livekit", "waitFunction": "200 + 8000 * x" },
6
    "customEndpointingRules": [
7
      {
8
        "type": "assistant",
9
        "regex": "account number",
10
        "regexOptions": [{ "type": "ignore-case", "enabled": true }],
11
        "timeoutSeconds": 3
12
      }
13
    ]
14
  },
15
  "stopSpeakingPlan": { "numWords": 2, "voiceSeconds": 0.3, "backoffSeconds": 1 }
16
}

1
from livekit.agents import Agent, AgentSession, TurnHandlingOptions, inference
2

3
session = AgentSession(
4
    # ... stt, llm, tts
5
    turn_handling=TurnHandlingOptions(
6
        turn_detection=inference.TurnDetector(),  # or "vad", "stt", or "manual"
7
        endpointing={"mode": "dynamic", "min_delay": 0.5, "max_delay": 3.0},
8
        interruption={"mode": "adaptive"},  # an "uh-huh" doesn't stop the agent
9
    ),
10
)
11

12
# Handed off from your main agent when it's time to collect the number
13
class AccountNumberAgent(Agent):
14
    def __init__(self) -> None:
15
        super().__init__(
16
            instructions="Ask for the account number, then read it back to confirm."
17
        )
18

19
    async def on_enter(self) -> None:
20
        # Callers pause mid-number. Wait longer before ending their turn.
21
        # Takes effect on the caller's next turn.
22
        self.session.update_options(endpointing_opts={"min_delay": 1.5, "max_delay": 5.0})
23
        await self.session.generate_reply(instructions="Ask for the account number.")
24

25
    async def on_exit(self) -> None:
26
        self.session.update_options(endpointing_opts={"min_delay": 0.5, "max_delay": 3.0})

1
import difflib
2
import re
3

4
from livekit.agents import Agent, ChatContext, ChatMessage
5

6
def normalize(text: str) -> str:
7
    return re.sub(r"[^A-Z0-9]", "", text.upper())
8

9
class OrderStatusAgent(Agent):
10
    async def on_user_turn_completed(
11
        self, turn_ctx: ChatContext, new_message: ChatMessage
12
    ) -> None:
13
        # Runs after STT and before the LLM, in the agent process. No network hop.
14
        orders = self.session.userdata.open_orders  # looked up by caller ID at call start
15
        spoken = normalize(new_message.text_content or "")
16
        candidates = {normalize(o.id): o for o in orders}
17
        match = difflib.get_close_matches(spoken, list(candidates), n=1, cutoff=0.6)
18
        if not spoken or not match:
19
            return  # nothing order-like; the model handles the turn as-is
20

21
        order = candidates[match[0]]
22
        # Replace the turn. The model relays a verified status instead of guessing digits.
23
        new_message.content = [
24
            f"What's the status of order {order.id}? "
25
            f"[Verified from the caller's account: {order.status}, arriving {order.eta}]"
26
        ]

1
// PATCH https://api.retellai.com/update-agent/{agent_id}
2
{
3
  "voicemail_option": {
4
    "action": {
5
      "type": "prompt",
6
      "text": "Leave a short message for {{name}} asking them to call us back at {{callback_number}}."
7
    }
8
  },
9
  "ivr_option": { "action": { "type": "hangup" } }
10
}
11

12
// To navigate a menu instead of hanging up, leave ivr_option unset and give the
13
// Retell LLM a press_digit tool. PATCH https://api.retellai.com/update-retell-llm/{llm_id}
14
{
15
  "general_tools": [{ "type": "press_digit", "name": "press_digit", "delay_ms": 1000 }]
16
}
17

18
// The call webhook reports one reason per dial:
19
// "disconnection_reason": "voicemail_reached" | "ivr_reached" | ...
20
// A call classified as IVR never triggers the voicemail action.

1
// PATCH https://api.vapi.ai/assistant/{assistant_id}
2
{
3
  "voicemailDetection": {
4
    "provider": "vapi",
5
    "backoffPlan": { "startAtSeconds": 2, "frequencySeconds": 2.5, "maxRetries": 5 },
6
    "beepMaxAwaitSeconds": 20
7
  },
8
  "voicemailMessage": "Hi, this is Acme calling for {{name}}. Please call us back at 555-0100.",
9
  "model": {
10
    "provider": "openai",
11
    "model": "gpt-4.1",
12
    "messages": [
13
      {
14
        "role": "system",
15
        "content": "... If you hear a phone menu, stay silent until the options finish, then use the dtmf tool (for example keys \"w2\") to reach billing."
16
      }
17
    ],
18
    "tools": [{ "type": "dtmf" }]
19
  }
20
}
21

22
// Then POST https://api.vapi.ai/call with phoneNumberId, customer.number and assistantId.
23
// The end-of-call report gives one verdict: "endedReason": "voicemail", or not.
24
// A menu, a full mailbox and silence all read as "not voicemail", so the assistant
25
// starts talking, and getting through the menu depends on the model calling dtmf.

1
import os
2

3
from livekit import api
4
from livekit.agents import AMD, AgentSession, JobContext
5

6
SIP_TRUNK_ID = os.environ["LIVEKIT_SIP_OUTBOUND_TRUNK"]
7

8
async def dial(ctx: JobContext, session: AgentSession, phone_number: str) -> None:
9
    identity = "callee"
10
    session.room_io.set_participant(identity)
11

12
    # Start AMD before the callee joins so no early audio is lost. The agent's
13
    # speech is paused until the verdict is in.
14
    async with AMD(session, participant_identity=identity) as detector:
15
        await ctx.api.sip.create_sip_participant(
16
            api.CreateSIPParticipantRequest(
17
                room_name=ctx.room.name,
18
                sip_trunk_id=SIP_TRUNK_ID,
19
                sip_call_to=phone_number,
20
                participant_identity=identity,
21
                wait_until_answered=True,
22
            )
23
        )
24
        await ctx.wait_for_participant(identity=identity)
25

26
        result = await detector.execute()  # STT and LLM you pick, prompt you can edit
27
        log_dial_outcome(phone_number, result.category, result.transcript)  # your ops report
28

29
        if result.category in ("human", "uncertain"):
30
            pass  # the paused reply plays and the conversation continues
31
        elif result.category == "machine-ivr":
32
            pass  # IVR navigation already started (ivr_detection=True is the default)
33
        elif result.category == "machine-vm":
34
            handle = session.generate_reply(
35
                instructions="Leave a brief message asking the customer to call back."
36
            )
37
            await handle.wait_for_playout()
38
            ctx.shutdown("voicemail")
39
        elif result.category == "machine-unavailable":
40
            ctx.shutdown("mailbox full or not set up")  # retry later

1
// On the Retell LLM. PATCH https://api.retellai.com/update-retell-llm/{llm_id}
2
{
3
  "general_tools": [
4
    {
5
      "type": "transfer_call",
6
      "name": "transfer_to_specialist",
7
      "description": "Transfer the caller to a billing specialist after they confirm.",
8
      "transfer_destination": { "type": "predefined", "number": "+14155550100" },
9
      "transfer_option": {
10
        "type": "warm_transfer",
11
        "agent_detection_timeout_ms": 30000,
12
        "on_hold_music": "relaxing_sound",
13
        "show_transferee_as_caller": true,
14
        "private_handoff_option": {
15
          "type": "prompt",
16
          "prompt": "Whisper a one-sentence summary of the caller's issue to the specialist."
17
        },
18
        "public_handoff_option": {
19
          "type": "static_message",
20
          "message": "You're now connected."
21
        }
22
      }
23
    }
24
  ]
25
}
26
// Warm transfer: the whisper is one-way. Agentic warm transfer adds a screening agent.
27
// If nobody picks up within agent_detection_timeout_ms, the tool fails and
28
// your agent carries on with the caller.

1
// In the assistant's model.tools, or POST https://api.vapi.ai/tool
2
{
3
  "type": "transferCall",
4
  "destinations": [
5
    {
6
      "type": "number",
7
      "number": "+14155550100",
8
      "description": "Transfer to a billing specialist after the caller agrees",
9
      "transferPlan": {
10
        "mode": "warm-transfer-experimental",
11
        "transferAssistant": {
12
          "firstMessage": "Hi, I have a caller with a billing question on hold. Can you take it?",
13
          "firstMessageMode": "assistant-speaks-first",
14
          "maxDurationSeconds": 120,
15
          "silenceTimeoutSeconds": 30,
16
          "model": {
17
            "provider": "openai",
18
            "model": "gpt-4o",
19
            "messages": [
20
              {
21
                "role": "system",
22
                "content": "Brief the specialist and answer their questions. Call transferSuccessful when they accept. Call transferCancel on voicemail, no answer, or a decline."
23
              }
24
            ]
25
          }
26
        },
27
        "holdAudioUrl": "https://example.com/hold.mp3",
28
        "fallbackPlan": {
29
          "message": "I couldn't reach a specialist. I can keep helping you.",
30
          "endCallEnabled": false
31
        }
32
      }
33
    }
34
  ]
35
}
36
// The other seven modes are one-way. This one runs a second assistant that
37
// talks to the specialist; on decline or no answer the caller gets the
38
// fallbackPlan message and either returns to your assistant or the call ends.

1
import os
2

3
from livekit.agents import Agent
4
from livekit.agents.beta.workflows import WarmTransferTask, WorkflowInstructions
5
from livekit.agents.llm import ToolError, function_tool
6

7
SPECIALIST_NUMBER = os.environ["SPECIALIST_PHONE_NUMBER"]
8

9
class SupportAgent(Agent):
10
    @function_tool
11
    async def transfer_to_specialist(self) -> None:
12
        """Transfer the caller to a billing specialist. Only call after the caller confirms."""
13
        await self.session.say(
14
            "Please hold while I check if a specialist is available.",
15
            allow_interruptions=False,
16
        )
17
        try:
18
            # One awaited task: dials the specialist into a private room, plays hold music
19
            # to the caller, briefs the specialist from chat_ctx, and gives them three tools:
20
            # connect_to_caller, decline_transfer(reason), voicemail_detected.
21
            await WarmTransferTask(
22
                sip_call_to=SPECIALIST_NUMBER,
23
                sip_trunk_id=os.environ["LIVEKIT_SIP_OUTBOUND_TRUNK"],
24
                chat_ctx=self.chat_ctx,
25
                ringing_timeout=25.0,
26
                instructions=WorkflowInstructions(
27
                    extra="Say who is calling and what they need, then answer questions."
28
                ),
29
            )
30
        except ToolError as e:
31
            # No answer, "human agent declined to connect: <reason>", or "voicemail detected".
32
            # The caller is already off hold. The reason goes back to the model as the tool result.
33
            raise ToolError(f"Could not transfer: {e}. Apologize and offer to take a message.") from e
34

35
        await self.session.say(
36
            "You're connected with a specialist now. Goodbye.", allow_interruptions=False
37
        )
38
        self.session.shutdown()

3. Will the agent need to work beyond phone calls, on web, mobile, video, devices or WhatsApp?#

The table is the quick version. Here’s each channel in more detail, and what it takes to support it on each platform.

Which platforms include phone numbers?#

All three, with different limits.

Retell is the only one that sells outbound-ready numbers with no telephony account. LiveKit and Vapi each include a free US number, and both are inbound-only.

Outbound on either means bringing a carrier. Vapi imports the number and handles the rest. LiveKit exposes the SIP layer: you configure trunks and dispatch rules, pick carrier and transport, and dial with CreateSIPParticipant. LiveKit is also the only one that answers WhatsApp voice calls natively, through a Cloud-only connector.

Can the agent send and receive SMS?#

All three, in different ways: Retell as a product, Vapi through Twilio, and LiveKit with a small amount of code.

Retell is the only one with SMS as a product: two-way texting on its own numbers, MMS attachments the agent can read, agent-initiated outbound, and A2P registration handled in the dashboard.

Vapi's SMS is a thin layer over a Twilio account you bring. It sets the webhook, keeps a 24-hour session per customer, and replies. It's Twilio-only, US-only, customer-initiated only, and has no MMS.

LiveKit doesn't ship SMS as a separate product, but adding it takes little code. Sending a text is a function tool that calls your carrier's API, and receiving one is a short webhook that passes the message into a text-only agent session. Because it's your code, it works with any carrier, the agent can text first or mid-call, and an MMS photo goes to the model as an image.

Can customers chat with the agent by typing on a website?#

All three, and each widget now handles voice too.

Retell's widget does text chat and browser voice calls, and Vapi's runs in either voice or text mode, one at a time. Both add a chat API. LiveKit's hosted widget is voice-first with a text pane. A text-only widget is two flags on the agent and a fork of the open-source embed starter. It’s buildable, but not prebuilt for you.

Which platforms have mobile SDKs, and are they maintained?#

All three run in a browser; only LiveKit's mobile SDKs are current.

Retell's client SDK is browser-only, though actively maintained. Vapi lists Web, iOS, Flutter, React Native and Python. The web package is current, but (as of October 2026) Flutter and React Native were last published in mid-2025, the iOS SDK has no tagged release, and the Python client hasn't shipped since 2024.

LiveKit ships ten client SDKs (web, Swift, Android, Flutter, React Native, Unity, Unity WebGL, C++, Rust, ESP32), each usually updated weekly.

Can the agent see video or images?#

Only on LiveKit.

In an STT-LLM-TTS pipeline you sample frames from the user's camera or screen into any vision-capable LLM. With Gemini Live or OpenAI Realtime, live video streams to the model directly (Python). Vapi's web SDK can start a screen share and record the call, but nothing actually reaches the model. Retell has no video plane. Its one media path is MMS during a phone call: images, audio or video the caller texts in, which the agent can describe.

Which platforms support video avatars?#

LiveKit has 16 avatar plugins.

Vapi's Tavus integration has dropped out of its documentation and survives only as credential and voice-provider types in the API. Retell has none.

Can the agent run on hardware, including a robot?#

Only LiveKit.

It runs on ESP32, embedded Linux and Nvidia Jetson, so the SDKs behind a phone agent also power a speaker, a kiosk or a wearable. For robots, LiveKit streams camera, sensor and control data in the same room as the voice agent, and LiveKit Portal syncs frames with robot state, arbitrates control between operator and policy, and bridges ROS and LeRobot.

Can more than two people be on the call?#

Only on LiveKit.

A room holds any number of humans and agents, which is how warm transfer, supervisor barge-in, and multi-agent calls work. On Retell and Vapi a call is one caller and one assistant; a second human only arrives through a transfer, and there's no documented way to add a third party and keep the agent on the line.

4. Is cost at scale a relevant concern?#

At the end of the day, most teams want a measurable ROI from their investment in voice. In many cases, the biggest return comes from two things: whether your agent delivers a successful experience to your end users, and whether the platform makes it easier for your developers to build, iterate, deploy, and keep optimizing it, which saves engineering time. At scale, though, cost starts to weigh more heavily, and it’s where the platforms diverge most.

Every voice agent bill has the same four parts: a platform fee for running the agent, model costs for STT, LLM and TTS (or a speech-to-speech model), telephony, and whatever you pay for logs and recordings. The model and carrier costs are roughly the same wherever you run them. The platform fee is where the vendors differ, and it's the part that scales with your minutes.

What you pay the platform#

Why the gap opens up#

Retell and Vapi charge a flat per-minute platform fee. It's the same rate at your first thousand minutes and your millionth, so the bill grows in a straight line with usage.

LiveKit Cloud charges a lower per-minute rate plus a plan fee, and each plan includes a block of minutes before per-minute charges start. At low volume the plan fee makes LiveKit cost about the same as the others. As usage grows, the included minutes and the lower rate pull the per-minute cost down, which is why the gap widens with every order of magnitude. Past the point where any vendor's list price applies, all three negotiate, and the more relevant LiveKit option becomes self-hosting, where the platform fee is zero.

Model costs: same providers, different billing#

Bring the same STT, LLM and TTS to each platform and the per-minute cost is similar at launch. It diverges as the agent matures, because prompts grow: more instructions, more tools, a knowledge base.

Retell prices each model per minute and scales the bill up once your prompt passes a token threshold, counting instructions, tool definitions, the transcript so far and knowledge base content. Vapi passes through the provider's per-token price. LiveKit Inference bills per token, charges repeated prompt context at the provider's cached rate, and serves fast open-weight models like Gemma 4 for a fraction of a cent per minute. Switching models is one line of code.

Concurrency#

All three include a concurrency allowance and charge for more. Retell and Vapi sell additional capacity per line per month, and with burst turned on, Retell adds a $0.10/min surcharge to calls over your limit. LiveKit's allowance scales with plan tier and can be raised on Scale, with no per-line fee.

Compliance#

All three support HIPAA workloads, but at different price points: Retell includes a BAA on pay-as-you-go, LiveKit includes HIPAA and region pinning from the Scale plan up, and Vapi sells HIPAA mode as a monthly add-on. Vapi and LiveKit offer EU regions; Retell doesn't publish one.

Self-hosting#

Only LiveKit is open source. Run it yourself and there's no platform fee and no concurrency quota from the vendor; you pay for your own infrastructure and any Cloud-only pieces you keep, like Inference, phone numbers and observability. Retell and Vapi have no self-hosted option.

Bottom line: If volume is low and will stay low, the first three questions decide it. If you're heading past 1,000 or 10,000 minutes a month, expect your prompts to grow, or need the audio path in your own infrastructure, LiveKit's pricing is built for that, and it's the only one of the three you can run without the vendor.

Putting it together: which platform fits which team?#

There's no wrong answer here, only a wrong fit. Map your team against the four questions and one platform usually falls out. For most teams, the deciding one is the second: how often you'll need to go past the defaults.

Choose Retell if the agent needs to run without engineers. It's the only one of the three where the whole agent lives in a visual editor a non-developer can own, and it ships the most as products: numbers, SMS, batch calling, a knowledge base. The ceiling is whatever the editor exposes.

Choose Vapi if a developer prefers to assemble the agent from configuration, the defaults are good enough, and the use case follows a well-worn path: simple scheduling, qualification, campaigns. Vapi keeps adding rails for those patterns. You're opting into them rather than writing and optimizing the behavior for your own use case.

Choose LiveKit if your developers would rather build the agent in code than in configuration. With LiveKit, the agent is a program in your repo, so changes go through pull requests, code review, tests and CI like the rest of your stack, and coding agents like Claude Code, Cursor and Codex can build and change it directly. That matters most once you go past the defaults (which most production agents do). It's also the stronger fit if cost at scale matters. The tradeoff is that there's no visual editor or pre-packaged outbound calling campaign product.

One more cut that's easy to miss: Retell and Vapi are built for customer-facing calls. Their feature sets (transfers, voicemail detection, campaigns, SMS follow-up, batch dialing) are primarily contact-center features, and the unit of work is focused around a phone call with one caller and one assistant. If you're building a language-learning app, a voice coaching product, a tutoring or companionship experience, an in-game character, or a voice interface for a device, the product is the conversation itself and LiveKit is the only one of the three built to support that.

Frequently asked questions#