OpenAI Opens the GPT-Live-1 API: Bring GPT's Voice Conversation Capabilities into Any App at $0.05 per Minute

OpenAI has officially brought GPT-Live-1, previously debuted in ChatGPT, to its API, available starting today. As a real-time voice model supporting full-duplex communication, GPT-Live-1 can listen and speak simultaneously; as demonstrated in Codex and ChatGPT Work, it can delegate deeper reasoning and actions to paired models and tools. This capability is primarily aimed at developers looking to build natural voice interaction experiences into applications and business workflows, giving them greater flexibility over the expressive style and behavior of their voice agents.

Why Previous Voice AIs Always Felt Like "Walkie-Talkies"

If you have ever used early automated phone customer support or talked to an in-car voice assistant in a noisy environment, you have likely experienced these awkward moments:

• You pause mid-sentence to find the right word, and the AI assumes you're done, jumping in to cut you off;
• The AI is reciting a chunk of information you don't need, you shout "hold on," but it insists on finishing the entire sentence before stopping;
• Someone coughs nearby or the cafe music gets louder, and the AI abruptly replies, "Sorry, I didn't catch that";
• While looking up an order, dead silence falls over the line, leaving you stuck waiting.

This comes down to how voice agents are built. There are three common architectural approaches:

The cascading approach stitches together speech recognition, a reasoning model, and speech synthesis. As noted on the launch page, every handoff adds latency and increases the risk of losing conversational timing, context, and natural rhythm; handling interruptions, pauses, or changes of mind requires developers to coordinate across all three stages themselves. Single-model real-time voice (such as GPT-Realtime-2.1) uses one model to handle speaking, reasoning, and tool selection all at once; Thavidu Ranatunga (who goes by Tav), engineering lead at Yelp, remarked in an official interview that previous speech-to-speech models "generally aren't smart enough to do complex tasks." GPT-Live-1 takes the third path: one model handles listening and speaking, while delegating deep reasoning and tool execution to the backend.

How GPT-Live-1 Works

You can think of it as a front-of-house receptionist focused entirely on real-time listening and speaking, while handing off complex reasoning and tasks to the back office. Unlike a cascading setup, however, GPT-Live-1's listening and speaking take place within a single model: it reasons over incoming and outgoing audio together, allowing it to speak and listen simultaneously. OpenAI states that it can distinguish between human voices and background noise, reacting instantly to interruptions or backchannel cues like "uh-huh" and "mm-hmm," while delegating deeper reasoning and tool calls to backend models or agents—letting the conversation continue seamlessly while the background work is underway.

In this demo, the Workbench interface features three swimlanes: You (Microphone), GPT-Live-1 (Voice frontend), and Backend (labeled GPT-5.6 Luna). Right at the start of the session, there is a delegation entry Display → "GPT LIVE 1", so the dot-matrix screen displays "GPT LIVE 1" from the very beginning. When the engineer asks the model to greet everyone, the model says, "Hi everyone! Great to be here. Welcome to the GPT-Live-1 launch.", while the backend simultaneously updates the display with the OpenAI logo and a waving animation. When discussing pricing, the screen shows "5¢ a minute", and the model explains that the front-end voice layer costs 5 cents per minute, with backend reasoning and tooling services billed separately. Notably, when the engineer interrupts at around 16–20 seconds and mentions background noise around 26–35 seconds, the Backend swimlane remains completely empty: interruptions and noise are handled entirely by the front end without triggering delegation. The only delegation entries visible on screen are display instructions; "handing off actions to the robot" comes from the model's own dialogue.

How to Choose and Delegate to Backends

The backend can be selected independently of the voice model. OpenAI's suggested setup: pair Luna with high-frequency tasks like appointment scheduling and order updates, and pair Astra with complex customer complaints requiring deeper reasoning—matching reasoning depth, speed, and cost to the specific task.

The developer documentation outlines two delegation modes:

• Responses delegation: GPT-Live directly invokes your configured Responses model, automatically forwarding conversation context and retrieving results—ideal for managed backends.
• Client delegation: Your application runs the backend itself, allowing you to connect any model, agent framework, or service, and decide which results to pass back to GPT-Live.

