OpenAI has made GPT-Live-1 available in the API, moving the full-duplex voice model that first appeared in ChatGPT into developer-built applications. The release matters because the voice layer no longer needs to own all reasoning and tool work. GPT-Live-1 can run the live conversation while delegating deeper work to a separate backend model or agent.
OpenAI prices the front-end voice layer at $0.05 per minute, with backend model and tool costs billed separately. For engineering teams, this changes the core design question. The challenge is no longer only how to connect speech recognition, reasoning and speech synthesis; it is also how the conversational layer and delegated execution layer share state, permissions and lifecycle control.
Full duplex moves timing into the model
Traditional voice stacks often chain speech recognition, a language model and speech synthesis. OpenAI says GPT-Live-1 instead reasons over incoming and outgoing audio together, allowing it to react to interruptions, acknowledgements, pauses and background speech without waiting for rigid turn boundaries.
The API release adds telephony support. OpenAI's API reference shows incoming SIP sessions being accepted with gpt-live-1 as the model. The launch also includes native transcripts, response text, turn detection, keyword biasing and controls over tone, pace and conversational style.
OpenAI reports a 30 percentage-point improvement over GPT-Realtime-2.1 on its Full Duplex Bench and says GPT-Live-1 paired with GPT-6 Astra ranks first on Tau3. Those are vendor-reported results. They are useful reasons to evaluate the model, but they are not independent proof that it will outperform another architecture on a specific production workload.
Delegation separates conversation from deeper work
The more consequential change is that the voice model does not have to own the entire agent loop. OpenAI says developers can connect GPT-Live-1 to GPT-6 Astra, another OpenAI model or a third-party model for reasoning and tool use. Its launch example shows conversation context being passed to Codex and the answer being returned to the live session.
This creates a useful division of labor. A low-latency conversational model can decide when to listen, speak or hand work off, while another model handles tasks that need more reasoning or tools. Teams can choose different backend models for different jobs instead of tying the voice experience to one reasoning model.
It also creates at least two operational layers whose state can diverge. A user can interrupt or change direction while delegated work is still running. The live session has its own transport and conversation state, while the backend has separate task state, permissions and tool calls. The application has to define how those two lifecycles relate.
A voice interruption is not the same as cancelling an action
Aipolix's analysis is that delegation makes cancellation semantics a first-class safety and reliability requirement. In a turn-based chatbot, stopping generation often feels close to stopping the work. In a delegated voice architecture, stopping speech and stopping a backend action are different operations.
Consider a voice agent that begins booking a reservation, changing an account setting or asking a coding agent to modify a repository. If the user interrupts with "actually, don't do that," the front-end model can stop speaking immediately, but the application still needs an explicit rule for whether the delegated task should be cancelled, allowed to finish or paused for confirmation.
That rule should not live only in conversational wording. The backend action should carry an identity, scope and lifecycle that the application can reconcile with the latest user intent. Logs should connect a spoken request, the delegation it created, the backend model or agent that received it, the tools that ran and the final external effect.
This is especially important for long-running or side-effecting work. Full duplex improves the human experience precisely because conversation and work can overlap. That same overlap makes it easier for what the user is currently saying and what the system is currently doing to become different things.
Pricing becomes a two-layer calculation
The $0.05-per-minute price covers the front-end voice layer. OpenAI explicitly tells developers to pair it with the backend model and agent harness that fit the product. Cost per task therefore depends on conversation duration plus the reasoning, token and tool usage delegated behind it.
A cheaper backend may suit high-volume scheduling or order updates, while difficult support or coding tasks may justify a stronger model. The flexibility is useful, but a single headline voice price is an incomplete cost metric.
Teams should measure cost at the completed-task level, including front-end minutes, backend tokens, tool calls, retries and the frequency with which a conversation escalates to more expensive reasoning.
Safety inherits the split architecture
OpenAI's GPT-Live system card says the voice model has system-level safeguards and that delegated work receives the safeguards of the underlying model that performs it. The card also says GPT-Live models without delegation have constrained cybersecurity capability because they do not independently have broad tool access or code execution.
That distinction reinforces the architecture boundary. Risk is not determined only by the voice model. It depends on the backend it can delegate to, the tools available there and the application's authorization model.
For production voice agents, the practical control surface should span both layers: conversation policy in the live model, authorization and tool policy in the backend, and application-level state that connects a delegation to the user instruction that created it. A full-duplex interface can make an agent feel more immediate, but immediacy should not make delegated effects harder to inspect or stop.
GPT-Live-1's API release is therefore more than a voice-quality update. It gives developers a different composition model for agents: continuous conversation in front, swappable reasoning and tools behind it. The engineering opportunity is lower-latency, more natural interaction. The engineering obligation is to make delegation, cancellation, permissions, observability and cost just as explicit as the audio experience itself.