A8gent

LiveKit Agents Pricing and Review (2026)

Open source framework for realtime voice AI agents.

Reviewed by A8gent
Contents
  1. Verdict
  2. What is LiveKit Agents?
  3. Best for, and not for
  4. Strengths and limits
  5. Pricing
  6. What people actually build with LiveKit Agents
  7. What LiveKit actually costs at small-business volume
  8. The gotcha: concurrency on the free tier, and four meters instead of one
  9. What breaks in production, and how you find out
  10. What it connects to that you already run
  11. LiveKit Agents alternatives: what to pick instead, and when
  12. Migration and lock-in: can you get your work out?
  13. FAQ
VerdictIs LiveKit Agents worth it?

LiveKit is the infrastructure layer rather than a voice agent product, and its pricing reflects that: as of August 2026 the Build plan is free with 1,000 agent session minutes, 5,000 participant minutes and 50GB of bandwidth, Ship is $50 a month with 5,000 agent minutes, and Scale is $500 with 50,000. Overages are cheap - $0.01 per agent session minute. Both the Agents framework and the media server are open source and self-hostable. On our 1,500-minute reference workload LiveKit's own charge is about $5 of agent-minute overage on the free Build plan; the real bill is the model, voice and telephony providers you assemble around it, and Build's $2.50 inference credit covers only about 50 of those 1,500 minutes.

What is LiveKit Agents?

LiveKit Agents is an open source framework for building realtime voice (and video) AI agents on top of LiveKit's WebRTC infrastructure, the same stack that powers voice features at OpenAI and other large AI products. You write agents in Python or Node, bring your own STT, LLM, and TTS providers, and run them either self-hosted or on LiveKit Cloud, which added first-party SIP telephony and phone numbers. It hit 1.0 in 2025 and now includes adaptive interruption handling and native MCP tool support.

Best for

Engineering teams building serious voice products at scale who want full stack control and are ready to write and operate code.

Not for

A small business that wants a working phone agent rather than a platform to build one on. LiveKit gives you excellent real-time plumbing and expects you to supply everything else, including the engineer.

Strengths

  • The free Build plan covers a typical small business's entire agent minute volume, so infrastructure genuinely costs nothing at that scale
  • Both the Agents framework and the media server are open source and self-hostable, which is unmatched in voice AI
  • Very low overage rates - $0.01 per agent session minute is a fraction of any bundled platform's rate
  • Full control over which model, transcription and speech providers you use, so you tune cost and quality per component
  • Genuinely excellent real-time performance, which is the hardest part of voice to get right
  • Not limited to telephony: the same infrastructure handles web, mobile and video, so one stack serves several channels
  • Because you own the provider relationships, a model price change hits your account directly rather than being repriced

Limitations

  • This is infrastructure, not a product - there is no dashboard where you configure an agent and go live
  • Requires real engineering to assemble a working voice agent, and more to make it reliable
  • Telephony, transcription, model and speech costs are all separate and all yours to manage
  • Participant minutes and bandwidth are additional meters to understand alongside agent minutes
  • Self-hosting the media server is a serious operational undertaking, not a weekend project
  • No packaged compliance offering the way bundled vendors sell HIPAA as an add-on - you build to your own requirements

LiveKit Agents pricing

LiveKit prices real-time infrastructure - agent session minutes, WebRTC minutes, SIP minutes and bandwidth - rather than a bundled voice agent service, and the model and speech providers are yours to choose and pay for separately. Published pricing as of August 2026: Build free with 1,000 agent session minutes, 5 concurrent agent sessions, 1 agent deployment, 1 free US local number, 50 inbound US local minutes, 1,000 third-party SIP minutes, 5,000 WebRTC minutes and $2.50 of inference credits (roughly 50 minutes); Ship at $50 a month with 5,000 agent minutes, 20 concurrent sessions, 150,000 WebRTC minutes and $5 of inference credits; Scale at $500 with 50,000 agent minutes, up to 600 concurrent sessions, 1.5M WebRTC minutes, $50 of inference credits, HIPAA support and region pinning; Enterprise custom. Overages are $0.01 per agent session minute, $0.12 per GB of data transfer on Build and Ship or $0.10 on Scale, and third-party SIP at $0.004 a minute on Build and Ship or $0.003 on Scale. Inference is billed per model once the included credits are used. The Agents framework and media server are both open source and can be self-hosted with no LiveKit fee at all.