The delegation mode is selected when creating the session; switching modes requires starting a new session. Two caveats require special attention: a user interruption will not automatically cancel backend tasks that have already been dispatched—cancellation logic must be handled by your application; access control, confirmation mechanisms, private function execution, and long-term task state management are also the responsibility of your application.

In addition, the API version natively provides the following capabilities:

• Speech recognition transcripts (ASR transcripts) and response text;
• Robust alphanumeric recognition with support for keyword biasing, making it easier to accurately recognize product names, order numbers, and similar terms;
• Native turn detection despite not being a turn-based model, allowing development around clear conversational turn boundaries;
• Improved handling of background noise and pauses without disrupting the conversation or reading out every background step;
• Better context retention and conversational quality in long sessions;
• Support for telephony deployment, from restaurant reservations to enterprise customer support.

Conversational Experience: Interruptions, Noise, and Tone

OpenAI states that GPT-Live-1 can distinguish between human speech and ambient noise, meaning cafe clamor won't disrupt the flow; users also don't have to wait for the model to finish speaking before adding details or shifting direction.

The first half shows the cascading approach with the background noise slider at 8%: the AI rattles off a long explanation without pausing, only stopping when interrupted by the user, and then merely offers a vague response admitting that "it changed more than the loading spinner you asked for." The second half switches to GPT-Live-1 with noise dialed up to 29%. When the user chimes in mid-sentence asking, "I only asked for a loading spinner, why change the API calls?", the AI immediately concedes it over-modified things and suggests using the existing isLoading flag from the current hook instead; the user adds that no new dependencies should be introduced, and the AI agrees, confirming it will disable the button during loading.

While the backend handles reasoning and tool calls, the front end can keep chatting with the user, and the user can provide further clarification while waiting, with the front end speaking the final results once ready.

The clip opens in cascading mode: the user asks to "boost the bass," but the AI doesn't react, prompting the user to call out "Hello?" and repeat the request. Switching to GPT-Live-1, the music plays uninterrupted; when the user asks to "slow it down," the AI responds by saying "dropping to 108 BPM" (108 was decided by the AI itself), followed by requests for "dreamier, more space," and finally an ending riser effect. The Tool calls panel below logs set_playback, set_bass_layer, adjust_saturation, adjust_tempo (with a 2-second ramp per adjustment), set_reverb, and end_with_riser queued for the end of the bar.

Speaking style can be tuned via the system prompt: tone, pacing, expressiveness, as well as language and response length. In a tweet, OpenAI noted that it can also mimic the tone and emotion in the speaker's voice, matching their speaking pace.

The user prompts, "What do you call a fish wearing a bowtie?", and the AI beats them to the punchline with "so fish-ticated," prompting the user to tease, "You already knew that one, didn't you?" The AI then counters with a joke about a cup of coffee calling the police because it "got mugged."

Voices have also expanded from a handful of previous real-time options to a collection spanning multiple accents, dialects, and languages. The page lists 12 names: Quartz, Ripple, Vesper, Willow, Stone, Gleam, Meridian, Bossa, Tempo, Beacon, Delta, and Cinder. The default Quartz is noted as "Australian English influenced," while other accents are not detailed on the page; more voices and languages will be added in coming months, with custom voices available through sales. The launch page also includes a time-limited online demo where users can test interrupting, laughing, or changing their minds at home, in a cafe, or on the street.

Official Benchmarks: Interpreting the 7 Metrics

On the launch page, OpenAI published 7 benchmark evaluations, comparing GPT-Live-1 solely against its own previous-generation real-time voice models, GPT-Realtime-2.1 and GPT-Realtime-2, without including any third-party models:

First, note that the test conditions are not identical: GPT-Live-1 scores marked with † were connected to a backend text model, whereas both Realtime models operated as standalone single models. Tau3 (Voice) tests voice customer support tasks across three domains—airline, retail, and telecom—where Pass@1 measures the proportion of tasks completed successfully on the first attempt, with the total score equally weighted across all three domains. Paired with GPT-6 Astra (medium reasoning effort), GPT-Live-1 achieved 86.2%, compared to 45.7% for GPT-Realtime-2.1 and 42.4% for GPT-Realtime-2. OpenAI's claim of being "#1 on Tau3" is also only compared against its own two legacy models in the chart.

