In one line: ~0.60 seconds, median, for the reply to reach your device, measured end to end on the live system, network included, on the turns a real conversation is made of.
The headline numbers
0.41s
Best
The fastest turn in a session.
~0.60s
Typical
The median turn, what a normal back-and-forth feels like.
What you're actually waiting for
~26 ms
Network
The round trip between your device and our servers.
~0.47 s
The reply
Understanding what you said, drawing on what it remembers about you, and composing a reply that clears our safety guardrails.
~0.12 s
The voice
Our hosted speech engine turns it into the first audio sent back to you.
All three are measured, not estimated. It's the gap a person feels: from the moment you finish speaking to the moment the reply's first audio reaches your device, not the time to the full answer, and not a synthetic benchmark.
The voice runs on our servers
Every number here includes the voice. Where most apps hand the text to an outside text-to-speech service (adding a network hop and a queue we don't control), we generate speech on our hosted engine, on dedicated GPU capacity we operate.
⚡First sound out
~0.12s on the full path, with your network included.
📈Stays fast under load
In a stress test we pushed well past normal concurrency with zero failures. The voice held its speed where a rented API slides into multi-second delays.
👂What it means for you
The voice starts almost immediately, and it doesn't degrade when the app gets busy.
How we measured it: a closed-loop load test against the live voice service: real synthesis of a real line, timed to the first audible sample, reported as median and 95th-percentile across many runs at each concurrency level. No warm-up cherry-picking; the one-time cold start is excluded and noted.
Where the 250 turns actually landed
median 0.60s
95th
10%
12%
11%
0.4s0.5s0.6s0.7s0.8s
Each bar is a 20 ms band; height is how many of the 250 turns landed there. Half finished under 0.60s, 94% under 0.70s, and every turn under 0.82s.
Best 0.41s
Median 0.60s
Mean 0.59s
95th 0.71s
99th 0.76s
Before the clock starts. There's a brief pause while we confirm you've finished speaking, the same settle any voice interface needs. It isn't in the figures above, which measure our system's response once your words are on their way.
What the clock measures. We start the clock when your words leave your device and stop it when the first audio of the reply arrives back. Your device then buffers briefly before playing, and every phone adds a little of its own audio delay, so what you hear lands a few tenths later than the figure above. We publish the part we control and measure.
How we report the tail. We publish the 95th and 99th percentiles rather than the single slowest turn: the more turns you measure, the worse the worst one gets, purely because you looked at more of them, so a slowest-turn figure would reward us for measuring less. 95% of turns complete within 0.71s, 99% within 0.76s, and no turn in the 250 exceeded nine tenths of a second. Percentiles are nearest-rank, so they are always a turn that actually happened rather than an interpolated value.
Every value from five real runs of 50 turns each, measured about 900 km from our servers. All 250 turns came back in under a second. We report the median (0.60s), not the average, so a normal turn is represented by where turns actually land, not dragged by an occasional slow one. Half of all turns fall between 0.53 and 0.65 seconds.
The dataset, in full. Every one of the 250 turns is in the raw file, unedited. Nothing dropped, nothing smoothed: thn-latency-2026-08-22.csv, 250 rows, one per turn. Every figure on this page can be recomputed from it.
How it's measured
🟢On the live system
The exact pipeline real users hit, same servers, same AI, our own speech engine. No mockup, no pre-recorded or cached reply.
🏠About 900 km away
A normal web browser on a home internet connection, about 900 km from our servers, not a server sitting next to it.
🔁A run of turns, each timed
Each measurement is a run of consecutive turns, timed individually, then summarized to a median.
Why the numbers are honest, not cherry-picked
1
Network time is included. We measure the actual round trip (median of repeated pings) and add it to every number, no flattering constant, never quietly dropped.
2
"Typical" is the median, not the average. One slow turn can drag an average the wrong way. The median is the value a real turn lands near, and it's what we publish.
3
We exclude only the one-time warm-up, and say so. The first reply is prepared on the welcome screens, before you talk, so you never wait for it. The published numbers are warm, mid-conversation turns.
4
One-time setup isn't counted per turn. Placing your AI Friend in your space happens once, behind onboarding, so it isn't part of the per-reply wait.
5
It's reproducible. Because it runs against the live system, anyone can repeat it from any consumer connection, a repeatable result, not a one-off claim.
A note on apples-to-apples
Ours is a stricter measurement than many speed figures you'll see. We measure the complete path to the first audio delivered, network, thinking, and voice combined, on a warm mid-conversation turn. Some published figures cite only "time to first text token," or a best-case lab run next to the datacenter, or leave the network out entirely. We report the whole thing, not the easiest slice of it.