LiveKit Agents pricing tiers
PlanPriceWhat you get
Build$0/mo1,000 agent session minutes, 5 concurrent sessions, 1 deployment, 1 free US number, 50 inbound minutes, 1,000 SIP minutes, 5,000 WebRTC minutes, $2.50 inference credits (re-verified Aug 2026)
Ship$50/mo5,000 agent minutes, 20 concurrent sessions, 2 deployments, 150,000 WebRTC minutes, $5 inference credits, custom voices, instant rollback
Scale$500/mo50,000 agent minutes, up to 600 concurrent sessions, 1.5M WebRTC minutes, $50 inference credits, RBAC, metrics export, region pinning, HIPAA support
Overage rates$0.01/agent minData transfer $0.12/GB (Build and Ship) or $0.10/GB (Scale); third-party SIP $0.004/min or $0.003/min on Scale; inference billed per model after credits
EnterpriseCustomVolume pricing, Slack support, SLA
Self-hosted$0The Agents framework and media server are both open source and can run on your own infrastructure

Pricing reflects public plans as of August 6, 2026 and can change. Check LiveKit Agents for the latest.

What people actually build with LiveKit Agents

LiveKit is chosen when the voice agent is part of a product rather than a way of answering a phone, and the projects that end up on it share a shape: somebody needs control over a component that a bundled platform decides for them. Here is what that looks like concretely.

The five builds that keep recurring

An in-app support agent for a SaaS product. The customer clicks a button in the web application, a browser WebRTC session opens directly to the agent with no phone number involved at all, and the agent already knows who they are because the session token carried their account ID. It answers from the product's own documentation, and when it cannot, it opens a ticket through the support desk API and reads back the ticket number. This is the case that bundled voice platforms simply cannot do, because they are telephony-shaped and the customer never dials anything.

A multilingual after-hours line for a clinic group. Inbound calls arrive over SIP from the practice's existing carrier, so no numbers move. The agent runs speech-to-text tuned for medical vocabulary, checks the practice management system for an existing patient record, and either books into the next open slot or takes a callback request. Because the transcription provider is a choice rather than a bundled default, the team swapped it after the first month when accent handling on the original one proved poor. That swap is a config change on LiveKit and a support ticket everywhere else.

An outbound qualification agent for a solar installer. A webhook fires when a lead form is submitted, the agent calls within sixty seconds, asks four qualifying questions about roof type, ownership and budget, and writes the answers straight into the CRM before booking a survey. Speed to lead is the entire value here, and it is worth noting that the constraint is the dialler and the CRM, not LiveKit.

A voice interface on a physical device. Kiosks, in-vehicle assistants and warehouse handhelds all need real-time audio without a telephone network, and the same agent code that serves a phone call serves the device. Teams that started on a bundled platform and then needed a device channel usually end up rebuilding on LiveKit, which is a good argument for starting here if a device is anywhere on the roadmap.

A video session with an agent participant. Screen sharing during a technical support call, or an agent that joins a meeting to take notes and file actions. This is native, because the underlying media server was built for video before it was pointed at voice agents.

What it is genuinely bad at

Getting a small business answering its missed calls this week. There is no dashboard where you describe an agent, pick a voice and receive a phone number. Every one of the builds above assumed a developer, and for a solo trades business or a two-chair salon that assumption fails immediately. If your goal is that the phone gets answered, LiveKit is the wrong tool at any price, including free, and Vapi or Phonely will get you there in an afternoon.

It is also poor at giving a non-technical operations manager visibility. There is no built-in transcript browser, no call outcome dashboard and no analytics view. You get exactly the observability you build, which for many teams means nobody in the business can answer the question of what the agent said to a customer last Tuesday.

Bottom line: LiveKit is the right choice when the voice agent needs a channel a phone network cannot provide - in-app, on a device, or in a video session - and the wrong choice whenever the goal is simply that a business phone gets answered.

What LiveKit actually costs at small-business volume

LiveKit's own fee is close to irrelevant and that is the most important thing to understand about it. On our 1,500-minute reference workload, the free Build plan includes 1,000 agent session minutes and the remaining 500 cost $0.01 each - about $5 a month to LiveKit. Ship at $50 covers 5,000 agent minutes outright. Compared with the $150 to $400 a month that bundled voice platforms charge for the same calls, LiveKit is barely a line item.

That is because you are not buying a voice agent. You are buying real-time media infrastructure, and everything that makes a voice agent work - transcription, the language model, speech synthesis, telephony - is yours to choose and pay for separately. The honest total is therefore LiveKit's few dollars plus four other bills, and those four are where essentially all the money goes.