Tau Banking (Voice) evaluates 97 banking support tasks requiring knowledge base lookups and account tool usage. Also paired with Astra (medium), GPT-Live-1 reached 32.0%, approximately 2.6 times GPT-Realtime-2.1's 12.4%. The remaining ~68% simply indicates tasks that were not completed successfully on the first attempt among these 97 scenarios, and should not be equated directly to failure rates in real-world financial operations; however, for high-stakes operations, applications must still implement proper permissions and confirmations as advised in the documentation.

Regarding conversational rhythm, Full Duplex Bench v1's turn-taking latency (time from user finishing speech to AI speaking—shorter is better) for GPT-Live-1 was 0.798 seconds, roughly 43% shorter than GPT-Realtime-2.1's 1.41 seconds. On Full Duplex Bench v1.5 interactivity (reactions to background chatter, the user turning aside to speak to someone else, backchanneling, and interruptions), GPT-Live-1 scored 80.10%, which is 34.7 percentage points higher than GPT-Realtime-2.1's 45.4%; the official text states "30 percentage points higher" without explaining the calculation baseline, and GPT-Realtime-2 (47.8%) actually scored slightly higher than 2.1 on this metric. Artificial Analysis conversational pacing evaluations were very close across all three: 97.3%, 95.7%, and 95.3%. None of these pacing benchmarks indicated a backend model on the page.

The final two metrics come from Full Duplex Bench v3, evaluating tool usage when speech contains pauses, hesitations, and mid-sentence corrections. Here, GPT-Live-1 was paired with Terra (OpenAI's GPT-5.6 Terra text model, priced between Luna and Astra, using low reasoning effort): accuracy in tool call sequencing reached 87.0% (compared to 60.0% and 58.0% for the two Realtime models), while alignment between spoken responses and reference intent reached 90.0% (compared to 88.0% and 81.0%).

How Customers Are Using It

The demos and testimonials below are drawn from OpenAI's launch page, representing officially curated customer accounts; among them, OpenAI Presence is OpenAI's own enterprise product.

Restaurant Phone Lines: Yelp

A customer calls the restaurant Stella Lago, initially asking for a table for 4 on Saturday at 7:00 PM; mid-call, they turn to family to ask, "Are the kids coming?", and change the party to 2. Next, they shift the time to 7:30, mention it's an anniversary and request a window table, leave the name Patel, and ask about gluten-free options. The AI notes that a window request can be added to the reservation notes but cannot be guaranteed, and adds that gluten-free pizza crust and pasta carry a $3 surcharge. Finally, the customer changes the name to Smith. After confirming the details, the AI finalizes the reservation for Saturday at 7:30, 2 guests, under Smith. The video explicitly notes that the call recording was edited and real-world results may vary.

He shared that in early large-scale production testing, the proportion of calls fully handled by the AI increased, transfers dropped, and more callers began speaking to the AI in full, natural sentences. Alex Levy, CTO at Yelp, echoed this in a written testimonial on the launch page:

“When Yelp Host answers incoming calls for reservations, takeout, and inquiries with GPT-Live-1, we see a meaningful increase in call resolution. Callers are also starting to speak in fuller, more natural sentences...” — Alex Levy, CTO, Yelp

Customer Support: OpenAI Presence and Fin

OpenAI Presence is OpenAI's enterprise offering that leverages GPT-Live-1 for real-time voice, helping businesses deploy AI agents capable of answering questions, resolving issues, navigating company systems, executing approved actions, and handing off to humans when necessary. Details can be obtained through OpenAI account managers.

A customer calls about a steam mop order shipped a month or two ago that is still in transit; no longer wanting the item, they ask for a refund. Midway through, the customer asks the AI to "speak a little slower," and the AI promptly obliges. In the background, tool and delegation entries for order lookups and refund eligibility checks are visible, locating order SC-908214 and ultimately offering and logging a $20 goodwill credit, which the customer accepts.

Jordan Neil, COO at Fin, wrote on the launch page:

“Customers can pause, interrupt, and change direction naturally... Fin can combine this natural conversation with proprietary support systems for deeper processing to resolve issues.” — Jordan Neil, COO, Fin

Healthcare: EliseAI

“Compared to our previous cascading setup, GPT-Live-1 reduced our codebase by 80%, eliminating 23,000 lines of code. Patient conversations became natural and real-time, freeing our team to focus on refining the end-to-end journey from scheduling to care navigation.” — Tony Stoyanov, Co-founder and CTO, EliseAI

Language Learning: Speak and HeyGen

“...In our early evaluations, interruptions during learner thinking pauses dropped by nearly 80% compared to previous turn-based systems.” — Andrew Hsu, Co-founder and CTO, Speak

Learner Wayne practices ordering in a simulated Tokyo cafe. The instructor initially teaches ordering a latte with "ラテをください", but the learner interrupts to clarify they want regular coffee rather than a latte. The instructor immediately pivots to "コーヒーをください" (kōhī o kudasai), reminding them not to drop the "o" particle in the middle; Wayne wraps up by specifying iced coffee with "Aisu de." The "Unlimited concurrency / Pennies a minute" tagline at the opening and along the top banner is HeyGen's own marketing copy, not GPT-Live-1 pricing.

Coding and Creativity: Devin and Picsart

An engineer uses voice to instruct Devin to build the launch landing page for Devin Live: pull the "launch brief" from Notion, which outlines three design directions, open a child session for each to build in parallel, and ensure all align with Cognition's overarching brand identity. Devin works while conversing, delivering three preview versions:

• editorial: poised and essayistic, with generous whitespace and restrained blue accents;
• playful retro: retaining Cognition's core palette while adding pixel typography, sprite graphics, and an arcade aesthetic;
• bold: poster-sized headlines, high-contrast dark blocks, and electric blue.

“With Devin and GPT-Live-1, collaborating with an AI engineer starts to feel much more like working with a teammate. You can bounce ideas back and forth, validate approaches, or hand off tasks when stepping away from the keyboard.” — Walden Yan, Co-founder and CPO, Cognition

The screen shows a cast of children's cartoon characters (a capybara, Pickle the pug, Pip the mouse, etc.). The user selects the capybara group and asks the AI to brainstorm 4 new scenes and generate them simultaneously: a rainbow garden maze, a boba playhouse cafe, a cardboard box rocket, and a silly dance parade. During generation, the user interrupts to request a character reference sheet for Pip the mouse; the AI agrees (though verbally mistakenly saying Pickle's reference sheet). By the end of the video, 3 of the 4 scenes are complete.

