Voice AI Build vs Buy: The Break-Even Math at 20K, 100K and 1M Minutes a Month
- Count two engineer-days a month of maintenance and a custom voice stack doesn't beat a vendor until roughly 20,000 minutes a month. Below that, buy. The math isn't close.
- At 100,000 minutes a month, a six-week build pays back in three to five months depending on your loaded engineer cost. At 20,000 it never does.
- There are three break-even points, not one: variable cost, labour-adjusted cost, and strategic constraint. Only the first two have a volume threshold.
Is it cheaper to build or buy a voice AI agent?
Buy below roughly 20,000 minutes a month. Build above roughly 100,000. In between, it depends on whether you already have an engineer who can own a pager. Building wins on pure per-minute cost almost immediately. Engineering time is what moves the threshold, and almost every article on this question leaves it out.
Both anchor numbers are published by the vendors, not estimated by me. Retell's pricing calculator prices its default configuration at $0.11 per minute, decomposed on the page as $0.055 voice infrastructure, $0.04 LLM and $0.015 TTS, against a headline range of $0.07–$0.31 per minute (retellai.com/pricing, checked 24 August 2026). LiveKit's pricing calculator defaults to $0.0672 per minute for a comparable phone agent. Axionry runs production voice agents at about 2.5¢ per minute on a self-orchestrated LiveKit stack.
Against Retell's own default configuration that's 4.4x. Against LiveKit Cloud's own calculator default it's 2.7x. I name the comparison configuration in the same sentence every time because a bare multiple is the easiest thing in this category to disprove, and the moment a reader disproves one number they stop believing all of them.
The decision isn't about per-minute rates. It's whether to spend six engineer-weeks now and two engineer-days a month forever for a margin improvement, and whether the people you'd spend are the same people your roadmap needs. That's the calculation this post models. To skip the reading, run your own volume through the voice AI cost calculator.
What does a voice AI vendor actually cost per minute?
More than the headline, because the headline excludes telephony and add-ons. Retell's calculator shows $0.11 per minute in its default configuration with telephony at $0.00. That zero assumes you bring your own carrier. Select Retell's bundled telephony and the page lists $0.015 per minute on top, taking the same call to $0.125.
Then the add-ons, all listed on the same page: knowledge base +$0.005/min, advanced denoising +$0.005/min, safety guardrails +$0.005/min, PII removal +$0.01/min, AI quality assurance $0.10/min after the first 100 free minutes, branded caller ID +$0.10 per outbound call, verified phone numbers $10/month each. Concurrency beyond the 20 included calls is $8 per concurrent call per month.
None of that is a criticism of Retell. They publish it, which is more than most of the category does, and that transparency is why I use them as the comparison baseline rather than a competitor's estimate. It also explains the $0.07–$0.31 range. A support agent with PII redaction, guardrails, a knowledge base and QA sampling is a materially different product from the $0.11 default, and it's the configuration a regulated buyer ends up with.
One more line from Retell's FAQ belongs in your model: "Am I charged during silence or hold time? Yes. Billing covers the entire duration of the call because the speech-to-text engine remains active and listening throughout, even during silence." That's correct, normal behaviour for a voice platform. It also means your billable minutes equal your call minutes, not your speech minutes. Model volume from call duration, not talk time.
- Retell voice infrastructure$0.055
- LLM$0.040
- TTS$0.015
What does building your own actually cost per minute?
About 2.0¢ per minute in published list prices, and about 2.5¢ all-in once you add compute you run yourself. I can show the first number line by line from public rate cards, so you can reproduce it. The second is my measured steady-state production cost. The gap is exactly what you'd expect: agent worker instances, Redis, log storage and observability that nobody sells you per minute.
The list-price build, on the LiveKit Ship plan with an inbound phone call: xAI Speech to Text streaming at $0.20/hour, which is $0.003333 per minute (xAI lists $0.10/hour for REST and $0.20/hour for streaming at docs.x.ai/developers/pricing, last updated 21 August 2026). xAI Text to Speech at $15 per million characters, which at LiveKit's calculator assumption of 600 characters per minute of agent speech is $0.009 per minute. A small LLM, Gemini 2.5 Flash-Lite at $0.10/$0.40 per million input/output tokens on LiveKit's published rate card, which at LiveKit's assumed 3,000 input and 175 output tokens per minute is about $0.0004 per minute. Telephony as a Telnyx trunk at $0.0032 per minute inbound local plus LiveKit's third-party SIP fee of $0.004 per minute on Ship.
That sums to $0.0199 per minute. Turn detection adds nothing, because LiveKit's v1-mini turn detector runs locally on CPU at no additional cost. Self-hosted agent workers and observability take the real figure to roughly 2.5¢, the number I quote and would defend in front of your CFO.
The structural point is which line moved. TTS is the largest single component in LiveKit's default calculator at $0.0300 per minute, more than STT, LLM, agent hosting and telephony combined. Choosing a $15-per-million-character voice over a $50-per-million-character voice is a bigger lever than any model swap, which is why I wrote a whole post on choosing a TTS provider for voice agents.
What does it cost in engineer time?
Six engineer-weeks to build, then roughly two engineer-days a month to run. Those two numbers decide this, and they're the two competing articles either omit or fudge as "a few weeks," which is not a number you can model.
The six weeks aren't evenly distributed. Week one is a working call path with one provider each for STT, LLM and TTS, genuinely a few days for a competent Python engineer. Weeks two and three are telephony, turn detection and barge-in, where the timeline usually slips because interruption handling looks done long before it is. Week four is instrumentation: per-turn latency, per-turn cost, structured logs with a call ID. Weeks five and six are the eval harness and the staged cutover, the two weeks teams delete from the plan and then regret.
At a $150K loaded annual cost, six weeks is about $17,300. At $250K, about $28,800. Maintenance at two engineer-days a month is about $1,150 or $1,920 a month on the same two rates. I give both because a US and a European reader have genuinely different numbers, and a single figure makes half the audience dismiss the table.
The cost not measured in money is the pager. A voice agent that fails, fails while a customer is on the line, and the failure modes are provider rate limits, socket drops and audio issues rather than clean stack traces. If nobody on your team wants to own that, buy. Hiring a fractional CTO to sit above the decision won't change the arithmetic.
| Phase | Effort | At $150K loaded | At $250K loaded | What it actually contains |
|---|---|---|---|---|
| Initial build | 6 engineer-weeks | ~$17,300 | ~$28,800 | Call path, telephony, turn detection, barge-in, instrumentation |
| Eval harness | Included above | — | — | Regression corpus, parity gates, latency test in CI |
| Ongoing maintenance | 2 engineer-days/mo | ~$1,150/mo | ~$1,920/mo | Provider changes, dependency bumps, cost and latency review |
| Incident response | Unbudgeted | Varies | Varies | Provider outages, concurrency ceilings, audio regressions |
| Fixed infrastructure | n/a | ~$600/mo | ~$600/mo | Agent workers, Redis, log storage, staging |
- Week 1One call path, end to end
AgentSession wired to STT, an LLM and TTS. Talks to you in a browser. Feels finished. Is not.
- Weeks 2‑3Telephony, turn detection, barge-in
SIP trunk, dispatch rule, endpointing tuned to your use case, mid-stream TTS cancellation and context truncation. This is where timelines slip.
- Week 4Instrumentation
Five timestamps per turn, per-turn token and character counts, one structured log line with a call ID. You cannot cut a cost you never emitted.
- Weeks 5‑6Eval harness and staged cutover
Regression corpus from real recorded calls, parity gates defined in advance, 1/5/25/100 percent traffic ramp with numeric rollback triggers.
Where is the break-even?
There are three, at different volumes. Naming them separately is the most useful thing you can do to a build-vs-buy discussion, because they're usually argued past each other in the same meeting.
Break-even one is variable cost against fixed infrastructure. Saving $0.085 per minute against $600 a month of fixed infrastructure crosses at about 7,100 minutes a month. This is the number that makes building look obviously correct, and the one to distrust, because it prices your engineers at zero.
Break-even two adds ongoing labour. At two engineer-days a month on a $150K loaded salary, fixed cost becomes about $1,754 a month, and the crossover moves to roughly 20,600 minutes a month. That's where the widely-quoted 20,000-minute threshold comes from. It's not folklore; it falls straight out of the model the moment you cost maintenance honestly.
Break-even three is strategic and has no volume threshold. It's the point where vendor constraints start costing you revenue: a model you can't choose, a latency you can't tune, a data-residency posture you can't offer, a feature you can't ship because it needs a hook the platform doesn't expose. This is why most teams actually migrate, and it's invisible to every spreadsheet in this category.
| Break-even | What it measures | Threshold | What moves it left | What moves it right |
|---|---|---|---|---|
| #1 Variable cost | Per-minute saving vs fixed infra only | ~7,100 min/mo | Cloud credits, cheaper TTS, self-hosted SFU | Multi-region, staging, recording storage |
| #2 Labour-adjusted | Per-minute saving vs infra + maintenance | ~20,600 min/mo | An engineer who already owns adjacent infra | Higher loaded salary, more than 2 eng-days/mo |
| #3 Strategic | Revenue lost to vendor constraints | n/a — not volume-dependent | Compliance deadlines, latency as a feature | A prompt-differentiated product |
At what volume should you definitely not build?
Under 20,000 minutes a month, if you have fewer than two engineers who can own a pager, if you need a signed BAA inside 90 days, or if your product's differentiation is the prompt rather than the pipeline. Each is a genuine reason to buy, and saying so costs me consulting revenue, which is why you should believe the rest of the post.
The volume case is arithmetic and I've shown it. The staffing case is subtler: a custom stack with one person who understands it is a single point of failure with a bus number of one. Two engineers isn't about workload, it's about continuity. If you can't staff two, you're buying a margin improvement with an operational risk you haven't priced.
The compliance case is the sharpest. If a deal is blocked on a BAA and the deadline is this quarter, a vendor who already has one is worth several cents a minute. Building your own means every provider in your pipeline needs its own agreement: Deepgram signs BAAs for enterprise customers handling ePHI, Rime offers a BAA on Enterprise, and you'll need one from each layer. That's a procurement project, not an engineering one, and procurement doesn't compress.
The prompt case is the one teams argue with and shouldn't. If what makes your agent good is the conversation design, the retrieval and the escalation logic, then owning the transport layer buys margin on a cost that isn't your bottleneck. Ship the thing that differentiates you, and revisit this when the bill gets finance's attention.
The per-minute saving doesn't cover fixed infrastructure plus two engineer-days a month of maintenance. Revisit at 20K.
It pays back, but slowly, and a single owner is a continuity risk. Instrument your vendor stack now so the migration has a baseline later.
Six-week build, three-to-five-month payback, and every future provider price cut accrues to you rather than to a vendor's margin.
Every provider in a custom pipeline needs its own agreement. That's a procurement timeline, and it doesn't compress to fit an engineering sprint.
This is strategic break-even #3. There's no minute threshold, because the cost is revenue you're not earning rather than money you're spending.
How do cloud credits change the break-even?
They move break-even one and two sharply left, and they should never be the reason you decide. Credits push the fixed-cost side toward zero for a window, which drops the labour-adjusted crossover from about 20,600 minutes a month to roughly 13,500: the $600 of infrastructure disappears while the $1,154 of maintenance labour does not.
I've done this at scale. I secured $300K in cloud credits across Microsoft for Startups and AWS Activate, plus $100K in LiveKit credits, and ran a production platform at effectively no infrastructure cost during the window. It's real and worth pursuing. The applications are pitches, not forms, and demonstrating high-volume production AI usage is what unlocks the upper tiers.
The trap is architecting onto credits you'll lose. A stack that only makes economic sense while somebody else pays for the compute has a cliff in it, and the cliff arrives 18 to 24 months later when the team that built it has moved on. Keep the portable parts portable: containerised workers, no proprietary queue in the critical path, and a per-minute cost model that still closes at list price.
My test is simple. Build the model at list price first, then apply credits. If the decision flips when you add credits, you're not making a build decision; you're betting a discount will still be there when your volume matures. That's a different conversation, and it belongs in front of your board rather than in an engineering doc. My own cloud cost optimization work runs on the same rule.
How do you decide in an afternoon?
Five inputs and one formula. The inputs: your monthly minutes, your current vendor's effective per-minute rate including add-ons, your target custom variable rate, your monthly fixed infrastructure, and your build cost in loaded engineer dollars. If you can't fill in the second one from an invoice rather than a pricing page, stop and get the invoice. The gap between the two is usually where the whole decision lives.
The formula runs in your head and is worth running properly. Monthly saving equals minutes times the rate difference, minus fixed infrastructure, minus monthly maintenance labour. If that's negative, don't build at any timeline. If it's positive, payback months equals build cost divided by monthly saving.
Run it twice, once at your loaded engineer cost and once at a cost 60% higher. If the answer changes between the runs, your salary assumptions are deciding, not your architecture, and it should go back to your CFO rather than your tech lead.
If the answer is "build" and you want it built and instrumented properly rather than built and then discovered, that's what voice AI development is for. If it's "migrate," the sequencing matters more than the code, and I've written that up separately in how to migrate from Retell or Vapi to LiveKit.
#!/usr/bin/env python3
"""Voice AI build-vs-buy break-even. No dependencies. Python 3.8+."""
def model(
monthly_minutes: float,
vendor_rate: float = 0.11, # Retell published default config, Aug 2026
custom_rate: float = 0.025, # measured steady-state custom stack
fixed_infra: float = 600.0, # agent workers, Redis, logs, staging
build_weeks: float = 6.0,
maint_days_per_month: float = 2.0,
loaded_salary: float = 150_000.0,
):
week_cost = loaded_salary / 52.0
day_cost = loaded_salary / 260.0
build_cost = build_weeks * week_cost
maint_cost = maint_days_per_month * day_cost
delta = vendor_rate - custom_rate
vendor_total = monthly_minutes * vendor_rate
custom_total = monthly_minutes * custom_rate + fixed_infra + maint_cost
saving = vendor_total - custom_total
be_variable = fixed_infra / delta
be_labour = (fixed_infra + maint_cost) / delta
payback = build_cost / saving if saving > 0 else None
return {
"vendor_monthly": vendor_total,
"custom_monthly": custom_total,
"monthly_saving": saving,
"breakeven_variable_only_minutes": be_variable,
"breakeven_labour_adjusted_minutes": be_labour,
"build_cost": build_cost,
"payback_months": payback,
}
if __name__ == "__main__":
for minutes in (20_000, 100_000, 1_000_000):
r = model(minutes)
pay = r["payback_months"]
pay_s = "never" if pay is None else "{:.1f} months".format(pay)
print("{:>9,} min/mo saving {:>10,.0f}/mo payback {}".format(
minutes, r["monthly_saving"], pay_s))
base = model(100_000)
print("\nbreak-even #1 (variable only): {:>10,.0f} min/mo".format(
base["breakeven_variable_only_minutes"]))
print("break-even #2 (labour-adjusted): {:>10,.0f} min/mo".format(
base["breakeven_labour_adjusted_minutes"]))$ $ python3 breakeven.py20,000 min/mo saving -54/mo payback never100,000 min/mo saving 6,746/mo payback 2.6 months1,000,000 min/mo saving 83,246/mo payback 0.2 monthsbreak-even #1 (variable only): 7,059 min/mobreak-even #2 (labour-adjusted): 20,635 min/mo
What did this look like when I actually did it?
I built AccioMatrix solo into an AI assessment and interview platform serving 20+ enterprise clients. The voice layer started on a managed vendor. I integrated Retell in 48 hours, and that integration drove interview false positives from 50% to 15%, a 70% reduction Retell published as an official customer case study. That's the part of my history that makes the rest of this post credible: I'm not a vendor sceptic who never shipped on one.
Later, at volume, I replaced it with a custom LiveKit stack and took per-minute cost from about 10¢ to about 2.5¢ with quality unchanged. Both decisions were correct when they were made. The platform got us to market and the custom stack got us margin, and anyone telling you those are opposing philosophies is selling one of them.
The thing I'd do differently is instrument earlier. I couldn't properly compare the two stacks on the dimensions that mattered, per-turn latency, false-interruption rate, cost per completed call, until I'd emitted the data, and I emitted it late. Week four of the plan in this post exists because of that mistake.
The same discipline applies to the cloud side. I cut a $200K+/year cloud bill by more than 70% and secured $300K in credits along the way, and the pattern was identical: the savings came from architecture and measurement, not haggling. If you want the full build rather than the business case, the full LiveKit voice AI build guide is the companion piece to this one.
Voice AI build vs buy: common questions
→Is it cheaper to build or buy a voice AI agent?
Cheaper to buy below roughly 20,000 minutes a month, cheaper to build above roughly 100,000, once you count engineering time. On pure per-minute cost building wins almost immediately: a custom LiveKit stack runs at about 2.5¢ a minute against Retell's published default configuration of $0.11 a minute. But two engineer-days a month of maintenance costs more than the saving until about 20,600 minutes a month.
→At what call volume does building your own voice AI stack become worth it?
About 20,600 minutes a month is where a custom stack stops losing money once maintenance labour is included, and about 100,000 minutes a month is where the six-week build cost pays back inside a quarter. Below 20,000 minutes a month the model never crosses zero on the assumptions in this post: $0.11 vendor rate, $0.025 custom rate, $600 monthly fixed infrastructure and two engineer-days a month at a $150K loaded salary.
→How long does it take to build a custom voice AI platform?
Six engineer-weeks for a production-grade stack: roughly one week for the end-to-end call path, two weeks for telephony, turn detection and barge-in, one week for instrumentation, and two weeks for the eval harness and staged cutover. The first week feels like the whole project is nearly done, which is the most common source of slipped timelines in this category.
→How much does it cost to maintain a self-hosted voice AI stack?
Budget two engineer-days a month plus roughly $600 a month of fixed infrastructure for agent workers, Redis, log storage and a staging environment. At a $150K loaded annual salary that's about $1,150 a month of labour, so total ongoing cost is around $1,750 a month before any per-minute charges. That figure, not the per-minute rate, is what sets the break-even volume.
→Do cloud credits change the build-vs-buy decision?
They move the break-even volume roughly 34% to the left by covering the fixed infrastructure, but they don't touch the maintenance labour, which is the larger term. Credits are a runway extension rather than a business case: build the model at list price first, and if the decision only flips once credits are applied, you're betting on a discount still being available when your volume matures.
→What is the strategic break-even for voice AI?
It's the point where vendor constraints cost you revenue rather than money: a model you can't select, a latency you can't tune, a data-residency posture you can't offer, or a feature you can't ship because the platform exposes no hook for it. Unlike the cost break-evens it has no volume threshold, and in practice it's the reason most teams migrate off a managed platform.