LiveKit makes that unusually visible through inference credits, and the number is instructive. Build includes $2.50 of inference credits, which LiveKit describes as roughly 50 minutes. Our 1,500-minute workload is thirty times that. So the free plan's inference allowance covers about three percent of the reference month, and the rest is billed per model. If you take one number from this section, take that ratio: on LiveKit, infrastructure is pennies and inference is the bill.

Self-hosting removes even the pennies. Both the Agents framework and the media server are open source and can run on your own infrastructure with no LiveKit fee at all - at which point your costs are a server plus the same four provider bills. For a team with real engineering capacity that is the cheapest credible way to run voice agents at volume that exists.

LiveKit all-in monthly cost at 4,000 minutes (1,000 calls averaging four minutes). Published rates read 2026-08-06.
LayerProvider and published ratePer minuteMonthly at 4,000 min
Real-time infrastructureLiveKit Ship, $50/mo including 5,000 agent minutescovered by base$50.00
Speech-to-textDeepgram Nova-3 streaming, $0.0048/min$0.0048$19.20
Text-to-speechDeepgram Aura-2, $0.030 per 1k characters~$0.0135~$54.00
Language modelGPT-5 mini, $0.25 in / $2.00 out per 1M tokens~$0.0020~$8.00
Inbound telephonyTwilio US local, $0.0085/min plus $1.15/number$0.0085$35.15
All-in totalFive separate bills, five separate accounts~$0.042~$166

The all-in stack at the category reference workload

The directory's voice reference workload is 1,000 inbound calls a month averaging four minutes, or 4,000 billable minutes. Because LiveKit unbundles, the only way to compare it honestly with a bundled platform is to price every layer. The table below does that from published rates read on 2026-08-06, using an inexpensive but capable configuration: LiveKit Ship, Deepgram Nova-3 streaming for transcription, Deepgram Aura-2 for speech, GPT-5 mini for the model, and Twilio for inbound telephony.

Two of those lines involve arithmetic rather than a published per-minute figure, and it is worth showing the working. Aura-2 is priced at $0.030 per 1,000 characters. An agent that speaks for roughly half of each minute produces somewhere around 450 characters, which is about $0.0135 a minute. The model line assumes roughly four turns a minute with a growing context of about 1,500 input tokens and 60 output tokens per turn, which at GPT-5 mini's $0.25 and $2.00 per million tokens comes to about $0.002 a minute. Change the voice to a premium one or the model to a flagship and both lines move by a factor of five or more, which is exactly the lever that unbundling gives you.

Bottom line: At 4,000 minutes a month LiveKit Ship plus Deepgram, GPT-5 mini and Twilio comes to roughly $166 all-in, about four cents a minute, of which LiveKit itself is $50 and the speech synthesis line is the largest variable.

The gotcha: concurrency on the free tier, and four meters instead of one

The Build plan's headline is 1,000 agent session minutes, but the limit that will actually stop you is 5 concurrent agent sessions and 5 inference concurrency, with a single agent deployment. Five simultaneous calls is a pilot allowance, not an operating one. Ship at $50 raises it to 20 concurrent sessions and 2 deployments; Scale at $500 goes to as many as 600 and 4 deployments. As with every voice platform, size on your busiest hour rather than your monthly total - except here the free tier's concurrency is low enough that most real deployments move to Ship for capacity long before they exhaust minutes.

The second gotcha is meter proliferation. LiveKit bills agent session minutes, WebRTC minutes, third-party SIP minutes, inbound telephony minutes, data transfer by the gigabyte and inference credits, each with its own allowance and its own overage rate. Build gives you 50 inbound US local minutes and 1,000 third-party SIP minutes; SIP overage is $0.004 a minute on Build and Ship, $0.003 on Scale; data transfer is $0.12 a gigabyte, or $0.10 on Scale. None of these is expensive. All of them are separate, and a forecast that models only agent minutes will be wrong. Build the estimate meter by meter the first time.

The third is not a gotcha so much as a warning about which bill grows. Because inference is billed per model after the credits run out, your voice agent's cost is driven by choices your developer makes - which model, which voice, how much context per turn. That is a powerful lever if someone is watching it and an unbounded one if nobody is. Put the model spend in an account with a cap and an alert on day one.

One consequence worth stating plainly for anyone budgeting: the 50 inbound US local minutes on Build are not a rounding error, they are the entire free telephony allowance. Any real inbound test programme exhausts that on the first afternoon, so either bring your own carrier over SIP from the start or accept that the free tier is a development tier and nothing else.