Pricing and Costs

The front-end voice layer costs $0.05 per minute—equivalent to $3.00 per hour—billed by the second without rounding up to whole minutes. Billing runs as long as the session remains open, making it crucial to explicitly close sessions once calls finish. The previous-generation GPT-Realtime-2.1 was billed by audio tokens ($32 per million input tokens, $64 per million output tokens); GPT-Live-1 switches the voice layer to duration-based billing, with backend reasoning billed separately.

Backend models are billed by tokens, while tools incur their own individual pricing. Standard short-context rates from the pricing page:

• GPT-6 Astra: $10 per million input tokens, $50 per million output tokens;
• GPT-5.6 Terra: $2 input, $12 output;
• GPT-5.6 Luna: $0.20 input, $1.20 output.

OpenAI provides no official total hourly cost figure. To illustrate with an explicitly hypothetical scenario: 60 delegations per hour, each with 4,000 input tokens and 150 output tokens, excluding reasoning/thinking tokens and any tool fees. With Luna on the backend, inputs run about $0.048 and outputs about $0.011, totaling around $0.06; combined with the $3.00 front-end layer, that comes to around $3.06/hour. With Astra on the backend, inputs run $2.40 and outputs $0.45, totaling around $2.85; combined with the front end, that comes to around $5.85/hour. The actual bill will depend on delegation frequency, context length, and tooling expenses.

Developer Onboarding

Connection Methods

The developer documentation lists several connection methods:

• WebRTC: In-browser voice applications, with audio traveling over media tracks and JSON events over data channels;
• WebSocket: Server-side audio integration, transmitting both audio and control events over a single connection;
• Server-side controls: Adding a sideband connection to pass events into an existing session while audio continues across the primary connection;
• Telephony and SIP: Connecting to telephone lines;
• Partner integrations: For teams already using LiveKit, Twilio, Telnyx, or Daily/Pipecat, connect via official partner integration guides.

Getting started steps:

1. Prepare a microphone and an HTTPS or localhost webpage; keep the API key on a trusted server rather than exposing it to the client;
2. Write a concise front-end prompt establishing speaking style and when to call the backend;
3. Connect browser microphone input, audio playback, and event channels according to the quickstart guide, creating the session and exchanging Offer/Answer from the server;
4. Begin speaking only after receiving session.started;
5. Explicitly close the session upon completion to capture final usage and release the connection.

