---
title: "Retell vs. Vapi vs. LiveKit for voice AI agents: A comparison for developers"
date: "2026-10-06"
authors: "Mike Chirokas"
tags: "guide"
---

# 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.

<ComparisonTable highlight="LiveKit" wide>
  | Consideration factor            | Retell                                                                           | Vapi                                                                            | LiveKit                                                                                                                                                     |
  | ------------------------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | Product category                | Managed voice-agent platform                                                     | Developer-oriented managed voice platform                                       | Developer-oriented [open source framework and cloud platform](/blog/best-open-source-voice-and-video-ai-agent-frameworks)                                   |
  | Who owns the agent after launch | Ops or business teams, in a visual editor; developers via an API that mirrors it | A developer, through config, APIs and webhooks; routine tuning in the dashboard | Engineers who keep iterating on the agent as code                                                                                                           |
  | Primary interface for building  | Drag-and-drop workflow editor                                                    | Assistant config via dashboard or API, plus webhooks                            | [Python and Node.js agent SDKs](https://docs.livekit.io/agents/), a CLI to deploy. Includes an [Agent Builder](/products/agent-builder) for getting started |
  | Channels                        | Phone (numbers included), SMS, web chat widget                                   | Phone (free inbound number), web SDK, chat API                                  | Phone (numbers included), web, mobile, video, devices and robots, WhatsApp, multi-party rooms                                                               |
  | Open source and self-hosting    | No                                                                               | No                                                                              | Yes, [Apache 2.0](https://github.com/livekit/livekit); run on LiveKit Cloud or your own infrastructure                                                      |
  | Estimated cost per minute\*     | \~$0.070–$0.310                                                                  | \~$0.070–$0.116                                                                 | \~$0.037–$0.099                                                                                                                                             |

  \* All-in estimates, including models, using your own phone number over each platform's SIP connection. [Retell's range](https://www.retellai.com/pricing) is the one it publishes on its pricing page. [Vapi's](https://vapi.ai/pricing) sums its pricing calculator's per-minute rates for hosting, AssemblyAI, OpenAI and Cartesia, with no success package. [LiveKit's](/pricing) runs from Gemma 4 31B, AssemblyAI Universal-Streaming and Fish Audio S2.1 Pro to the most expensive options through LiveKit Inference: GPT-5.5, AssemblyAI Universal-3.6 Pro Streaming and Cartesia Sonic 3.5. It includes $0.010/min for observability, and excludes your SIP carrier's charges (about $0.008/min), monthly plan fees and Scale plan discounts, which bring the upper end down to about $0.092. Public list prices, October 2026. [Skip to question 4](#4-is-cost-at-scale-a-relevant-concern) for monthly totals by volume.
</ComparisonTable>

## 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?

<Alert variant="note" title="Short answer">
  Retell is built so a non-engineer can improve the agent, which works until the change isn't a field Retell exposes. Vapi lets a developer script changes while Vapi runs the call, which means developers live inside Vapi's schema and versioning. LiveKit’s open source Agent framework puts the agent in your repo, which gives maximum flexibility for iterations and optimizations, but assumes you have engineers to keep iterating on it.
</Alert>

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.

<ComparisonTable highlight="LiveKit" wide>
  |               | Retell                                                                                           | Vapi                                                                                                                                     | LiveKit                                                                                                         |
  | ------------- | ------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
  | The agent is  | Configuration (dashboard first; API exposes the same fields)                                     | Configuration (API or dashboard)                                                                                                         | A program you deploy                                                                                            |
  | A change is   | [Edit a draft, diff, publish, roll out by %](https://docs.retellai.com/agent/version-comparison) | [Edit a draft, publish, split traffic by % (beta), or PATCH the assistant](https://docs.vapi.ai/assistants/versioning/traffic-splitting) | Pull request, [lk agent deploy](https://docs.livekit.io/deploy/agents/managing-deployments/), rollback if wrong |
  | Who builds it | Ops or marketing                                                                                 | Usually a developer                                                                                                                      | A developer                                                                                                     |
  | Testing       | [Text-only simulations](https://docs.retellai.com/test/llm-simulation-testing)                   | [Voice + chat simulations](https://docs.vapi.ai/observability/simulations-overview)                                                      | [Full-pipeline audio simulations](https://docs.livekit.io/testing/simulations/)                                 |
  | Tradeoff      | More flexibility for non-developers, but less flexibility for developers                         | Some flexibility for developer configuration, some flexibility for non-developers                                                        | Full flexibility for developers, but it always requires one                                                     |
</ComparisonTable>

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

<Alert variant="note" title="Short answer">
  The difference comes in how developers make a change and their limits. On Retell, you stop where the slider or field stops. On Vapi, you PATCH the assistant until the schema runs out. On LiveKit, it's a code change to the agent itself in your repo. The hosted platforms ship more out of the box, and if your workflow fits perfectly within their presets you might launch faster. However, many agents outgrow presets, and that's usually where working in code pays off. Instead of hunting for a setting that might do what you need, you write the change, test it like the rest of your code, and ship it using your git-based workflows (often with a coding agent doing much of the work).
</Alert>

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](https://docs.retellai.com/build/knowledge-base) and [eleven first-party connectors for CRMs, calendars, helpdesks and knowledge sources](https://docs.retellai.com/integrations/overview) or [Vapi's “Campaigns” feature](https://docs.vapi.ai/outbound-campaigns/overview). 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”.

<ComparisonTable highlight="LiveKit" wide>
  | I want to…                                                         | Retell                                                                                                                                                                                                                                           | Vapi                                                                                                                                                                                                           | LiveKit                                                                                                                                                                                                                                                                                                                                                      |
  | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
  | Control how fast the agent replies and when it can be interrupted  | [Wait-time and interruption sliders](https://docs.retellai.com/build/single-multi-prompt/configure-basic-settings), per agent or per flow node; built-in end-of-turn detection you can't swap                                                    | [Choose the turn model, set wait times by punctuation or regex](https://docs.vapi.ai/customization/speech-configuration), and tune interruption by word count and seconds                                      | Full flexibility to choose [how turns are detected](https://docs.livekit.io/agents/logic/turns/) (with the [built-in AI model](https://docs.livekit.io/agents/logic/turns/turn-detector/), silence, or transcript). You can also tune min/max wait and interruption thresholds.                                                                              |
  | Remove background noise and other speakers from the caller's audio | One setting, three options: [off, noise only (default), or noise + background speech (+metered)](https://docs.retellai.com/build/handle-background-noise)                                                                                        | [Krisp denoising (noise and background voices) on or off](https://docs.vapi.ai/documentation/assistants/conversation-behavior/background-speech-denoising), plus an experimental Fourier filter you tune by dB | Choose [noise suppression (free) or voice isolation (metered)](https://docs.livekit.io/transport/media/noise-cancellation/), Krisp or [ai-coustics](/blog/telli-automates-high-volume-enterprise-phone-operations-with-livekit-ai-coustics), a telephony-tuned variant for SIP, adjust suppression level mid-call, or pick a different model per participant |
  | Redact or edit what the caller said before the model sees it       | [Post-call only](https://docs.retellai.com/accounts/privacy-disable), or host your own LLM server                                                                                                                                                | [Deepgram redaction at transcription](https://docs.vapi.ai/api-reference/assistants/update), or host your own LLM server                                                                                       | [A hook in your process](https://docs.livekit.io/agents/logic/nodes/), no network hop                                                                                                                                                                                                                                                                        |
  | Keep the conversation going while a long-running tool runs         | Agent fills the wait and answers if the caller speaks; the result lands in the transcript but isn't read back. [Fields on the tool](https://docs.retellai.com/build/single-multi-prompt/custom-function), set in the dashboard or agent JSON     | Agent holds the turn. Fields on the tool JSON, set in the dashboard or via API                                                                                                                                 | You decide, in the tool function itself (Python or Node). Agent can keep talking and speak the result when it lands. Full flexibility to choose [how you handle async tools](https://docs.livekit.io/agents/logic/tools/async/)                                                                                                                              |
  | Let a human screen the transfer                                    | [A screening agent talks with the human, then bridges or cancels](https://docs.retellai.com/build/single-multi-prompt/transfer-call). A decline or timeout returns the caller to your agent, without the human's reason. Dashboard or agent JSON | Human hears a message or summary, then is bridged. [Talking back or declining needs the experimental mode](https://docs.vapi.ai/calls/assistant-based-warm-transfer). Configured in transferPlan JSON          | Human can question the agent, connect, decline with a reason, or flag voicemail. Each outcome returns to your code. [One awaited task](https://docs.livekit.io/telephony/features/transfers/warm/), extend with your own tools                                                                                                                               |
</ComparisonTable>

#### 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.

<Collapsible summary="Scenario 1: A caller pauses mid-sentence and the agent cuts them off" defaultOpen={false}>
  "My account number is… hang on…" and the agent is already answering a question the caller hadn't finished. Every platform's defaults are tuned for a caller who talks in one steady stream. Fixing it for the caller who doesn't is usually the first optimization a team makes, and a good test of how far each platform's knobs reach.

  **Retell** gives you a [Response Wait time slider](https://docs.retellai.com/build/single-multi-prompt/configure-basic-settings) (0 to 5.5 seconds; `responsiveness`, 0 to 1, in the API), interruption\_sensitivity, and an enable\_dynamic\_responsiveness toggle that adapts to the caller's pace. Retell already waits longer when it thinks the caller hasn't finished, but you can't choose or tune that detection. [Switch STT to custom mode](https://docs.retellai.com/build/transcription-mode) and you can also set the provider's endpointing\_ms. To wait longer only after the agent asks for a number, build a Conversation Flow and override those settings on the node that collects it.

  ```json
  // PATCH https://api.retellai.com/update-agent/{agent_id}
  {
    "responsiveness": 0.6,
    "interruption_sensitivity": 0.7,
    "enable_dynamic_responsiveness": true,
    "stt_mode": "custom",
    "custom_stt_config": { "provider": "deepgram", "endpointing_ms": 800 }
  }
  // Agent-level: applies to every turn.
  // A Conversation Flow node can override responsiveness and stt_mode for one step.
  ```

  **Vapi** exposes far more in startSpeakingPlan: pick a smart endpointing provider ([Vapi's docs recommend LiveKit's turn detector for English](https://docs.vapi.ai/customization/speech-configuration)) or, without one, set separate wait times for turns that end on punctuation, no punctuation, or a number, and add regex rules that override either so the assistant waits longer after it says "account number." stopSpeakingPlan tunes interruption by word count and seconds. It's a PATCH to the assistant or a dashboard edit, and for this scenario it's enough. The ceiling is that the rule has to be expressible as a regex and a number of seconds.

  ```json
  // PATCH https://api.vapi.ai/assistant/{assistant_id}
  {
    "startSpeakingPlan": {
      "waitSeconds": 0.4,
      "smartEndpointingPlan": { "provider": "livekit", "waitFunction": "200 + 8000 * x" },
      "customEndpointingRules": [
        {
          "type": "assistant",
          "regex": "account number",
          "regexOptions": [{ "type": "ignore-case", "enabled": true }],
          "timeoutSeconds": 3
        }
      ]
    },
    "stopSpeakingPlan": { "numWords": 2, "voiceSeconds": 0.3, "backoffSeconds": 1 }
  }
  ```

  **LiveKit** treats turn-taking as a pipeline stage you configure in code: choose the detector (the turn-detector model, VAD, STT endpointing, or manual), set min\_delay and max\_delay, [switch endpointing to dynamic](https://docs.livekit.io/reference/agents/turn-handling-options/) so the delay tracks the caller's actual pauses, and [use adaptive interruption](https://docs.livekit.io/agents/logic/turns/adaptive-interruption-handling/) so an "uh-huh" doesn't stop the agent. Because it's code, the rule can be anything your app knows. Here the agent that collects the number changes the timing on entry, and it takes effect on the caller's next turn:

  <TabbedCodeBlock>
    <TabbedCodeBlock.File label="Python">
      ```python
      from livekit.agents import Agent, AgentSession, TurnHandlingOptions, inference

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

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

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

          async def on_exit(self) -> None:
              self.session.update_options(endpointing_opts={"min_delay": 0.5, "max_delay": 3.0})
      ```
    </TabbedCodeBlock.File>

    <TabbedCodeBlock.File label="TypeScript">
      ```typescript
      import { inference, voice } from '@livekit/agents';

      const session = new voice.AgentSession({
        // ... stt, llm, tts
        turnHandling: {
          turnDetection: new inference.TurnDetector(), // or 'vad', 'stt', or 'manual'
          endpointing: { mode: 'dynamic', minDelay: 500, maxDelay: 3000 },
          interruption: { mode: 'adaptive' }, // an "uh-huh" doesn't stop the agent
        },
      });

      // Handed off from your main agent when it's time to collect the number
      const accountNumberAgent = voice.Agent.create({
        instructions: 'Ask for the account number, then read it back to confirm.',
        onEnter(ctx) {
          // Callers pause mid-number. Wait longer before ending their turn.
          // Takes effect on the caller's next turn.
          ctx.session.updateOptions({
            turnHandling: { endpointing: { minDelay: 1500, maxDelay: 5000 } },
          });
          ctx.session.generateReply({ instructions: 'Ask for the account number.' });
        },
        onExit(ctx) {
          ctx.session.updateOptions({
            turnHandling: { endpointing: { minDelay: 500, maxDelay: 3000 } },
          });
        },
      });
      ```
    </TabbedCodeBlock.File>
  </TabbedCodeBlock>
</Collapsible>

<Collapsible summary="Scenario 2: A caller reads out an order number and the transcript comes back garbled" defaultOpen={false}>
  The caller says "K7 dash 3R9Q." The transcript says "k7 3 are 9 queue." What happens next is where the platforms split.

  **Retell** hands the transcript to the model. [You can boost keywords in the STT](https://docs.retellai.com/reliability/wrong-transcript), which helps, but the model still has to guess the order number, call your lookup tool with its guess, and ask the caller to repeat when the lookup fails. Fixing the transcript before the model sees it means [taking over generation with a custom LLM server](https://docs.retellai.com/integrate-llm/overview).

  **Vapi** works the same way. Keyword boosting on Deepgram improves recognition, but the model still receives whatever the STT produced and does the guessing. Transforming the turn before the model means hosting a custom transcriber or a custom LLM server that Vapi streams through.

  **LiveKit** [edits the turn inside the agent process](https://docs.livekit.io/agents/logic/nodes/). You already know the caller's phone number, so you know their open orders. Fuzzy-match the garbled transcript against that list, then replace the turn with the result: "Order K7-3R9Q, shipped Tuesday, arriving Thursday." The model never guesses, never repeats a digit string, and the caller never hears "can you say that again?" No network hop, no second server.

  <TabbedCodeBlock>
    <TabbedCodeBlock.File label="Python">
      ```python
      import difflib
      import re

      from livekit.agents import Agent, ChatContext, ChatMessage

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

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

              order = candidates[match[0]]
              # Replace the turn. The model relays a verified status instead of guessing digits.
              new_message.content = [
                  f"What's the status of order {order.id}? "
                  f"[Verified from the caller's account: {order.status}, arriving {order.eta}]"
              ]
      ```
    </TabbedCodeBlock.File>

    <TabbedCodeBlock.File label="TypeScript">
      ```typescript
      import { voice } from '@livekit/agents';
      import { closest, distance } from 'fastest-levenshtein';

      interface SessionData {
        openOrders: { id: string; status: string; eta: string }[];
      }

      const normalize = (text: string) => text.toUpperCase().replace(/[^A-Z0-9]/g, '');

      const orderStatusAgent = voice.Agent.create<SessionData>({
        instructions: "Help the caller with their order.",
        // Runs after STT and before the LLM, in the agent process. No network hop.
        async onUserTurnCompleted(ctx, chatCtx, newMessage) {
          const orders = ctx.session.userData.openOrders; // looked up by caller ID at call start
          const spoken = normalize(newMessage.textContent ?? '');
          const ids = orders.map((o) => normalize(o.id));
          const best = closest(spoken, ids);
          if (!spoken || distance(spoken, best) > best.length * 0.4) {
            return; // nothing order-like; the model handles the turn as-is
          }

          const order = orders[ids.indexOf(best)]!;
          // Replace the turn. The model relays a verified status instead of guessing digits.
          newMessage.content = [
            `What's the status of order ${order.id}? ` +
              `[Verified from the caller's account: ${order.status}, arriving ${order.eta}]`,
          ];
        },
      });
      ```
    </TabbedCodeBlock.File>
  </TabbedCodeBlock>
</Collapsible>

<Collapsible summary="Scenario 3: Handle whatever picks up an outbound call: a person, voicemail, a phone menu, or nothing" defaultOpen={false}>
  Leaving a message is one field on every platform. Telling a menu from a mailbox, getting through the menu, and logging why 30% of last night's dials didn't connect is where they split.

  **Retell** [runs two detectors](https://docs.retellai.com/build/handle-voicemail). Voicemail can hang up or leave a message; the IVR detector's only action is hang up, and [navigating the menu is a separate feature](https://docs.retellai.com/build/single-multi-prompt/press-digit) you turn on. The two are handled separately, so a call classified as IVR never triggers the voicemail action

  ```json
  // PATCH https://api.retellai.com/update-agent/{agent_id}
  {
    "voicemail_option": {
      "action": {
        "type": "prompt",
        "text": "Leave a short message for {{name}} asking them to call us back at {{callback_number}}."
      }
    },
    "ivr_option": { "action": { "type": "hangup" } }
  }

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

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

  **Vapi** [picks a detection provider and returns one verdict](https://docs.vapi.ai/calls/voicemail-detection), voicemail or not. However, a menu, a full mailbox and silence all read as "not voicemail," so the agent starts its pitch. Getting through a menu depends on the model deciding to call [the dtmf tool](https://docs.vapi.ai/tools/default-tools).

  ```json
  // PATCH https://api.vapi.ai/assistant/{assistant_id}
  {
    "voicemailDetection": {
      "provider": "vapi",
      "backoffPlan": { "startAtSeconds": 2, "frequencySeconds": 2.5, "maxRetries": 5 },
      "beepMaxAwaitSeconds": 20
    },
    "voicemailMessage": "Hi, this is Acme calling for {{name}}. Please call us back at 555-0100.",
    "model": {
      "provider": "openai",
      "model": "gpt-4.1",
      "messages": [
        {
          "role": "system",
          "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."
        }
      ],
      "tools": [{ "type": "dtmf" }]
    }
  }

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

  **LiveKit** classifies with an STT and LLM you pick and a prompt you can edit, [returns one of five verdicts](https://docs.livekit.io/telephony/features/answering-machine-detection/) (person, voicemail, IVR menu, unavailable line, or uncertain) with the transcript behind it, and in Python [starts IVR navigation on its own](https://docs.livekit.io/telephony/features/dtmf/). Each verdict is a branch in your code and ops can get five reasons a dial failed, not one.

  <TabbedCodeBlock>
    <TabbedCodeBlock.File label="Python">
      ```python
      import os

      from livekit import api
      from livekit.agents import AMD, AgentSession, JobContext

      SIP_TRUNK_ID = os.environ["LIVEKIT_SIP_OUTBOUND_TRUNK"]

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

          # Start AMD before the callee joins so no early audio is lost. The agent's
          # speech is paused until the verdict is in.
          async with AMD(session, participant_identity=identity) as detector:
              await ctx.api.sip.create_sip_participant(
                  api.CreateSIPParticipantRequest(
                      room_name=ctx.room.name,
                      sip_trunk_id=SIP_TRUNK_ID,
                      sip_call_to=phone_number,
                      participant_identity=identity,
                      wait_until_answered=True,
                  )
              )
              await ctx.wait_for_participant(identity=identity)

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

              if result.category in ("human", "uncertain"):
                  pass  # the paused reply plays and the conversation continues
              elif result.category == "machine-ivr":
                  pass  # IVR navigation already started (ivr_detection=True is the default)
              elif result.category == "machine-vm":
                  handle = session.generate_reply(
                      instructions="Leave a brief message asking the customer to call back."
                  )
                  await handle.wait_for_playout()
                  ctx.shutdown("voicemail")
              elif result.category == "machine-unavailable":
                  ctx.shutdown("mailbox full or not set up")  # retry later
      ```
    </TabbedCodeBlock.File>

    <TabbedCodeBlock.File label="TypeScript">
      ```typescript
      import { type JobContext, voice } from '@livekit/agents';
      import { SipClient } from 'livekit-server-sdk';

      const SIP_TRUNK_ID = process.env.LIVEKIT_SIP_OUTBOUND_TRUNK!;

      async function dial(ctx: JobContext, session: voice.AgentSession, phoneNumber: string) {
        const identity = 'callee';
        session._roomIO!.setParticipant(identity);

        // Start AMD before the callee joins so no early audio is lost. The agent's
        // speech is paused until the verdict is in.
        const detector = new voice.AMD(session, { participantIdentity: identity });
        try {
          const sip = new SipClient(process.env.LIVEKIT_URL!);
          await sip.createSipParticipant(SIP_TRUNK_ID, phoneNumber, ctx.room.name!, {
            participantIdentity: identity,
            waitUntilAnswered: true,
          });
          await ctx.waitForParticipant(identity);

          const result = await detector.execute(); // STT and LLM you pick, prompt you can edit
          logDialOutcome(phoneNumber, result.category, result.transcript); // your ops report

          switch (result.category) {
            case voice.AMDCategory.HUMAN:
            case voice.AMDCategory.UNCERTAIN:
            case voice.AMDCategory.MACHINE_IVR: // Node has no IVR navigation yet: let the agent talk
              break; // the paused reply plays and the conversation continues
            case voice.AMDCategory.MACHINE_VM: {
              const handle = session.generateReply({
                instructions: 'Leave a brief message asking the customer to call back.',
              });
              await handle.waitForPlayout();
              session.shutdown({ reason: 'voicemail' });
              break;
            }
            case voice.AMDCategory.MACHINE_UNAVAILABLE:
              session.shutdown({ reason: 'mailbox full or not set up' }); // retry later
              break;
          }
        } finally {
          await detector.aclose();
        }
      }
      ```
    </TabbedCodeBlock.File>
  </TabbedCodeBlock>
</Collapsible>

<Collapsible summary="Scenario 4: Let a human screen the transfer" defaultOpen={false}>
  All three can brief the human before connecting. The difference is what happens after the human hears the briefing.

  **Retell** has two modes. Warm transfer [speaks a one-shot whisper, then bridges](https://docs.retellai.com/build/single-multi-prompt/transfer-call); the human can't reply. Agentic warm transfer hands off to a separate screening agent you build, which talks with the human and then bridges or cancels. A cancel or timeout sends the caller back to your agent, but your agent never learns what the human said.

  ```json
  // On the Retell LLM. PATCH https://api.retellai.com/update-retell-llm/{llm_id}
  {
    "general_tools": [
      {
        "type": "transfer_call",
        "name": "transfer_to_specialist",
        "description": "Transfer the caller to a billing specialist after they confirm.",
        "transfer_destination": { "type": "predefined", "number": "+14155550100" },
        "transfer_option": {
          "type": "warm_transfer",
          "agent_detection_timeout_ms": 30000,
          "on_hold_music": "relaxing_sound",
          "show_transferee_as_caller": true,
          "private_handoff_option": {
            "type": "prompt",
            "prompt": "Whisper a one-sentence summary of the caller's issue to the specialist."
          },
          "public_handoff_option": {
            "type": "static_message",
            "message": "You're now connected."
          }
        }
      }
    ]
  }
  // Warm transfer: the whisper is one-way. Agentic warm transfer adds a screening agent.
  // If nobody picks up within agent_detection_timeout_ms, the tool fails and
  // your agent carries on with the caller.
  ```

  **Vapi** [has eight transfer modes](https://docs.vapi.ai/tools/transfer-call). Seven are one-way: two blind, four that speak a fixed message or a generated summary, and one that runs your TwiML on the specialist's leg, then bridge. For a human who can ask a question or decline, you switch to the eighth, [warm-transfer-experimental](https://docs.vapi.ai/calls/assistant-based-warm-transfer), and prompt a second assistant to run the handoff; if the human declines or doesn't answer, the caller comes back to your assistant or the call ends, per your fallback plan.

  ```json
  // In the assistant's model.tools, or POST https://api.vapi.ai/tool
  {
    "type": "transferCall",
    "destinations": [
      {
        "type": "number",
        "number": "+14155550100",
        "description": "Transfer to a billing specialist after the caller agrees",
        "transferPlan": {
          "mode": "warm-transfer-experimental",
          "transferAssistant": {
            "firstMessage": "Hi, I have a caller with a billing question on hold. Can you take it?",
            "firstMessageMode": "assistant-speaks-first",
            "maxDurationSeconds": 120,
            "silenceTimeoutSeconds": 30,
            "model": {
              "provider": "openai",
              "model": "gpt-4o",
              "messages": [
                {
                  "role": "system",
                  "content": "Brief the specialist and answer their questions. Call transferSuccessful when they accept. Call transferCancel on voicemail, no answer, or a decline."
                }
              ]
            }
          },
          "holdAudioUrl": "https://example.com/hold.mp3",
          "fallbackPlan": {
            "message": "I couldn't reach a specialist. I can keep helping you.",
            "endCallEnabled": false
          }
        }
      }
    ]
  }
  // The other seven modes are one-way. This one runs a second assistant that
  // talks to the specialist; on decline or no answer the caller gets the
  // fallbackPlan message and either returns to your assistant or the call ends.
  ```

  **LiveKit** [runs the handoff as one awaited task](https://docs.livekit.io/agents/prebuilt/tasks/warm-transfer/). The human lands in a private room with the transcript and three tools: connect to the caller, decline with a reason, or flag voicemail. Whatever they choose comes back to your code.

  <TabbedCodeBlock>
    <TabbedCodeBlock.File label="Python">
      ```python
      import os

      from livekit.agents import Agent
      from livekit.agents.beta.workflows import WarmTransferTask, WorkflowInstructions
      from livekit.agents.llm import ToolError, function_tool

      SPECIALIST_NUMBER = os.environ["SPECIALIST_PHONE_NUMBER"]

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

              await self.session.say(
                  "You're connected with a specialist now. Goodbye.", allow_interruptions=False
              )
              self.session.shutdown()
      ```
    </TabbedCodeBlock.File>

    <TabbedCodeBlock.File label="TypeScript">
      ```typescript
      import { llm, voice, workflows } from '@livekit/agents';

      const SPECIALIST_NUMBER = process.env.SPECIALIST_PHONE_NUMBER!;

      const supportAgent = voice.Agent.create({
        instructions: 'You are a support agent. Confirm before transferring anyone.',
        tools: [
          llm.tool({
            name: 'transfer_to_specialist',
            description: 'Transfer the caller to a billing specialist. Only call after the caller confirms.',
            execute: async (_, { ctx }) => {
              await ctx.session
                .say('Please hold while I check if a specialist is available.', { allowInterruptions: false })
                .waitForPlayout();
              try {
                // One awaited task: dials the specialist into a private room, plays hold music
                // to the caller, briefs the specialist from chatCtx, and gives them three tools:
                // connect_to_caller, decline_transfer(reason), voicemail_detected.
                await new workflows.WarmTransferTask({
                  sipCallTo: SPECIALIST_NUMBER,
                  sipTrunkId: process.env.LIVEKIT_SIP_OUTBOUND_TRUNK,
                  chatCtx: ctx.session.history,
                  ringingTimeout: 25_000,
                  instructions: { extra: 'Say who is calling and what they need, then answer questions.' },
                }).run();
              } catch (e) {
                // No answer, "human agent declined to connect: <reason>", or "voicemail detected".
                // The caller is already off hold. The reason goes back to the model as the tool result.
                throw new llm.ToolError(`Could not transfer: ${e}. Apologize and offer to take a message.`);
              }

              await ctx.session
                .say("You're connected with a specialist now. Goodbye.", { allowInterruptions: false })
                .waitForPlayout();
              ctx.session.shutdown();
            },
          }),
        ],
      });
      ```
    </TabbedCodeBlock.File>
  </TabbedCodeBlock>
</Collapsible>

<Collapsible summary="Scenario 5: Dial a list of patients tomorrow morning and report who picked up" defaultOpen={false}>
  This is the one where the hosted platforms often offer a better out-of-the-box experience.

  Retell and Vapi ship it as a product. [Retell's Batch Call](https://docs.retellai.com/deploy/make-batch-call) takes a list with per-recipient variables, a start time, a call window and reserved concurrency, and shows Sent, Picked Up and Successful in the dashboard. [Vapi's Campaigns take up to 10,000 contacts](https://docs.vapi.ai/outbound-campaigns/contact-data), a schedule window, a concurrency cap, per-contact webhooks and [a pre-dial eligibility hook](https://docs.vapi.ai/outbound-campaigns/webhooks). Neither needs code.

  As an open source framework, LiveKit Agents has no campaign product. [Each dial is one dispatch against a SIP trunk you bring](https://docs.livekit.io/telephony/making-calls/outbound-calls/), and the list, the schedule, the pacing and the report are yours. It’s a real afternoon of work that the hosted platforms save you. What you get for it is no ceiling: pacing, retries and reporting are whatever you write, and concurrency is a plan tier rather than a per-line fee.
</Collapsible>

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

<Alert variant="note" title="Short answer">
  All three answer a phone. Retell adds SMS, MMS and a web chat widget as products. Vapi adds SMS through your Twilio number and a chat API. LiveKit is the only one where the model can see video (like a screen-share), a call can have more than two participants, the agent can run on hardware that isn't a phone or a browser, or answer a WhatsApp call. If the roadmap ends at phone plus text, any of the three works. If it includes web, mobile, video or devices, this question decides it.
</Alert>

<ComparisonTable highlight="LiveKit" wide>
  | Channel                              | Retell                                                                                                                                             | Vapi                                                                                                                                                                         | LiveKit                                                                                                                                                                                     |
  | ------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | Phone numbers                        | [Buy US or Canada numbers](https://docs.retellai.com/deploy/purchase-number), inbound and outbound, calls to 15 countries. SIP import for the rest | [One free US number, inbound only](https://docs.vapi.ai/free-telephony). Outbound means importing a Twilio, Vonage, Telnyx or DIDWW number, or a SIP trunk                   | [One free US local number per plan](https://docs.livekit.io/telephony/start/phone-numbers/), inbound only today. Outbound and other countries run on a SIP trunk you configure              |
  | SMS and MMS                          | [A product on Retell or Twilio numbers](https://docs.retellai.com/deploy/enable-sms). Two-way, MMS in, agent can text first or mid-call            | [Glue over your Twilio account](https://docs.vapi.ai/phone-numbers/inbound-sms). Customer-initiated only, US to US, 24-hour sessions, no MMS. A built-in tool texts mid-call | Sending via Twilio or others is a function tool. Receiving is a small webhook you host that feeds a text-only session. Any carrier, agent can text first, MMS in as an image the model sees |
  | Web and in-app chat (typed, not SMS) | Chat-and-voice widget, callback widget, chat API                                                                                                   | Widget (voice or text mode, one at a time) and chat API                                                                                                                      | Voice-first widget with text pane. Text-only widget: build it from the starter                                                                                                              |
  | Web and mobile                       | [Browser SDK only, current](https://github.com/RetellAI/retell-client-js-sdk)                                                                      | Web SDK current. [Flutter and React Native last shipped mid-2025; iOS has no tagged release](https://docs.vapi.ai/resources)                                                 | [Ten client SDKs](https://docs.livekit.io/transport/sdk-platforms/), all pushed regularly                                                                                                   |
  | Video in (the model sees)            | Images, audio or video texted in mid-call (MMS), which the agent can describe                                                                      | No. Screen share and recording reach the call, not the model                                                                                                                 | [Frames into any vision LLM](https://docs.livekit.io/agents/multimodality/vision/video/); live camera or screen share with Gemini Live and OpenAI Realtime (Python)                         |
  | Avatars                              | None                                                                                                                                               | Tavus (though no longer in the docs)                                                                                                                                         | [16 plugins](https://docs.livekit.io/agents/models/avatar/)                                                                                                                                 |
  | Devices and robotics                 | None                                                                                                                                               | Python client for desktop                                                                                                                                                    | [ESP32, embedded Linux](https://docs.livekit.io/frontends/build/hardware/), Jetson; ROS and LeRobot through [LiveKit Portal](https://docs.livekit.io/robotics/integrations/portal/)         |
  | WhatsApp                             | Via automation platforms                                                                                                                           | Via automation platforms                                                                                                                                                     | Voice calls through the [WhatsApp Connector](https://docs.livekit.io/telephony/connectors/whatsapp/) (Cloud)                                                                                |
  | More than two participants           | Only through transfer                                                                                                                              | Only through transfer                                                                                                                                                        | Rooms hold any number                                                                                                                                                                       |
</ComparisonTable>

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](https://docs.livekit.io/telephony/accepting-calls/dispatch-rule/), pick carrier and transport, and [dial with CreateSIPParticipant](https://docs.livekit.io/telephony/making-calls/outbound-calls/). 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](https://docs.retellai.com/build/single-multi-prompt/send-sms), 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](https://docs.vapi.ai/chat/sms-chat), 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](https://docs.livekit.io/agents/logic/tools/definition/) that calls your carrier's API, and receiving one is a short webhook that passes the message into a [text-only agent session](https://docs.livekit.io/agents/multimodality/text/). 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](https://docs.retellai.com/deploy/chat-widget) does text chat and browser voice calls, and [Vapi's](https://docs.vapi.ai/chat/web-widget) runs in either voice or text mode, one at a time. Both add a chat API. [LiveKit's hosted widget](https://docs.livekit.io/agents/start/embed/) 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](https://docs.livekit.io/frontends/start/starter-apps/web-embed/). 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](https://pub.dev/packages/vapi), [the iOS SDK has no tagged release](https://github.com/VapiAI/client-sdk-ios), 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](https://docs.livekit.io/agents/models/realtime/gemini/) or [OpenAI Realtime](https://docs.livekit.io/agents/models/realtime/openai/), live video streams to the model directly (Python). [Vapi's web SDK can start a screen share and record the call](https://github.com/VapiAI/client-sdk-web), 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](/blog/bringing-ai-avatars-to-voice-agents).

Vapi's Tavus integration has dropped out of its documentation and [survives only as credential and voice-provider types in the API](https://github.com/VapiAI/server-sdk-typescript). Retell has none.

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

Only LiveKit.

It runs on [ESP32](/blog/livekit-sdk-for-esp32-bringing-voice-ai-to-embedded-devices), 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](/blog/teleoperate-and-collect-robot-data-with-livekit-portal) syncs frames with robot state, arbitrates control between operator and policy, and [bridges ROS](https://docs.livekit.io/robotics/integrations/ros-portal/) and LeRobot.

#### Can more than two people be on the call?

Only on LiveKit.

[A room holds any number of humans and agents](https://docs.livekit.io/intro/basics/rooms-participants-tracks/), 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?

<Alert variant="note" title="Short answer">
  All in, including models, LiveKit runs about $0.037–$0.099 a minute, against about $0.070–$0.310 on Retell and $0.070–$0.116 on Vapi. Because LiveKit's plans include a block of minutes while Retell and Vapi charge a flat rate, the gap widens with volume: at 50,000 minutes a month, LiveKit comes to about $1,096–$3,844, against $3,500–$15,500 on Retell and $3,492–$5,782 on Vapi. LiveKit also gives you two levers the others don't: cut the LLM bill to a fraction of a cent with fast open models like Gemma 4 through LiveKit Inference, or self-host the whole stack and pay no platform fee at all.
</Alert>

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 estimates below add all four together, so you can compare what you'd actually pay each month.

#### What you pay each month

<ComparisonTable highlight="LiveKit Cloud">
  Below are public list prices as of October 2026, from low-cost to premium model choices on each platform. Excludes additional concurrency and enterprise discounts, which are negotiable on all three.

  | Monthly minutes | Retell           | Vapi            | LiveKit Cloud   |
  | --------------- | ---------------- | --------------- | --------------- |
  | 1,000           | \~$70–$310       | \~$70–$116      | \~$10–$73       |
  | 10,000          | \~$700–$3,100    | \~$698–$1,156   | \~$294–$919     |
  | 50,000          | \~$3,500–$15,500 | \~$3,492–$5,782 | \~$1,096–$3,844 |

  [Retell's](https://www.retellai.com/pricing) multiply its published per-minute range, $0.07–$0.31, by your minutes. [Vapi's](https://vapi.ai/pricing) are its pricing calculator's totals with AssemblyAI, OpenAI and Cartesia, with no success package (paid packages start at $29/mo). [LiveKit's](/pricing) use the free Build plan at 1,000 minutes, Ship at 10,000 and Scale at 50,000, whichever is cheapest at that volume: the plan fee, then $0.01/min for agent sessions, $0.004/min for SIP ($0.003 on Scale) and $0.010/min for observability past each plan's included minutes, plus models from Gemma 4 31B, AssemblyAI Universal-Streaming and Fish Audio S2.1 Pro to GPT-5.5, AssemblyAI Universal-3.6 Pro Streaming and Cartesia Sonic 3.5, less the plan's included inference credits. Build caps usage at 1,000 minutes, so a team that needs headroom would be on Ship, at about $58–$120. Vapi and LiveKit exclude your SIP carrier's charges (about $0.008/min). Past 50,000 minutes a month, all three move toward negotiated pricing, so list prices stop being a reliable guide.
</ComparisonTable>

#### Why the gap opens up

[Retell and Vapi charge a flat per-minute platform fee](https://www.retellai.com/pricing). 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](/pricing), and each plan includes a block of minutes before per-minute charges start. At low volume the plan fee is most of LiveKit's bill. 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](https://docs.retellai.com/accounts/billing-exceptions), 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](/products/inference), charges repeated prompt context at the provider's cached rate, and serves [fast open-weight models like Gemma 4](/blog/latency-optimized-inference-gemma-4-on-livekit) 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](https://docs.vapi.ai/billing/purchase-call-concurrency), and [with burst turned on, Retell adds a $0.10/min surcharge to calls over your limit](https://docs.retellai.com/deploy/concurrency). [LiveKit's allowance scales with plan tier](https://docs.livekit.io/deploy/admin/quotas-and-limits/) 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](https://docs.retellai.com/general/compliance), LiveKit includes HIPAA and [region pinning](https://docs.livekit.io/deploy/admin/regions/region-pinning/) from the Scale plan up, and [Vapi sells HIPAA mode as a monthly add-on](https://docs.vapi.ai/security-and-privacy/hipaa). Vapi and LiveKit offer [EU regions](https://docs.livekit.io/deploy/admin/regions/data-residency/); Retell doesn't publish one.

#### Self-hosting

Only LiveKit is open source. [Run it yourself](https://docs.livekit.io/transport/self-hosting/) 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.

| If your team…                                                                                                               | Start with |
| --------------------------------------------------------------------------------------------------------------------------- | ---------- |
| Is building a product where voice is the experience: language learning, coaching, tutoring, companionship, gaming, a device | LiveKit    |
| Has no engineers on the agent after launch, and ops or marketing will own and iterate it                                    | Retell     |
| Has a developer who can configure and wire up webhooks, the workflow fits a standard pattern, and volume is moderate to low | Vapi       |
| Has engineers who will keep iterating, and needs to tune, extend or scale beyond the defaults                               | LiveKit    |
| Needs web, mobile, video, devices or more than two people on a call                                                         | LiveKit    |
| Expects heavy usage, or needs the audio path in its own infrastructure                                                      | LiveKit    |

**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

<Collapsible name="faq" summary="Which platform is fastest to set up: Retell, Vapi, or LiveKit?" defaultOpen={false}>
  All three can have a phone agent answering calls within a day. Retell is fastest for a team with no developer, since the whole agent is built in a visual editor. Vapi and LiveKit both take a developer an afternoon: Vapi via a config and a webhook, LiveKit via a \~[30-line agent](https://docs.livekit.io/agents/start/voice-ai/) deployed to LiveKit Cloud. For an engineering team the difference is hours, not weeks; what separates the platforms is how quickly you can change the agent after launch.
</Collapsible>

<Collapsible name="faq" summary="Which platform gives you telephony out of the box?" defaultOpen={false}>
  All three. LiveKit is often assumed to require a carrier, but [LiveKit Cloud provisions US local and toll-free numbers directly](/products/livekit-phone-numbers), includes a free local number on every plan, and answers inbound calls without a Twilio account. Outbound calls, transfers and international calls run over a SIP trunk from a provider you choose, and LiveKit is the only one of the three that [answers WhatsApp voice calls natively](https://docs.livekit.io/telephony/connectors/whatsapp/). Retell sells outbound-ready numbers with no carrier account. Vapi's free numbers are inbound-only; outbound means importing a number from Twilio, Telnyx, Vonage or a SIP trunk.
</Collapsible>

<Collapsible name="faq" summary="How do you deploy, manage, and host LiveKit?" defaultOpen={false}>
  [Run lk agent deploy](https://docs.livekit.io/deploy/agents/managing-deployments/) from your project and LiveKit Cloud builds a container from your code, deploys it, and scales it with call volume. New versions roll out without dropping calls: new sessions go to the new build while active ones finish on the old one. [Deployment logs, session metrics, recordings and traces](/products/agent-observability) are in the dashboard, with instant rollback and [separate non-production deployments](/blog/staging-deployments-for-livekit-agents) on paid plans. If you'd rather run the agent yourself, the same code deploys to [Kubernetes, Render or any container platform](https://docs.livekit.io/deploy/custom/deployments/), connected to LiveKit Cloud transport or a [self-hosted LiveKit server](https://docs.livekit.io/transport/self-hosting/).
</Collapsible>

<Collapsible name="faq" summary="Which platform has the lowest latency?" defaultOpen={false}>
  None of the three publishes a comparable end-to-end benchmark, and most of a voice agent's latency comes from the models: how fast the STT finalizes, how long the LLM takes to first sentence, how quickly the TTS starts speaking. All three let you pick fast models. Where they differ is what you can do about the rest. Retell exposes two sliders. Vapi exposes the turn model and a set of timing thresholds in config. LiveKit exposes every stage in code: how turns are detected, [which turn model runs](/blog/turn-detection-and-interruption-handling), endpointing and interruption thresholds, and where the agent runs.

  Inference is the other lever. On LiveKit Cloud the agent is hosted next to the media server and LiveKit Inference, so model calls don't leave the cluster. And LiveKit hosts latency-optimized open-weight models, like [Gemma 4 31B](/products/inference/gemma-4), on its own GPUs; on [LiveKit's public live benchmark](/benchmarks/latency) it returns a first sentence several times faster than the frontier APIs, and several times faster than the same model served through a general-purpose provider. The benchmark re-runs every ten minutes and shows p95 and p99 next to p50, because a fast median doesn't help the caller who hits the slow tail. If latency is a competitive feature of your product rather than a number to keep under a threshold, it's a difference that matters.
</Collapsible>

<Collapsible name="faq" summary="Can you use speech-to-speech models like OpenAI Realtime or Gemini Live?" defaultOpen={false}>
  Yes on all three, as a model choice. The difference is what you can do around it. On LiveKit, [a realtime model is one option in the same framework as a pipeline agent](https://docs.livekit.io/agents/models/realtime/), so you can pair it with a separate TTS voice, keep your own turn detection and noise cancellation in front of it, [hand off between realtime and pipeline agents](https://docs.livekit.io/agents/logic/agents-handoffs/) mid-call, and (in Python) stream live camera or screen-share video into it. On Retell and Vapi you select the realtime model in configuration and take the platform's handling of turns and audio.
</Collapsible>

<Collapsible name="faq" summary="Which platform should you use if voice is the product, not a support channel?" defaultOpen={false}>
  LiveKit. Retell and Vapi are designed around customer-service calls or outbound campaigns: a phone number, a caller, a resolution or a transfer. A language-learning app, a coaching product, a tutoring experience or a voice-driven game has different needs: it lives inside your web or mobile app, sessions run long, the model may need to see video, and there may be more than two participants. LiveKit's client SDKs, video support, multi-participant rooms and device targets are built for that, and the agent is code in your app, so the experience is yours to design.
</Collapsible>

<Collapsible name="faq" summary="Which is the most cost-effective at scale?" defaultOpen={false}>
  All in, including models, LiveKit runs about $0.037–$0.099 a minute, against about $0.070–$0.310 on Retell and $0.070–$0.116 on Vapi. As volume grows, Retell and Vapi's flat per-minute rates hold while LiveKit's included minutes pull its cost down: at 50,000 minutes a month, LiveKit comes to about $1,096–$3,844, against $3,500–$15,500 on Retell and $3,492–$5,782 on Vapi. Model costs are similar everywhere, with one exception: Retell scales its per-minute LLM price up as prompts grow, while LiveKit and Vapi bill per token. [See question four](#4-is-cost-at-scale-a-relevant-concern) for the numbers.
</Collapsible>

<Collapsible name="faq" summary="Can you self-host any of these?" defaultOpen={false}>
  Only LiveKit. The server, SIP service, egress and agents framework are [open source under Apache 2.0](https://github.com/livekit/livekit), so you can run the whole stack on your own infrastructure and pay LiveKit nothing. What you give up is the Cloud-only layer: managed inference, observability, the dashboard, Agent Builder, Krisp noise cancellation and LiveKit's hosted turn-detection model. Most teams that self-host keep transport on LiveKit Cloud and run only the agent themselves, which removes the per-session fee without losing those features. Retell and Vapi have no self-hosted option.
</Collapsible>

<Collapsible name="faq" summary="Can a coding agent like Codex, Claude Code, or Cursor build on these?" defaultOpen={false}>
  [All three publish an MCP server](https://docs.vapi.ai/sdk/mcp-server) and machine-readable docs, so the answer is yes for each. The difference is what the coding agent is being asked to do. On Retell and Vapi, the MCP server lets an assistant drive the platform: create agents, adjust config, place calls. On LiveKit the coding agent writes the agent itself, and LiveKit publishes a [docs MCP server](https://docs.livekit.io/reference/developer-tools/docs-mcp/), an [llms.txt index](https://docs.livekit.io/llms.txt), [a CLI](https://docs.livekit.io/reference/developer-tools/livekit-cli/agent/) and [agent skills](/blog/voice-agent-skills-for-coding-assistants) that cover workflow design, handoffs and testing, so tools like Claude Code, Cursor and Codex can efficiently build, test, iterate, and deploy an agent end to end. If your plan is to have a coding agent own most of the implementation, the code-first platform is where it has the most to work with.
</Collapsible>