If you are building a voice agent, two numbers matter first: how long until the first sound plays, and how bad the slow end is (the 95th percentile). We measured both, for one caller and for four callers at once.

Results

Time to the first audible sound, in milliseconds. Lower is better.

How we measured

• One MacBook, one program, the same five sentences for every voice. Each caller kept one connection open, as an app would, after two untimed warm-up requests.
• Every request counted. No errors, refusals or timeouts happened in any row.
• First sound means the first audio bytes plus any silence at the start of the audio, the way Coval defines time to first audio. It is our own implementation of their description.
• One caller made 20 requests and four callers made 10 each. These are small samples, so read the 95th percentile as approximate.

What this does not show

• Our voices ran on a Mac mini on the same network as the test computer, over Wi-Fi through an encrypted tunnel. Polly and Google were reached over the internet. We expect our times to change a little on a wired connection and will update.
• Google's text to speech returns the whole clip at once, so its number is the time for the entire sentence, not a streaming start.
• Voice quality is not part of this test. Listen before you choose.
• Our voices come from a smaller catalog than the big providers, and there is no uptime guarantee yet.

Full table and method

The whole table, the method, and a ten-minute capacity test (25 + 10 + 2 live callers on one Mac mini with no errors) are on our speed page: https://speakvora.com/performance

The API itself costs $3 per million characters, with 100,000 characters free: https://speakvora.com/text-to-speech

Disclosure: I run Speakvora, a speech API. Every number below is from our own tests, with dates, and I say where they are not comparable to anyone else's.

1. The first byte is not the first sound

A streaming text-to-speech response can begin with audio that is silent. The first chunk arrives quickly, your timer stops, and the caller still hears nothing for another 100 to 400 ms. What a person experiences is the arrival of the first chunk plus the silence before the first audible sample.

That is also how Coval's published TTS benchmark defines it: first chunk arrival plus leading silence, where "audible" is the first 10 ms window with RMS above 0.01 on a -1 to 1 scale (their method). We implemented that description ourselves; we did not run Coval's own harness. On 30 October 2026 we measured our Phonon voices that way, on a test server of ours over plain HTTP, next to Amazon Polly from the same client in the same run:

Our voice produced its first chunk in 25 ms and then spent 123 ms saying nothing. The early "fast" figure was true as a first-byte time and misleading as a description of what a caller hears. Other engines show the same gap. A stock Pocket TTS voice (Kyutai's model, on a CPU) delivered its first chunk in 125 to 173 ms, then added 210 to 240 ms of leading silence. A local Qwen3-TTS model on my Mac sent its first chunk at about 100 ms and became audible at about 210 ms.

When you compare vendors, ask which of the two numbers they are quoting.

2. Where you measure changes the answer

The same Phonon voice, on a test server of ours, measured in October 2026 (these are first-byte times, taken before we started counting the silence):

• On the server itself (loopback, no network): 24 to 28 ms for a short line.
• From my laptop over the internet, with a 16.5 ms round trip: 57 to 62 ms.
• The same laptop with a kept-alive connection and the text split at the first clause: 42 to 45 ms.
• From a cloud VM in the same region: 25 to 27 ms.

A number measured "on the box" tells you about the model. Your app lives somewhere else, so measure there.

3. Setting up a connection is part of your latency

On 5 November 2026 we measured time to first audio bytes for a Phonon voice through our API, five runs, medians, same voice and server:

• 43 ms when the connection and the stream session were already open.
• 101 ms when a new session was requested for every line over a reused connection.
• 207 ms (range 152 to 310) for a brand-new visitor with new connections.

That is nearly a five-fold spread from setup alone, with no change to the model.

4. Fast and wrong is not fast

One more lesson. We once compiled a speech model for speed and its first-byte time dropped into the 40 to 47 ms range. Then we ran an accuracy check: Whisper transcribed the compiled model's output with a word error rate of 0.27, against 0.023 for the uncompiled model. It was fast and it was wrong. We withdrew every speed figure from that path and corrected our pages. Always listen to (or transcribe) the audio, not just read the clock.

Measure it yourself

This function returns milliseconds from just before your request until the first audible sound. It takes any iterator of raw 16-bit mono PCM chunks:

import time
import numpy as np


def first_audible_ms(chunks, started, sr=24000, thresh=0.01):
    """ms from `started` (time.perf_counter() just before the request) to the first audible sound.
    Audible = a 10 ms window (1 ms step) with RMS above `thresh` on a -1..1 scale."""
    win, step = sr // 100, sr // 1000
    pcm, rest, pos, t_first = np.zeros(0, dtype=np.float32), b"", 0, None
    for chunk in chunks:
        if t_first is None:
            t_first = time.perf_counter()                       # arrival of the first chunk
        data = rest + chunk
        rest = data[len(data) // 2 * 2:]                        # keep a split sample for next time
        pcm = np.concatenate([pcm, np.frombuffer(data[:len(data) // 2 * 2], dtype="<i2").astype(np.float32) / 32768.0])
        while pos + win <= len(pcm):
            w = pcm[pos:pos + win]
            if np.sqrt(np.mean((w - w.mean()) ** 2)) > thresh:
                return (t_first - started) * 1000 + pos / sr * 1000     # arrival + the silence before the sound
            pos += step
    return None

Use it with any streaming HTTP client, for example:

import requests
t0 = time.perf_counter()
r = requests.post(STREAM_URL, headers={"authorization": f"Bearer {TOKEN}"}, json=BODY, stream=True)
print(first_audible_ms(r.iter_content(4096), t0))

Run it 20 times, from where your app runs, and look at the median and the 95th percentile, not the best run. (I tested the function against synthetic audio with a known 150 ms of silence; it reported 176 ms for a 30 ms arrival, within a few milliseconds of the expected 180, because the window sees the sound a little before its midpoint.)

How to get a lower number in your app

1. Measure first audible sound, from your own machine or region. Use the function above, not a vendor's headline.
2. Run your calling code near the API. Our servers are in AWS us-east-1. A 16.5 ms round trip is paid more than once on a cold request: for the TCP connection, the TLS handshake and the request itself.
3. Reuse connections. Keep one pooled HTTP client alive instead of creating a client per request. In our numbers above, the case with brand-new connections was the slowest.
4. Ask for the stream ahead of time. Our streaming flow is two calls: ask for a stream (you get a one-use URL and token), then open it. The first call adds roughly 100 to 150 ms, once, so make it before you need the audio: when a field gets focus, on hover, or when the user starts typing.
5. Take out hops. Every proxy between the audio and the listener adds its own connection and its own delay. Where you can, give the browser the one-use stream URL and token so the audio goes straight to it, instead of relaying audio through your server. Keep your API key on your server; never put it in a page.
6. Start playing at the first chunk. A player that waits for a full second of audio, or a whole sentence, throws away everything above. Check the buffer settings in your audio element or worklet.
7. Look at the leading silence. Two voices with the same first-byte time can differ by 100 ms or more of dead air before the sound. Compare voices by first audible sound.
8. Pre-generate lines that never change. Greetings, confirmations and menu prompts can be generated once and played from your own storage, with no generation delay at all.
9. Warm up. The first request after a quiet period can be slow. On one path we saw a 95th-percentile cold tail of 4.8 seconds, so send a tiny request when your app starts rather than letting your first real caller pay for it.

What these numbers are not

They are our own tests, in our own setup, on specific days. They are not a third-party benchmark and not a ranking, and your network will give you different numbers, which is exactly the point. If you try the function and get a result that disagrees with ours, I would like to hear about it.

More detail, with the method: Speakvora's latency page and the streaming docs.

If you are choosing a text-to-speech API for a voice agent, two numbers matter first: how long until the first audio plays, and how bad the slow end is (the 95th percentile).

On first audio, Speakvora Phonon is faster than every Fish Audio model on the Coval leaderboard (53 ms against 167, 362 and 758 ms), and the slow end is tighter too (96 ms at the 95th percentile against 223 ms for the fastest Fish model). Fish Audio's S2.1 Pro lists at $15 per million characters, against our $3.

Where Fish Audio is the better choice and where Speakvora is, with sources and the pricing we checked: https://speakvora.com/compare/fish-audio

The ranked table with every provider: https://speakvora.com/performance

Caveats: speed is not voice quality, and we did not benchmark quality or uptime. Fish Audio is known for expressive and cloned voices, which are a different strength. Speakvora streaming needs a paid account. Prices change, so confirm on each provider's page.

If you are choosing a text-to-speech API for a voice agent, two numbers matter first: how long until the first audio plays, and how bad the slow end is (the 95th percentile).

On first audio, Speakvora Phonon is faster than both Rime models on the Coval leaderboard (53 ms against 367 and 381 ms), and the slow end is tighter too (96 ms at the 95th percentile against 484 and 543 ms). Rime lists at $30 to $50 per million characters, against our $3.

Where Rime is the better choice and where Speakvora is, with sources and the pricing we checked: https://speakvora.com/compare/rime

The ranked table with every provider: https://speakvora.com/performance

Caveats: speed is not voice quality, and we did not benchmark quality or uptime. Speakvora streaming needs a paid account. Prices change, so confirm on each provider's page.

If you are choosing a text-to-speech API for a voice agent, two numbers matter first: how long until the first audio plays, and how bad the slow end is (the 95th percentile).

This one is close. Inworld TTS Flash 2 is within 3 ms of Speakvora Phonon at the median (56 ms against 53 ms), and 15 ms behind at the 95th percentile (111 ms against 96 ms). The larger difference is price: $15 per million characters against $3. Inworld TTS 2 is slower (158 ms) and lists at $25.

Where Inworld is the better choice and where Speakvora is, with sources and the pricing we checked: https://speakvora.com/compare/inworld

The ranked table with every provider: https://speakvora.com/performance

Caveats: speed is not voice quality, and we did not benchmark quality or uptime. Speakvora streaming needs a paid account. Prices change, so confirm on each provider's page.

If you are choosing a text-to-speech API for a voice agent, two numbers matter first: how long until the first audio plays, and how bad the slow end is (the 95th percentile).

On first audio, Speakvora Phonon is about ten times faster than Google's Chirp 3 HD on the Coval leaderboard (53 ms against 547 ms), and the slow end is far tighter: 96 ms at the 95th percentile against 867 ms. Google's cheaper Standard voices list at $4 per million characters and its Neural2 voices at $16; we did not measure their speed here.

Where Google is the better choice and where Speakvora is, with sources and the pricing we checked: https://speakvora.com/compare/google-cloud-text-to-speech

The ranked table with every provider: https://speakvora.com/performance

Caveats: speed is not voice quality, and we did not benchmark quality or uptime. Google Cloud offers many more voices, languages and regions. Speakvora streaming needs a paid account. Prices change, so confirm on each provider's page.

If you are choosing a text-to-speech API for a voice agent, two numbers matter first: how long until the first audio plays, and how bad the slow end is (the 95th percentile).

On first audio, Speakvora Phonon is faster than both Cartesia Sonic models on the Coval leaderboard (53 ms against 272 and 280 ms). Cartesia prices by credits; at the plans we checked it works out to about $38 to $50 per million characters, against our $3.

Where Cartesia is the better choice and where Speakvora is, with sources and the pricing we checked: https://speakvora.com/compare/cartesia

The ranked table with every provider: https://speakvora.com/performance

Caveats: speed is not voice quality, and we did not benchmark quality or uptime. Cartesia has a wider voice-control feature set. Speakvora streaming needs a paid account. Prices change, so confirm on each provider's page.

If you are choosing a text-to-speech API for a voice agent, two numbers matter first: how long until the first audio plays, and how bad the slow end is (the 95th percentile).

On first audio, Speakvora Phonon is faster than both Deepgram models on the Coval leaderboard (53 ms against 206 and 286 ms), and the slow end is much tighter: 96 ms at the 95th percentile against 361 and 524 ms. Aura 2 lists at $30 per million characters against our $3.

Where Deepgram is the better choice and where Speakvora is, with sources and the pricing we checked: https://speakvora.com/compare/deepgram

The ranked table with every provider: https://speakvora.com/performance

Caveats: speed is not voice quality, and we did not benchmark quality or uptime. Deepgram also offers speech-to-text and a wider platform. Speakvora streaming needs a paid account. Prices change, so confirm on each provider's page.

If you are choosing a text-to-speech API for a voice agent, two numbers matter first: how long until the first audio plays, and how bad the slow end is (the 95th percentile).

On first audio, Speakvora Phonon is faster than both ElevenLabs models on the Coval leaderboard (53 ms against 189 and 206 ms), and it lists at $3 per million characters against ElevenLabs' $40.

Where ElevenLabs is the better choice and where Speakvora is, with sources and the pricing we checked: https://speakvora.com/compare/elevenlabs

The ranked table with every provider: https://speakvora.com/performance

Caveats: speed is not voice quality, and we did not benchmark quality or uptime. ElevenLabs has far more voices, languages and voice-design features. Speakvora streaming needs a paid account. Prices change, so confirm on each provider's page.

If you are choosing a text-to-speech API for a voice agent, two numbers matter first: how long until the first audio plays, and how bad the slow end is (the 95th percentile).

Polly Standard starts audio faster than ours (42 ms vs 53 ms), so if first-audio speed is all you need, test it. Against Polly Neural, Phonon is 90 ms faster and $13 cheaper per million characters.

Where Polly is the better choice and where Speakvora is, with sources and the pricing we checked: https://speakvora.com/compare/amazon-polly

The ranked table with every provider: https://speakvora.com/performance

Caveats: speed is not voice quality, and we did not benchmark quality or uptime. Speakvora streaming needs a paid account. Prices change, so confirm on each provider's page.

The question I keep getting is simple: is paying once actually cheaper than a $79-a-month AI receptionist, or is that a nice story? So I worked it out.

What I compared

On the monthly side I used the entry prices that third-party guides report: about $79 a month for Goodcall and about $99 a month for My AI Front Desk. These are reported figures, not taken from the vendors' own pages, and some sources disagree, so check before you rely on them.

On our side, a bundle with the agent is $214 to $399 once per location. I used the $214 one. On top of that you pay your phone provider. At Twilio's US list prices that is $1.15 a month for a number and $0.0085 a minute for inbound calls. Speech to text through our API is $0.0015 a minute, so I added that too.

The first year

Over three years, with no renewals, the one-time side comes to $291, $471 and $975. The monthly plans are $2,844 and $3,564 before any overage.

At 600 minutes a month, the first year costs about a third of the cheaper monthly plan, and the gap widens every year because nothing recurs.

What I left out, and it favours the monthly plans

Monthly plans have call, customer or minute limits, and a busy shop pays overage on top. I did not add any of that. Texts are extra on both sides.

Where the monthly service is simply better

• You do not want software on your own computer. Our agent runs on yours. If it is off or asleep, inbound Twilio calls are missed unless you set up the optional fallback. This is the biggest catch, and it is why this is not for everyone. Texts are retried by Twilio, so those are less of a problem.
• Very light use. Smith.ai's AI plan reportedly includes about 25 calls a month free. If that is all you need, it beats us.
• You need a human to answer. We are not a human service, and we make no HIPAA or compliance claim.

Setup is not instant either

About five minutes to a first test, then roughly fifteen more to connect something like Slack, Teams or an Android phone. If you text through a US Twilio number, carrier approval can take days. The hosted services advertise minutes to about an hour; those are the vendors' own claims, so I would treat all the setup times, ours included, as rough.

Everything starts in practice mode. The agent records what it would do and sends nothing until you press Go live, and a Test screen lets you type what a customer would text and see the reply first.

What I would do

If your calls are steady and you can keep a computer running, pay once. If you want it hosted, or you only get a handful of calls, take a monthly plan and do not feel bad about it.

The full table, with sources and the date I checked each price, is here: https://speakvora.com/ai-receptionist-cost-and-setup-time-compared

If you have run one of these for a year, I would like to know what the bill actually turned out to be.