Front-End Prompt Example (Editor-Written)

The GPT-Live prompt should be concise, governing only speaking style (tone, pace, expressiveness, language, response length) and when to reach out to the backend; detailed business logic and tooling workflows belong in the backend.

# Role & Tone
You are a phone receptionist for a restaurant.
Maintain a warm, natural, and professional tone, with a moderate pace
and expressive delivery.
Respond in English,
keeping each spoken turn to 1 or 2 sentences,
avoiding long speeches.
When the user pauses to think,
use brief, natural conversational affirmations where appropriate
(such as "sure," "got it"),
without repetitively overusing catchphrases.

# Delegation Rules
You are responsible for maintaining a natural, fluent phone conversation;
do not directly query or modify business databases yourself.
1. When handling specific operations like checking table availability,
   confirming reservations, or canceling/modifying bookings:
   - First verbally ask the user to wait briefly, for example:
     "Sure, one moment, let me check that for you,"
     and then dispatch the request to the backend.
2. While the backend processes the task:
   - If the user adds preferences or raises new requests,
     continue listening naturally and acknowledge briefly.
3. Upon receiving results back from the backend:
   - Extract the key information and convey it to the user
     in natural, conversational phrasing within two sentences,
     never reading out raw API data verbatim.

Connecting GPT-Live-1 to Codex (Official Code Snippet)

The launch page includes a code snippet showing how to connect GPT-Live-1 to Codex; under the developer documentation's taxonomy, running the backend within your own application falls under client delegation. OpenAI notes: This snippet shows only handing conversation context over to Codex and returning the answer to GPT-Live-1; connection setup and delegation handling are omitted. sandboxMode: "read-only" combined with approvalPolicy: "never" specifies a read-only repository requiring no human approvals, making it suitable exclusively for read-only Q&A. Comments added by the editor.

import { Codex } from "@openai/codex-sdk";

// 1. Initialize the Codex execution thread (configured as a read-only sandbox requiring no human approval, suitable for read-only retrieval)
const thread = new Codex().startThread({
  workingDirectory: "./repo",
  sandboxMode: "read-only",
  approvalPolicy: "never",
});

// 2. Receive delegation requests from the GPT-Live-1 front end (Client delegation mode)
async function answer(live, delegationId, context) {
  // Pass conversation context to Codex for retrieval and answering
  const { finalResponse } = await thread.run(
    `Answer the latest question using this repo.\nReply in two short spoken sentences.\\n${context}`
  );

  // 3. Send results back via event to the GPT-Live-1 front-end voice layer for broadcast
  live.send({
    type: "session.commentary.append",
    delegation_id: delegationId,
    content: finalResponse,
  });
}

Pre-Launch Checklist (Editor-Written)

1. Turn-taking latency: Test on real-world 4G/5G or VoIP phone connections to see whether the delay from user finishing speech to the agent responding comes close to the 0.8 seconds reported in benchmarks (adjust thresholds according to your use case).
2. Pauses and cut-offs: Simulate thinking out loud ("I'd like to reserve... uh... well... a table for two this Saturday evening") to see if the agent jumps in prematurely (example buffer: 1.5 seconds, adjusted to your needs).
3. Background chatter and noise: Test in environments with nearby conversations, TV audio, or ambient noise to ensure third-party speech isn't misinterpreted as instructions.
4. Backend tasks after interruptions: Interruptions do not automatically cancel dispatched backend tasks; when users change their minds, your application must handle cancellation or reset state itself.
5. Permissions and confirmations: Sensitive or irreversible operations such as payments, charges, refunds, or itinerary changes require explicit confirmation steps implemented by your application.
6. Session teardown: Front-end billing runs by the second, requiring explicit session closure; establishing a maximum per-session duration (e.g., 15 minutes as an example threshold) is recommended to prevent dangling connections from client anomalies.

Realtime remains an officially supported option, relying on a single model to manage speech, reasoning, and tool selection simultaneously. When you need to handle complex business logic and tool execution alongside fluid conversation, GPT-Live-1's front-end/back-end division of labor offers significantly greater flexibility in architectural design.