Open-source TTS models promise real savings: no per-minute API fees, full control over your voice data, and the freedom to self-host. But here's the problem. Most TTS benchmarks and demos are built for audiobooks, podcasts, and content narration. They're tested on clean 24kHz studio audio, not the 8kHz phone lines your callers are actually using.
This guide compares the best open-source TTS models specifically through a phone-call lens: latency, telephony audio compatibility, licensing terms, and how production-ready each one actually is.
TL;DR
- Open-source TTS means self-hostable model weights—but "best" for phone calls hinges on live latency and 8kHz audio.
- Five models worth testing on calls: Kokoro, Chatterbox-Turbo, Orpheus, XTTS-v2, and MeloTTS.
- Prioritize streaming TTFB, telephony audio fit, commercial licensing, and production maturity.
- Self-hosting for calls needs orchestration and telephony integration, not just weights.
Overview of Open-Source TTS for Phone Call Applications
Open-source TTS means the model weights are public. You can download them, run them on your own hardware, and never send audio to a third-party API. That sounds simple until you try to use one inside a live phone call.
On a phone call, the model doesn't get to render an entire paragraph and hand back a finished file. It has to generate speech from a stream of text, in real time, while a human is waiting on the line. Sound quality alone doesn't cut it; timing does too.
How Fast Is Fast Enough?
Industry guidance is consistent: voice agents should get audio back to the caller in under a second from the moment they stop talking. LiveKit's voice agent architecture guidance splits that budget roughly as:
- 100–200ms for speech-to-text
- 300–500ms for the language model's first token
- 100–200ms for TTS to produce the first audio chunk
Miss that window and the conversation starts to feel like a bad international call.
Telephony Audio Is a Different Animal
Most TTS demos run at 16kHz or 24kHz on a clean WAV file. Phone calls don't work that way. Standard telephony uses G.711 audio, encoded as PCMU or PCMA, at a flat 8,000 Hz sample rate.
Twilio's Media Streams documentation confirms this is the format carriers expect for real-time audio over SIP and PSTN trunks. Every open-source model on this list needs a resampling and codec-conversion layer before it can touch a real phone call—plus tolerance for jitter and packet loss that a studio benchmark never sees.
Why This Matters Now
The conversational AI market—voice bots included—was valued at $13.77 billion in 2024 and is projected to reach $49.80 billion by 2031, according to MarketsandMarkets' 2025 report.
A growing share of that is inbound and outbound calling, so the TTS choice behind each agent matters at scale.
The models ranked below are evaluated for that reality, not for how they sound reading an audiobook chapter.
Top Open-Source TTS Models for Phone Calls
The models below are ranked on four things that actually affect call outcomes:
- Real-time streaming capability
- Time-to-first-audio
- Licensing for commercial call center use
- Production maturity of the surrounding tooling
Kokoro
Kokoro is an 82M-parameter, decoder-only TTS model. No diffusion steps, no separate encoder, released under an Apache 2.0 license. Its small footprint means it runs on modest hardware without needing a dedicated GPU per call.
For phone agents handling high call volumes, that's the whole appeal: you can run more concurrent conversations per server without the compute bill scaling linearly. It won't match the expressiveness of a larger model, but for cost-sensitive IVR and outbound campaigns, that trade-off is usually worth it.
| Spec | Details |
|---|---|
| Parameters | 82M, decoder-only architecture, no encoder or diffusion steps |
| Licensing | Apache 2.0, free for commercial telephony use |
| Best For | High-volume, cost-sensitive voice agents where speed matters more than expressive range |
Chatterbox-Turbo
Resemble AI's Chatterbox-Turbo is a 350M-parameter distilled model built specifically for production voice applications. Its decoder was distilled from ten diffusion steps down to one. Resemble's own model card claims sub-200ms inference, and the product page cites figures as low as 75ms on GPU hardware.
It also supports native paralinguistic tags like [laugh] and [cough], giving it a natural pacing that most compact models don't have. Combined with an MIT license, it's one of the most call-ready open-source options on the market today.
| Spec | Details |
|---|---|
| Latency | Sub-200ms inference via a distilled one-step decoder (down from 10 diffusion steps) |
| Licensing | MIT License, fully free for commercial use |
| Best For | Real-time conversational agents needing natural pacing and light emotional control |
Orpheus
Canopy Labs built Orpheus on a Llama backbone, releasing it in four sizes: 150M, 400M, 1B, and 3B parameters, trained on more than 100,000 hours of English speech. That range is the point. Teams can swap in a smaller version for a low-stakes IVR menu and a larger one for outbound calls where voice quality carries more weight.
Orpheus also ships with real-time streaming support out of the box, with the creators claiming latency around 200ms, dropping closer to 100ms with input streaming enabled.
| Spec | Details |
|---|---|
| Parameters | Multiple sizes (150M-3B), trained on 100k+ hours of English speech |
| Licensing | Apache 2.0 |
| Best For | Teams needing a single model family that scales from lightweight IVR to higher-fidelity outbound calling |
XTTS-v2
Coqui's XTTS-v2 is, by download count, the most popular open TTS model on Hugging Face. Its standout feature is voice cloning from a short reference clip. Coqui's own documentation cites figures ranging from 3 to 6 seconds depending on the source, which makes it a favorite for brand-voice consistency.
Coqui's developer docs report streaming inference with under 200ms to the first audio chunk, fast enough for real-time agent pipelines. The catch is licensing: the Coqui Public Model License is non-commercial by default, so any commercial phone deployment needs separate licensing terms.
| Spec | Details |
|---|---|
| Latency | Streaming inference under 200ms to first audio chunk |
| Licensing | Coqui Public Model License, non-commercial by default; commercial phone deployments require separate licensing |
| Best For | Multilingual voice cloning use cases where brand-voice consistency matters |
MeloTTS
MyShell.ai's MeloTTS is a multilingual TTS library built to run in real time without a GPU. That's a meaningful difference for teams running dozens or hundreds of concurrent calls: CPU inference means infrastructure cost doesn't scale with GPU availability or pricing.
It supports English (with regional accent variants), Spanish, French, Chinese, Japanese, and Korean, all under an MIT license with no restrictions on commercial use.
| Spec | Details |
|---|---|
| Efficiency | Real-time inference on CPU, no GPU required |
| Licensing | MIT License, free for commercial use |
| Best For | Budget-constrained deployments and multilingual IVR without voice cloning needs |
How We Chose the Best Models
The most common mistake teams make is picking a TTS model off a naturalness leaderboard or a demo video. Under real telephony conditions, that same model often behaves completely differently: 8kHz audio, network jitter, and dozens of concurrent calls competing for GPU memory.
We weighted four factors that actually correlate with phone-call outcomes:
- Streaming time-to-first-audio (TTFB): how fast the model produces the first chunk of speech, not just its average generation speed
- Licensing terms for commercial calling: whether the license permits revenue-generating phone deployments, not just research or personal use
- Community and production maturity: how many teams have actually shipped this model in a live product, and how active the GitHub issues and pull requests are
- Hardware footprint per concurrent call: GPU memory or CPU load required to run one call, multiplied by however many calls you need simultaneously
One thing we didn't do: treat published word-error-rate or naturalness scores as gospel. Those numbers are almost always measured on clean studio-quality audio. Telephony audio is compressed, resampled, and sometimes noisy, so it behaves differently. There's no substitute for testing your shortlisted models against your own call audio before locking in an architecture.
Deploying Open-Source TTS Models in Production Phone Systems
Downloading model weights is the easy part. Getting a model like Kokoro or Chatterbox-Turbo to answer real phone calls means wrapping it in a streaming API, converting its output to telephony-compatible sample rates and codecs, and integrating it with a SIP or PSTN carrier. None of that shows up in a Hugging Face model card.
The Latency-Stacking Problem
TTS is only one leg of a three-part pipeline: speech-to-text, then a language model, then text-to-speech. Each stage adds delay, and those delays stack. A TTS model with a genuinely fast 150ms time-to-first-audio doesn't help much if the STT and LLM stages ahead of it are each adding 300-500ms.
LiveKit's own architecture documentation notes that a naively sequential pipeline can produce 2-4 seconds of total delay, even when every individual component looks fast in isolation.
That's why serious voice-agent platforms don't just swap in a faster TTS model. They attack latency at the orchestration layer. Two approaches worth knowing:
- Speech-to-speech pipelines: Collapse STT, LLM, and TTS into one real-time model (e.g., Gemini Flash Live or GPT-Realtime-2) instead of chaining three services
- Hybrid pre-recorded + TTS fallback: Play a human-recorded clip in the agent's cloned voice for common lines; use generative TTS only when the call goes off-script
Dograh AI applies both. In production use:
- Speech-to-speech orchestration (Gemini Flash Live, GPT-Realtime-2, and similar models) has roughly halved end-to-end latency
- Hybrid pre-recorded + TTS has cut outbound calling costs by up to 3x and improved conversions by roughly 2x, because most of the call plays a real human voice clip and TTS only fills the gaps
For teams that want to run their own locally-hosted models, including Kokoro, Chatterbox, and Coqui, Dograh's visual workflow builder lets you wire them directly into a phone-call agent without writing custom orchestration code from scratch, keeping sensitive call audio on-premise rather than routing it through a third-party API.
Matching Deployment to Compliance Needs
That flexibility extends to how you deploy:
- Self-hosted OSS: full control, runs on your own infrastructure, you own the DevOps
- Managed cloud: Dograh-hosted and maintained, faster to get running
- Fully managed private cloud: Dograh builds and operates the stack inside your own cloud environment
For healthcare and financial services teams, keeping TTS and orchestration on-premise reduces how many third parties ever touch call audio, transcripts, or protected health information, cutting down on the BAAs, DPAs, and vendor-risk reviews that come with every closed API added to the stack.
Conclusion
No single open-source TTS model is "best" for phone calls—only the one that holds up under your real telephony conditions. A model that sounds flawless on a demo page can fall apart at 8kHz audio, with network jitter, and under fifty concurrent calls.
Before you lock in an architecture, benchmark shortlisted models—Kokoro, Chatterbox-Turbo, Orpheus, XTTS-v2, or MeloTTS—on your own call audio:
- Measure latency under realistic load
- Check licensing against your revenue model
- Confirm community support for production issues
If you want to run these models in a real phone-call pipeline without building orchestration from scratch, Dograh AI's self-hostable platform connects locally hosted TTS models into a working voice agent so you can judge production performance before you commit.
Frequently Asked Questions
What is the best open-source TTS model for phone calls?
It depends on your priority. Kokoro and MeloTTS fit low-resource, cost-sensitive deployments. Chatterbox-Turbo and XTTS-v2 suit low-latency streaming with voice cloning; Orpheus fits teams that want one model family across call types.
Can open-source TTS models handle real-time streaming for voice agents?
Yes. Chatterbox-Turbo, XTTS-v2, and Orpheus support streaming with sub-200ms time-to-first-audio claims from their creators, which is enough for live calls when you validate under real load.
Do open-source TTS models support telephony audio formats like 8kHz PCMU?
Not natively. Most generate audio at 16–24kHz by default, so you need a resampling and codec layer to produce the 8kHz PCMU/PCMA format carriers expect.
Is open-source TTS free to use for commercial phone call systems?
Licensing varies. Kokoro, Chatterbox-Turbo, and MeloTTS use Apache 2.0 or MIT licenses that are free for commercial use, while XTTS-v2's Coqui Public Model License requires separate commercial terms.
What latency is acceptable for AI voice agents on phone calls?
End-to-end latency should stay under about one second for a call to feel natural. That budget is shared across speech-to-text, the language model, and TTS—not TTS alone.
How do I deploy an open-source TTS model into a production voice calling system?
You need a streaming API wrapper, telephony audio conversion, and integration with SIP/PSTN infrastructure, or a platform like Dograh AI that supports locally-hosted TTS models out of the box.