Bottom line: LiveKit's free Build tier is capped at 5 concurrent agent sessions and 50 inbound US minutes, so the limit that ends your pilot is concurrency and telephony, not the 1,000 included agent minutes.

What breaks in production, and how you find out

The honest headline is that LiveKit gives you excellent components and no opinions, so what breaks is whatever you did not build. There is no managed conversation designer, no built-in escalation logic and no default error handling for a call that goes wrong. Everything a bundled platform decides for you is a decision you now own. For a team with engineering capacity that is the entire appeal; for anyone else it is the reason the project never ships.

Operationally, the numbers to watch are concurrency and deployments. Agent session concurrency is capped per tier - 5, 20 and up to 600 across Build, Ship and Scale - and inference concurrency is capped separately at 5, 20 and 50. Those are two different ceilings and hitting either degrades calls. The deployment limit matters too: one deployment on Build means you have no separate staging environment, so testing happens against the thing your customers are calling unless you self-host a second instance.

Scale adds the operational features that a serious deployment actually needs - role-based access control, metrics export APIs, region pinning and HIPAA support - and it is worth noting where those sit, because it means a regulated business is looking at $500 a month rather than $50 regardless of call volume. Region pinning matters for latency as well as compliance: real-time voice is sensitive to physical distance in a way that ordinary web applications are not.

The failure mode specific to real-time media, and the one teams new to it underestimate, is that voice quality problems are network problems. Jitter, packet loss and bandwidth constraints on the caller's side produce transcription errors that look like model failures and are not. Instant rollback, available from Ship, is genuinely valuable here because the fastest way to diagnose a regression in a live voice system is to undo it and listen again.

Project health, checked rather than assumed

Unlike several things in this category, LiveKit's open-source core is demonstrably alive. Querying the GitHub API for livekit/agents on 2026-08-06 returned 12,673 stars, 733 open issues and a last push earlier that same day. Apache 2.0 licensed. A repository being pushed to on the day you check it is the single most useful maintenance signal available, and it is the direct contrast with Vocode, which sits elsewhere in this directory with no push since November 2024.

The 733 open issues deserve a fair reading rather than a scared one. On a repository of that size and pace, a large open-issue count is a symptom of a large user base filing things, not of neglect. The number to worry about is always the push date, and here it is today.

The three things to instrument before your first real call

A latency budget with a per-component breakdown, so that when a call feels slow you know whether it was transcription, the model or speech synthesis rather than guessing. Second, barge-in behaviour under load, because interruption handling degrades first when the system is busy and it is the thing callers notice most. Third, a transcript and outcome record written into a system you own as calls happen, because there is no vendor dashboard to retrieve it from later.

Bottom line: The livekit/agents repository was last pushed on 2026-08-06 with 12,673 stars under Apache 2.0, which makes it the most demonstrably maintained open-source foundation in this category.

What it connects to that you already run

LiveKit's integration story is provider-agnostic by design. You choose your speech-to-text, language model and text-to-speech vendors and pay them directly, or use LiveKit's inference credits to route through it. Telephony connects through SIP, with third-party SIP minutes included at every tier and a free US local number on Build, so an existing business number or an existing PBX can be brought in rather than replaced. For a business that already has phone infrastructure it wants to keep, SIP support is the feature that makes this possible at all.

For business systems, there is no connector catalogue - the agent calls functions your developer writes, against APIs you already have. In practice LiveKit sits alongside whatever automation platform runs your operations: the agent handles the conversation and calls out to a workflow that writes the booking or updates the CRM. That is the same architecture as the other developer-oriented voice platforms, with less scaffolding provided and correspondingly more freedom.

The capability that distinguishes LiveKit from the voice-only platforms is that it is genuinely a real-time media platform, not a telephony wrapper. Video, screen sharing and multi-participant sessions are native, because that is what the underlying product was built for. If your use case is an agent that joins a video call, or a support session where the customer shares a screen, LiveKit does that and the bundled voice platforms simply do not.

The pragmatic pattern for a business that already runs automations is to let the agent do only the conversation and hand everything else to a webhook. The agent takes the booking details and posts them to n8n or Make.com, which owns the calendar write, the confirmation SMS and the CRM update. That keeps the voice layer thin enough to replace and puts the business logic somewhere a non-developer can read it.

Bottom line: LiveKit connects to your business systems only through code your developer writes, so the durable pattern is to keep the agent thin and hand every side effect to a webhook into an automation platform you already run.

