gpt-live-1 results at a glance: phone first, then web
Every figure below was observed on the APIFleet server, not at the caller's ear, and each carries its own sample size. Phone means Telnyx media streams from 11 September to 29 October 2026, web means browser test sessions from 10 September to 28 October 2026, and the two channels are never pooled.
Medians are shown because these distributions are skewed. The two greeting rows start their clocks at different points and come from different assistants, so they are not a comparison. The sections below give the 75th and 90th percentiles, the exact definitions and the confounders behind each row.
| Measure | Phone (Telnyx) | Web (browser tests) |
|---|---|---|
| Calls analysed | 1,073 calls, 20 assistants | 183 calls, 159 assistants |
| Model-spoken greeting: start of the Live connection to first audible greeting audio | 3,775 ms (309 calls) | 2,368 ms (158 calls, from 13 Sep) |
| Cached greeting clip: media stream accepted to first clip frame sent | 58 ms (632 calls, 2 assistants, from 12 Sep) | Not used on web |
| Delegated backend: first backend event to final event, per response | 1,478 ms (3,003 responses, 551 calls) | 1,604 ms (559 responses, 109 calls) |
| Backend input tokens per delegated response | 17,321 (3,003 responses, 551 calls) | 10,219 (559 responses, 109 calls) |
| Tool call duration | 3,257 ms (1,082 tool calls, 454 calls) | 90 ms (117 tool calls, 56 calls) |
| Tool calls whose result was an error | 7.4% of 1,082 tool calls (454 calls) | 5.1% of 117 tool calls (56 calls) |
| Calls ended by a Live pipeline error | 1.0% (11 of 1,073 calls) | 1.6% (3 of 183 calls) |
| Calls of 10 s or more with no assistant audio | 0.9% (7 of 745 calls) | 1.2% (2 of 168 calls) |
| Estimated AI provider and carrier cost per connected minute, pooled | $0.0574 (1,073 calls) | $0.0659 (183 calls) |
| Response time after the caller stops speaking | Not measurable | Not measurable |
What gpt-live-1 is and how APIFleet runs it
OpenAI's model page presents gpt-live-1 as a full-duplex model for live voice conversation, able to listen while it speaks and to pass reasoning and tool calls to a separate backend, and describes it as its premier model for “natural, expressive voice conversations with smooth interruption handling”. It accepts audio and text, produces audio and text, and is offered only through OpenAI's Live sessions endpoint, not through the Responses, Chat Completions or Realtime APIs.
OpenAI charges $0.05 per minute of Live session, billed by the second with no rounding to whole minutes, and charges for the backend model's tokens and any tool usage on top. Inside APIFleet, gpt-live-1 carries the spoken conversation while business instructions, knowledge and the assistant's tools go to a managed OpenAI Responses backend that each assistant selects.
When the backend calls functions, APIFleet runs them through its existing tool handlers one at a time and then resumes the backend once with all the results. Voice style, language, accent and the greeting go to gpt-live-1 itself; the older Realtime controls for transcription, speed and voice activity detection do not configure Live, which keeps its own continuous conversation timing.
APIFleet's platform defaults for a new gpt-live-1 assistant are the marin voice and GPT-5.6 Terra as the backend, with low reasoning effort, the Standard processing tier and 4,096 delegated output tokens; GPT-5.6 Luna and Sol are the other backend choices. Most measured calls did not use those defaults.
On the phone (11 September to 29 October 2026), 99.7% of the 1,073 calls ran the willow voice with GPT-5.6 Luna as the backend, low reasoning and the Standard tier, and no phone call used the Fast tier, which OpenAI prices at twice the Standard token rates. On the web (10 September to 28 October 2026), 62% of the 183 calls ran marin with Terra, 14% willow with Luna and 9% gleam with Terra.
| Model | Role on APIFleet | OpenAI list price |
|---|---|---|
| gpt-live-1 | Voice model for the whole session | $0.05 per Live minute, billed per second |
| GPT-5.6 Luna | Backend on all but one of the 1,073 phone calls | $0.20 input, $0.02 cached input, $1.20 output per million tokens |
| GPT-5.6 Terra | Platform default backend, used on most web calls | $2.00 input, $0.20 cached input, $12.00 output per million tokens |
| GPT-5.6 Sol | Optional backend | $4.00 input, $0.40 cached input, $20.00 output per million tokens |
Where the data comes from and how it was measured
The data is APIFleet's own production call traces: 1,073 phone calls and 183 browser test calls that ran gpt-live-1 between 10 September and 29 October 2026, from a de-identified extract of call logs. Simulations and calls without trace events are excluded, and this page reports aggregates only, with no transcripts, recordings, caller details or customer names.
Each trace event is stamped by the APIFleet server's clock when the code path runs, so every time on this page is a server observation. Phone audio then leaves in paced 20 ms frames through the carrier and browsers buffer audio too, so no event marks the moment a caller heard something.
Rates appear only for groups of at least 20 calls and percentiles only for at least 20 samples. Intervals are 95% bootstrap intervals that resample whole calls; resampling whole assistants gives far wider intervals where a few assistants dominate, for example 1,777 to 3,447 ms for the phone tool-call median (1,082 tool calls) and 0.0% to 6.5% for the silent-call rate (745 phone calls).
Live greeting events appear in the data from 11 September on the phone and 13 September on the web, cached-clip events from 12 September and web backend and tool events from 11 September, so those figures start on those dates. No call, assistant or setting was randomly assigned, so no difference on this page shows what the model, a voice or a setting caused.
| Channel | Calls | Assistants and tenants | Dates | Median call length | Calls under 10 s |
|---|---|---|---|---|---|
| Phone (Telnyx media streams) | 1,073, 11% outbound | 20 assistants, 2 tenants | 11 Sep to 29 Oct 2026, calls on 49 days | 37.3 s | 31% |
| Web (browser test sessions) | 183, browser only | 159 assistants, 3 tenants | 10 Sep to 28 Oct 2026, calls on 38 days | 58.8 s | 8% |
Why response time after the caller stops is not measurable
We cannot report how quickly gpt-live-1 answers after a caller finishes speaking, on the phone or on the web. That measurement needs two timestamps from the same session, the end of the caller's turn and the start of the reply's audio, and these traces contain only the second.
OpenAI's Live WebSocket guide lists no event for a caller starting or stopping speech, no end-of-turn event and no interruption event, and its output audio carries no timing information and no event marking its end. The Live conversation guide adds that transcript fragments do not mark where a turn ends, so the application has to group them into turns itself.
APIFleet therefore records no caller endpoint for gpt-live-1, whereas OpenAI Realtime sessions log the voice activity detector's stop and cascading sessions log the final transcript. Even the start of assistant speech is inferred from the audio: APIFleet marks it at the first 20 ms output frame with an audible sample, at the start of a session or after at least 600 ms of quiet output.
Input transcripts do carry start and end times, but OpenAI calls those times approximate rather than word-accurate, and this analysis does not use them as an endpoint. Barge-in and talk-over rates are missing for the same reason: there is no interruption event to count.
The backend response time reported below is no substitute. OpenAI's delegation guide points out that the spoken conversation and the backend work proceed separately, so a completed backend response is no evidence that the caller has heard its result.
Greeting time: model-spoken greetings and cached clips
On the phone (11 September to 29 October 2026), gpt-live-1's model-spoken greeting reached the server a median 3,775 ms after APIFleet began connecting the Live session (309 calls, 18 assistants; interval 3,657 to 3,904 ms; p75 4,363 ms, p90 4,764 ms). On 632 other phone calls a pre-recorded clip went out instead, its first frame a median 58 ms after the carrier's media stream was accepted. The two clocks start at different points and cover different assistants, so the figures are not comparable.
A native opening is the model speaking the configured greeting: its clock starts when APIFleet begins connecting the Live session and stops at the first audible frame of the greeting it receives, and carrier answer and media set-up before that are not included. A cached opening is a pre-recorded clip that APIFleet's phone bridge plays itself, without waiting for the model.
In stages, connecting until OpenAI reported the session started took a median of 1,606 ms, and from that point to the first greeting audio a median of 2,054 ms, over the same 309 calls. Stage medians do not add up to the median of the total.
Native greetings were requested on 368 phone calls: 309 produced greeting audio, on 47 a caller transcript arrived before any greeting audio and 12 sessions closed before either, and no call ended on the runtime's 12-second silent-opening timeout. On 41.0% of the 368 (151 calls), nothing audible had arrived and the caller had not spoken 1.5 seconds after OpenAI acknowledged the greet instruction, so the runtime sent its one nudge; this rate does not show that the nudge produced any greeting.
On the web (13 September to 28 October 2026), native greetings took a median of 2,368 ms (158 calls, 144 assistants; p75 2,892 ms, p90 3,928 ms), split into 1,562 ms until OpenAI reported the session started and 536 ms from there to audio, and 13.1% of 160 attempts (21 calls) were nudged. Leaving out each channel's busiest day changes little: 3,844 ms on the phone without 15 September (290 openings) and 2,401 ms on the web without 17 September (143 openings).
Cached clips ran from 12 September on calls to the two assistants that had a verified clip, which APIFleet operators install per assistant rather than through a dashboard setting; the bridge uses a clip only on authenticated inbound Telnyx calls whose clip matches the current greeting, voice and settings. Their median of 58 ms (p75 172 ms, p90 248 ms) runs from the moment APIFleet accepted the media stream to the first clip frame sent back, and with only two assistants behind it the figure describes those two, not other deployments.
Do not subtract one opening type from the other. On cached calls APIFleet began connecting the Live session about 55 ms after accepting the media stream, so the cached clock starts that much earlier than the native one. Only 3 of the 309 native phone openings came from the two clip assistants, so any gap mixes assistant differences with the opening method.
What the design guarantees is ordering: the model is told not to greet, and its first reply is queued behind the clip. Neither figure marks the moment a caller heard sound, and OpenAI's conversation guide itself recommends playing a recorded clip from the application when the exact opening words or their start must be known.
| Opening path | Phone calls | What the trace shows |
|---|---|---|
| Cached clip sent by the bridge | 632 | First clip frame sent a median 58 ms after the media stream was accepted |
| Native greeting, audio received | 309 | First greeting audio a median 3,775 ms after APIFleet began connecting the Live session |
| Native greeting, caller transcript first | 47 | A caller transcript arrived before any greeting audio |
| Native greeting, session closed first | 12 | The session closed before any greeting audio or caller transcript |
| No greeting requested or played | 73 | Neither a clip nor a greeting request appears in the trace |
Delegated backend: response time and prompt size
On the phone (11 September to 29 October 2026), with GPT-5.6 Luna at low reasoning, a delegated backend response took a median of 1,478 ms over 3,003 responses in 551 calls from 11 assistants (interval 1,441 to 1,507 ms; p75 1,896 ms, p90 2,433 ms). The median prompt was 17,321 input tokens per response (p75 18,697, p90 20,420), and most of these responses came from one assistant.
Each time gpt-live-1 hands work to the backend, OpenAI runs a Responses call, and APIFleet times it from the first backend event it receives for that response to the response's final event. Tools run between backend responses, so tool time is not inside these durations, and neither is the hand-off before the first event or the voice model speaking the result.
On the web (11 September to 28 October 2026), mostly with GPT-5.6 Terra, the median was 1,604 ms over 559 responses in 109 calls (p75 2,176 ms, p90 2,967 ms), and the median prompt was 10,219 input tokens (p75 11,536, p90 17,544). The two channels differ in backend model, prompts, tools and assistants at once, so the gap is not a comparison of Luna and Terra.
Treat these figures as backend processing time, not as time a caller spent waiting. As illustrative arithmetic only, 17,321 input tokens at Luna's uncached list rate of $0.20 per million come to about $0.0035 per response; OpenAI lists cached input at a tenth of that rate and charges output tokens separately, so the recorded backend cost in the cost section is the better guide.
Tool calls: duration and error share
On the phone (11 September to 29 October 2026), 454 of the 1,073 calls made 1,082 tool calls with a median of 3,257 ms (interval 3,125 to 3,399 ms; p75 4,788 ms, p90 6,609 ms), and 7.4% of them returned an error (interval 5.3% to 9.7%). The 1,008 lasting 20 ms or more (450 calls), probably external tools, had a median of 3,400 ms, and one assistant made most of all 1,082.
Tool duration runs from APIFleet starting a tool call to receiving its result. The extract carries no tool names, so built-ins such as end_call and transfer_call are mixed in with HTTP tools, while hang-ups the runtime infers itself after a spoken farewell are left out.
A tool call counts as an error when its result carried an error field or reported ok as false. That covers endpoint failures, timeouts, errors returned by the tool service and calls the runtime rejected before sending them.
On the web (11 September to 28 October 2026), 56 calls made 117 tool calls with a median of 90 ms (p75 445 ms, p90 1,917 ms), and 5.1% returned an error. These durations describe each tenant's booking and CRM endpoints far more than gpt-live-1, so the gap between phone and web is not a model result.
APIFleet turns parallel tool calls off, so the backend requests one function at a time and is resumed only after that call has finished; a turn that needs two tools waits for both in sequence. The voice model can keep talking meanwhile, but nothing in these traces shows what the caller heard during the wait.
Error-ended and silent calls
On the phone (11 September to 29 October 2026), 11 of 1,073 calls (1.0%, interval 0.5% to 1.7%) ended on a Live pipeline error, 9 by a Live session error and 2 by an unexpected transport close, and 7 of 745 calls lasting 10 seconds or more (0.9%) were silent. No phone call ended on a lost carrier or assistant connection (0 of 1,073, rule-of-three upper bound 0.3%) or on the opening timeout.
A call counts as error-ended when its recorded end reason is a pipeline failure: for gpt-live-1, a Live session error, an unexpected transport close or the 12-second silent-opening timeout, plus assistant set-up failures, of which there were none. A silent call is one connected for at least 10 seconds in which neither assistant audio nor a cached clip ever started.
On the web (10 September to 28 October 2026), 3 of 183 calls (1.6%) ended on a Live session error, none on a lost connection (upper bound 1.6%), and 2 of 168 calls lasting 10 seconds or more (1.2%) were silent. These rates count the failures a Live session reports, so they are not directly comparable with pipelines that report failures another way.
Most calls ended from the caller's side or the assistant's, as the table shows; the bridge also records the caller-side reason when the carrier ends the media stream without stating why. The assistant-ended count can include calls the runtime closed after an audible farewell when the model did not call end_call itself.
| End reason | Phone calls (of 1,073) | Web calls (of 183) |
|---|---|---|
| Caller or browser user ended the call | 948 | 169 |
| Assistant ended the call | 110 | 10 |
| Live session error | 9 | 3 |
| Maximum call duration reached | 4 | 1 |
| Unexpected Live transport close | 2 | 0 |
| Silent-opening timeout | 0 | 0 |
Cost per connected minute, by component
On the phone (11 September to 29 October 2026), AI provider and carrier costs came to an estimated $0.0574 per connected minute, pooled over 1,073 calls and about 1,035 connected minutes (interval $0.0571 to $0.0576): $0.0488 for the Live voice, $0.0031 for the Luna backend and $0.0055 for the carrier, with nothing for separate transcription. The per-call median was $0.0584 and the 90th percentile $0.0603 (745 calls of 10 seconds or more), all before APIFleet's platform fee.
These costs are APIFleet's estimates from configured rate cards, not invoices, divided by connected call time. The Live voice is priced at OpenAI's $0.05 per Live minute, the backend from its recorded input, cached-input and output tokens at OpenAI list rates and the phone carrier at a configured flat $0.0055 per minute; pooled figures divide all cost by all connected minutes, and per-call figures use calls of 10 seconds or more.
The voice line sits just under $0.05 because Live session seconds added up to slightly less than connected call time. On the web (10 September to 28 October 2026), where most calls ran Terra at ten times Luna's list token rates, the backend line was $0.0165 and the pooled total $0.0659 per connected minute (183 calls, about 260 minutes), with a per-call median of $0.0601 (168 calls).
Usage was estimated rather than confirmed on 37 phone and 5 web calls. On 39 of those 42, OpenAI never confirmed the billed seconds, so the larger of its last usage update and wall-clock time stands in; on the other 3, all on the phone, a backend response returned no usage or did not finish.
None of these figures includes APIFleet's own charge: a platform fee of $0.03 per connected AI minute, billed per second, with AI providers and the carrier billed on top. As illustrative arithmetic only, adding it to the phone estimate gives about $0.087 per minute, if every connected minute is billed as an AI minute.
If an assistant uses your own OpenAI key, OpenAI bills the Live minutes and backend tokens to your account directly. For the platform layer alone, Vapi's pricing page lists a $0.05 per minute hosting fee on its pay-as-you-go option, with model, voice and transcription costs charged separately and third-party carriers billing their own rates (checked 29 October 2026).
| Component | Phone, pooled (1,073 calls) | Web, pooled (183 calls) |
|---|---|---|
| Live voice: gpt-live-1 at $0.05 per Live minute | $0.0488 | $0.0494 |
| Delegated backend tokens | $0.0031 (GPT-5.6 Luna) | $0.0165 (mostly GPT-5.6 Terra) |
| Carrier at a configured flat rate | $0.0055 | $0.0000 (browser sessions) |
| Separate transcription | $0.0000 | $0.0000 |
| Total | $0.0574 | $0.0659 |
| Per-call median, calls of 10 s or more | $0.0584 (745 calls) | $0.0601 (168 calls) |
Confounders and limits of this data
This is observational production data, not a controlled benchmark: nothing was randomized or matched on prompt, tools, callers, dates or channel. Use it to set expectations and to design your own tests, not to rank gpt-live-1 against other models.
A few assistants dominate. Two assistants made most of the phone calls, and a single assistant contributed most of each phone sample (native openings, backend responses and tool calls), and the cached-clip figures come from two assistants.
Web calls are browser tests and demos spread over 159 assistants, and they can include automated evaluation runs. Phone calls include developer test and demo calls, 31% lasted under 10 seconds and 11% were outbound.
Phone and web differ in voice (willow against mostly marin), backend (Luna against mostly Terra), prompt size, audio format (8 kHz phone audio against 24 kHz browser audio) and tenants (2 against 3). Native and cached phone openings came from different assistants, and tool timings describe tenants' own endpoints.
APIFleet's runtime kept changing during the seven-week window, and any vendor-side model update would be invisible here. Every time is a server observation that leaves out carrier and browser buffering, and every cost is a rate-card estimate rather than a bill.
How to check gpt-live-1 on your own calls
These steps turn the measurements above into checks for your own deployment. They describe what to measure, not tests we ran for this page.
- Choose the backend deliberately in the assistant editor, reached from the dashboard at /app/assistants: the phone calls above ran GPT-5.6 Luna, while APIFleet's default backend is GPT-5.6 Terra.
- Decide whether the greeting must be word-for-word or start at a known moment. If so, OpenAI's conversation guide recommends a verified clip played by the application over the model's own opening; on APIFleet such clips are installed per assistant by operators, not set in the dashboard.
- Time native greetings from your own session start, and count how often callers speak before any greeting audio arrives.
- Log backend duration and input tokens for every delegated response, because each delegated response is billed for its whole prompt, at a lower rate for cached input.
- Time every tool endpoint and record its error share apart from the model, and make write operations safe to retry before going live.
- Track error-ended calls and calls of 10 seconds or more with no assistant audio, separately for phone and web.
- Compute cost per connected minute from Live seconds, backend tokens and carrier minutes, then add APIFleet's $0.03 platform fee per connected AI minute.
- Audition voice and accent in a browser test, then confirm on real phone calls, because the phone path carries 8 kHz audio while browser tests use 24 kHz.
Continue with a practical next step
- Set up OpenAI realtime voice models in APIFleet
- Route Telnyx phone calls to an assistant
- See APIFleet's platform fee and billing boundaries
- Estimate platform, provider and carrier costs
- Test tool calls and timeouts with a checklist
- Compare speech-to-speech models on phone calls
- How long voice agent tool calls take on real calls
- What happens when callers talk during the opening
Frequently asked questions
How fast does gpt-live-1 respond after a caller stops speaking?
These traces cannot tell. OpenAI's Live WebSocket guide lists no end-of-speech event, so APIFleet records no caller endpoint to time a reply from; across 1,073 phone and 183 web calls (10 September to 29 October 2026) we can time greetings, backend responses and tools, but not the gap after each caller turn.
What does gpt-live-1 cost per minute on phone calls?
OpenAI lists $0.05 per Live minute, billed per second, plus backend model usage. On 1,073 APIFleet phone calls from 11 September to 29 October 2026, with a GPT-5.6 Luna backend, voice, backend and carrier came to an estimated $0.0574 per connected minute, before APIFleet's $0.03 platform fee per connected AI minute.
Which gpt-live-1 configuration did these phone calls use?
99.7% of the 1,073 phone calls (11 September to 29 October 2026) ran the willow voice with GPT-5.6 Luna as the backend, low reasoning effort and the Standard tier. APIFleet's platform default backend is GPT-5.6 Terra, which most of the 183 web calls (10 September to 28 October 2026) used.
Is a cached opening faster than a native gpt-live-1 greeting?
This data cannot answer that. The cached median of 58 ms (632 phone calls, 2 assistants, from 12 September) and the native median of 3,775 ms (309 phone calls, from 11 September, both to 29 October 2026) start from different points and come from almost entirely different assistants, so they are not a controlled comparison.
Is this a benchmark of gpt-live-1?
No. It is observational data from calls on APIFleet's production platform, with different assistants, prompts, tools and dates behind each number, so it shows what happened on these calls rather than what the model causes.
Sources and evidence
- OpenAI API docs: GPT-Live 1 model page · observed 2026-10-29
- OpenAI API pricing: GPT-Live sessions and GPT-5.6 models · observed 2026-10-29
- OpenAI guide: Live delegation and tools · observed 2026-10-29
- OpenAI guide: Live conversations, transcripts and openings · observed 2026-10-29
- OpenAI guide: Live over WebSockets, server events · observed 2026-10-29
- Vapi pricing: hosting fee and pass-through costs · observed 2026-10-29