LiveKit Agents alternatives: what to pick instead, and when

LiveKit wins on cost and control and loses on time to first working agent, and that trade is the whole decision. Every alternative below is more product and less foundation. The right question is not which is better but whether you have a developer who will still be here in six months.

Pick Vapi if you want the unbundling economics without the build. It charges $0.05 a minute for orchestration and passes transcription, model and speech through at cost, or free if you bring your own API keys, with telephony billed by your provider. You keep the same per-component tuning that makes LiveKit cheap, and you skip the weeks of latency work. It is the closest thing to LiveKit with the plumbing already done, and for most developer teams answering phone calls it is the more sensible starting point.

Pick Retell AI if you want that same component-level transparency with a published range you can plan against, currently $0.07 to $0.31 a minute all-in depending on which voice and model you select. Pick Bland AI if you would rather stop thinking about components entirely and pay one number: $0.14 a minute on Start with no platform fee, transcription, model and premium voices all included. Pick ElevenLabs Agents if voice quality is the thing your customers will judge you on, and pick Synthflow only if you are an enterprise buyer, because its published floor is $30,000 a year.

Do not pick LiveKit because it looked cheapest in the table. The $166 figure below excludes the engineering time to build and maintain the agent, and three weeks of a developer costs more than a year of any bundled platform on this list.

Voice platform comparison at 4,000 minutes a month (1,000 calls averaging four minutes). Rates published as of 2026-08-06.
PlatformBilling unitCost at 4,000 minWho it suitsDoes one thing better
LiveKit AgentsAgent session minutes, plus your own STT, LLM, TTS and telephony bills~$166 all-in on Ship, plus engineering timeTeams with developers building voice into a productOpen-source framework and media server, plus web, mobile and video channels that telephony platforms cannot serve
Vapi$0.05/min orchestration, components at cost or free with your own keys~$340 including components and telephonyDeveloper teams who want unbundled pricing without the buildSame component-level control as LiveKit with the latency work already done
Retell AI$0.055/min base plus per-component voice, model and telephony~$350 on a budget voice and model; up to $1,240 on flagship choicesTeams that want to see and tune every line of the per-minute costPublishes a per-component price list, so the cheap and expensive configurations are both visible before you commit
Bland AIOne flat per-minute rate with model, transcription and voices included$560 on Start at $0.14/min with no platform feeBusinesses that want a single predictable number and no component decisionsThe simplest bill in the category: one rate, nothing else to model
ElevenLabs AgentsMonthly tier with included minutes, then $0.08/min; LLM and telephony separate~$320 on Scale at $299 for 3,738 minutes plus overageBusinesses where the voice itself is the differentiatorThe best-sounding synthesised speech available in a packaged agent product

Bottom line: At 4,000 minutes a month LiveKit is the cheapest platform bill on this list at roughly $166 and the most expensive project, so choose Vapi if you want its unbundled economics without spending weeks on latency work.

Migration and lock-in: can you get your work out?

LiveKit has the best lock-in position of anything in this directory's voice category, and unusually the claim survives scrutiny from several directions at once. The Agents framework is open source. The media server is open source. Your model, voice and transcription providers are your own accounts with your own keys. Your telephony connects over SIP, an open standard, from a carrier you can choose. There is almost nothing here that a vendor could take away from you.

Concretely, that means if LiveKit's pricing changed tomorrow you could run the identical stack on your own infrastructure, and the agent code would not need rewriting - the cloud product and the open-source components are the same software. That is a materially stronger position than an open-source-adjacent platform where the useful version is proprietary, and it is the reason technically capable teams keep choosing it.

What you would still rebuild moving to a different vendor entirely is the agent logic written against LiveKit's framework APIs, and that is real work. But it is your own code, in version control, in a mainstream language, which is the same thing that makes it maintainable in the first place. The conversation design embedded in it ports conceptually even where the code does not.

The one genuine lock-in is skills rather than software: LiveKit repays engineering investment, and a team that has learned it has built expertise specific to it. That is the honest cost of the flexibility - and it is also why the platform is the wrong choice for a business with nobody to make that investment.

Bottom line: With an Apache 2.0 framework, an open-source media server, your own provider accounts and SIP telephony, the only thing you are really locked into on LiveKit is your team's own expertise.

LiveKit Agents FAQ

What does LiveKit cost for a voice agent?

Possibly nothing. As of August 2026 the free Build plan includes 1,000 agent session minutes, 5,000 participant minutes and 50GB of bandwidth, and our reference workload of 1,500 minutes a month sits just above that - Ship at $50 covers 5,000 agent minutes. But LiveKit is only the real-time layer: you pay separately for your transcription, language model, speech synthesis and telephony providers, and those are where the actual per-minute cost lives.

What is the real all-in cost at 1,000 calls a month?

About $166 a month, or roughly four cents a minute, for 1,000 inbound calls averaging four minutes. That breaks down as LiveKit Ship at $50, Deepgram Nova-3 transcription at $0.0048 a minute, Deepgram Aura-2 speech at $0.030 per 1,000 characters, GPT-5 mini at $0.25 and $2.00 per million tokens, and Twilio inbound at $0.0085 a minute. Swap in a premium voice or a flagship model and the total climbs steeply, because those two lines carry almost all the variability.

What are agent minutes versus participant minutes?

Agent session minutes meter the time your AI agent is active in a session; participant minutes meter each human connected. For a simple phone agent talking to one caller, both accrue, but participant minutes are priced at a tiny fraction - $0.0005 or $0.0004 each on Ship and Scale - so agent minutes are the meter that matters. Where participant minutes become significant is multi-party use like meetings or group calls, which the same infrastructure supports.

What breaks when you build voice on infrastructure?

Latency budgets, mostly. A caller notices delay above roughly half a second, and that half second has to cover transcription, model inference and speech synthesis across three different providers plus network time. Teams that build voice agents from components almost always spend their first month on latency rather than on the conversation. The second issue is failure handling: when one provider is slow or down, the agent needs to degrade gracefully rather than go silent.

Who should not use LiveKit?

Any business without engineering capacity, without exception. LiveKit gives you excellent primitives and no product - there is no dashboard where you describe an agent and get a phone number. That is the right trade for a team building a voice product, and completely the wrong one for a clinic that wants its missed calls answered. Be honest about which you are before spending a fortnight discovering it.

Is self-hosting worth it?

Only at scale or under a hard data-residency requirement. The Agents framework and media server are open source and self-hostable, which is genuinely rare and valuable, but running real-time media infrastructure reliably is a specialist job - it is not a container you start and forget. For most teams the free and $50 tiers cover the volume anyway, so self-hosting buys control rather than savings. Take it when control is what you need.

How locked in are we?

Less than anywhere else in voice AI. The framework and media server are open source, your model, transcription, speech and telephony providers are your own accounts, and your agent logic is code you wrote. If LiveKit changed its pricing tomorrow you could self-host the same stack. That is the strongest position available in this category, and for a team building a product on top of voice it is a serious argument in itself.

Can we use it for more than phone calls?

Yes, and that is a real advantage if you need more than telephony. The same infrastructure handles web and mobile real-time audio and video, so a business that wants an agent on its website, in its app and on the phone builds once rather than three times. Bundled voice platforms are telephony-shaped and typically make the web and in-app cases awkward or impossible.

Is the open-source project actually maintained?

Yes, and we checked rather than assumed. Querying the GitHub API for livekit/agents on 6 August 2026 returned 12,673 stars, 733 open issues and a last push on that same day, under an Apache 2.0 licence. A large open-issue count on a repository of that size reflects an active user base filing things rather than neglect; the signal that matters is the push date, and here it was current. That is the direct contrast with Vocode, which has not been pushed to since November 2024.

LiveKit or Vapi for a developer team?

Vapi if you want orchestration handled and are happy to pay $0.05 a minute for it - it is meaningfully less work to get to a first working agent. LiveKit if you want maximum control, the lowest possible infrastructure cost, self-hosting as an option, or channels beyond telephony. Vapi is the faster path; LiveKit is the more durable foundation. Both leave you owning the model and telephony relationships, which is the right position either way.

Can you build a voice agent on this for us?

Yes, and for teams with product ambitions in voice it is often the right foundation. The work is in the latency tuning, the failure handling and the conversation design rather than the plumbing. We scope it on a free automation audit, build against your own accounts so the infrastructure and the provider relationships are yours, and hand over the code and documentation outright, plus a recurring plain-language report of what ran and what needed attention.

Looking at alternatives? LiveKit is the strongest foundation in voice AI and the wrong purchase for anyone without engineering capacity - those two facts sit together and neither cancels the other. If you have developers, the free tier plus open-source components means you can build something excellent at genuinely minimal platform cost. On lock-in it is in the best position in this directory: open-source framework, open-source media server, your own model and telephony providers. If nobody in the business writes code, a bundled platform will get you a working agent this week and this will not. See the Autonoly review.