You want your voice assistant to book a flight. You just said the departure and destination cities, and the phone screen starts spinning. For the next dozen seconds, you stare at the loading animation, afraid to make a sound. You’re waiting, and it’s waiting too. It’s searching for flights and comparing prices in the background, but all you can do is wait.
Now, with the new ChatGPT voice mode, the experience feels completely different. When you speak, it responds with “uh-huh” or “right.” You can interrupt it at any time. When you want to hear a complex travel plan, it doesn’t pause to wait. It keeps chatting with you while delegating heavy research to a large model in the background. Once the results come in, it naturally weaves the new information into the conversation.
The ability to listen and speak at the same time is technically called full-duplex communication. This feature went live on July 8, 2026. It’s powered by a new model called GPT-Live. According to OpenAI’s official introduction, it now supports ChatGPT’s voice mode.
You can experience it on mobile or web. It supports mobile clients (iOS, Android) and ChatGPT.com web. Go, Plus, and Pro subscribers can use GPT-Live-1. Free users get the lightweight GPT-Live-1 mini. Business, Enterprise, and Edu accounts don’t have access yet.
When you chat with it, you’ll notice clear role separation. The voice layer responsible for talking to you focuses solely on fluid conversation. Complex tasks like web search, computation, or deep reasoning are handled by GPT-5.5 in the background.
Many developers want to integrate this capability into their products. But OpenAI hasn’t opened the API yet. The official word is only that it’s coming soon.
Every time a new product launches, people tend to think there’s been a major technical breakthrough. Some assume GPT-Live is a direct upgrade of the Realtime API. In reality, they’re completely independent. In fact, many of the technologies used in this product have already been applied across the industry.
First, full-duplex. This isn’t a new invention. Academia proved this approach works long ago. The open-source organization Kyutai released the Moshi model in September 2024. Related findings can be found in the Moshi paper. This model demonstrated the feasibility of dual-stream parallel token generation.
On the product side, Google previously launched Gemini Live. ByteDance also released the Doubao Seeduplex voice interaction system. Both can listen and speak simultaneously. GPT-Live has scaled this model to hundreds of millions of users, but the underlying principles haven’t changed.
Next, end-to-end audio. This isn’t new technology either. GPT-4o could already directly input and output audio. It didn’t need text as an intermediary. The official System Card classifies GPT-4o’s previous voice mode as turn-based, and notes that GPT-Live aims to transcend this turn-based approach. This indicates that GPT-Live upgraded the interaction from half-duplex to full-duplex. This upgrade didn’t come from a new breakthrough in end-to-end technology.
Finally, tool calling. The Realtime API has supported this for a while. It launched in 2024, with function calling as a standard feature. Developers can attach tools for the voice model to call directly within a session. This is the mainstream approach for building voice agents today. The latest gpt-realtime-2.1 was released in June 2026 — details in the Realtime API gpt-realtime-2.1 documentation. But tool calling has been supported since 2024.
If none of these features are new, where’s the real pain point for developers?
When building a voice agent with the Realtime API, the bottleneck is the model’s reasoning capability. If the voice model handles tool calling and reasoning on its own, its performance is usually poor. Its intelligence level is roughly equivalent to GPT-3.5 or GPT-4 — barely sufficient for complex tasks.
To solve this, developers typically adopt a layered architecture. GPT-5 in the background handles reasoning and tool calling. The Realtime API in the front serves only as an interaction shell.
This approach achieves an architecture where the interaction layer is separated from the work layer. GPT-Live’s delegation mechanism didn’t come from OpenAI discovering a new need. The company saw developers manually building this architecture everywhere and simply made it the platform’s default.
If none of these features are new, what did GPT-Live actually bring?
The answer is the delegation architecture. In real-world use, this design makes a noticeable difference.
When a user asks a question requiring web search or complex reasoning, traditional voice models immediately go silent. They must wait for background retrieval and reasoning to finish before speaking again. This leads to long wait times.
In GPT-Live, the voice layer and the work layer are completely decoupled. After a question is asked, the voice layer delegates the task to the background and continues interacting with the user. The voice layer isn’t just offering meaningless filler — it’s an independent interaction layer. Once background computation finishes, the voice layer integrates the results into the conversation and speaks them naturally.
The key is that the background can run multiple tasks simultaneously. OpenAI explicitly states that GPT-Live can manage multiple background tasks at once. You can have it search flights, calculate exchange rates, and discuss your itinerary — all at the same time. The voice layer just handles interaction; heavy lifting gets delegated out. Background tasks process in parallel, and results come back in batches. For more details on this mechanism, see the marktechpost report.
This is delegation. Talking handles talking, working handles working — the two are completely separated.
This solves the traditional voice interaction dilemma where
responsiveness and reasoning depth are hard to reconcile. This
phenomenon was previously known as the latency paradox. The deeper the
model reasons, the slower it opens its mouth to respond. Developers
could only adjust the reasoning_effort parameter before.
Users also constantly faced the trade-off between “fast but simple” and
“slow but smart.”
Now, GPT-Live changes the rules. It doesn’t ask users to choose between the two — it solves the problem through role specialization. One role handles interaction, the other handles computation.
The architecture comparison diagram shows how voice systems evolved from the traditional three-stage pipeline to the delegation architecture:
It should be noted that GPT-Live itself has limited intelligence. The official System Card notes that GPT-Live-1 and mini underperform GPT-5.5 Thinking across multiple evaluations.
It primarily serves as an interaction shell, with deep reasoning still provided by the large model in the background. What this model changes is the programming model — it doesn’t raise the intelligence ceiling of the voice model itself. It takes the layered logic developers previously built by hand and turns it directly into the platform foundation.
This also introduces a core difference for developers.
With the Realtime API, tool calling is fully controlled by the developer. Developers decide which tools to provide and how long to wait.
But in GPT-Live, tool calling is encapsulated within the official delegation system. Tools run inside ChatGPT’s black box. Developers can’t hook into it or observe how data flows. This defines the boundary between hand-built voice agents and the official voice product.
OpenAI hasn’t disclosed the underlying details. But by referencing academic approaches, we can roughly infer how it works.
First, the model’s ability to listen and speak simultaneously comes from a dual-stream parallel token generation scheme. At each timestep, the model simultaneously predicts its own output and the user’s input.
This means interactions like interruptions, turn-taking, or filler words don’t require a fixed state machine to orchestrate. These interactions emerge naturally during the token generation process.
The open-source Moshi model offers a reference. Its Mimi codec runs at a frame rate of 12.5Hz. This means it generates one audio frame every 80ms, with latency around 200ms. GPT-Live’s implementation likely follows a similar approach.
Under this design, the voice model continuously makes high-frequency sequential decisions. When generating each audio frame, it evaluates the current state in real time: whether to stay silent, produce a filler word, or trigger a delegation.
Once delegation is triggered, foreground and background tasks run asynchronously.
The model running in the background is GPT-5.5. The official offering includes three reasoning tiers: Instant, Medium, and High. The Medium and High tiers call GPT-5.5 Thinking.
While the background handles retrieval or computation, the foreground voice model continues conversing with the user. When the background finishes computation and returns results, the data is incorporated into the foreground model’s generation probabilities. The voice model then speaks it out naturally.
On the technical details, the voice model itself doesn’t have tool calling or code execution capabilities. The official System Card explicitly states that the voice model has no independent tool access and no code execution capability.
This also indicates that the voice model itself has a relatively simple structure. It doesn’t directly orchestrate tools or run code — all complex computation is handled by the background model.
Regarding tool availability plans, the System Card mentions that cybersecurity protections will be re-evaluated before new tools are opened up.
This means even if the API becomes available in the future, its tool capabilities will be rolled out in phases.
The programming paradigm shift diagram shows the contrast between developers’ hand-built architecture and the official native delegation architecture:
Facing these changes, voice application developers can plan along three directions.
First, for the short term, continue using the existing Realtime API.
The Realtime API remains the workhorse for building voice agents today. Its latest version, gpt-realtime-2.1 — details in the Realtime API gpt-realtime-2.1 documentation. These turn-based models are stable and support full control over function calling.
Here are the pricing details for gpt-realtime-2.1 per million tokens: Text input $4.00, text output $24.00. Audio input $32.00, audio output $64.00.
The lightweight gpt-realtime-2.1-mini model pricing per million tokens: Text input $0.60, text output $2.40. Audio input $10.00, audio output $20.00.
These API models are parallel products to GPT-Live, not replacements. Developers can continue using them in production.
Second, keep an eye on the GPT-Live API registration channel.
Developers can apply for testing access through the API registration form. Once the GPT-Live API opens, full-duplex and delegation will become core capabilities. At that point, two key questions remain:
First, whether the official side will allow custom external tools to be mounted in the delegation layer. Second, how much control developers will have over this delegation black box. These factors will determine whether applications can only serve as interaction skins or can go deeper into business logic.
Third, re-evaluate the architectural positioning of voice products.
The approach of stitching GPT-5 together with the Realtime API will be replaced by platform-native delegation.
Developers need to identify their core value early. Which heavy orchestration work can be offloaded to the platform to reduce latency and cost? Which core capabilities are irreplaceable by the platform? Such as proprietary toolchains, or domain-specific knowledge orchestration. These core advantages must be firmly held.
Additionally, the combination of full-duplex and delegation opens up entirely new application scenarios.
For example, companion-style voice becomes possible. While long background tasks run for minutes, the foreground voice model can continuously report progress. During reporting, users can interrupt at any time and adjust the search direction. This bidirectional flow breaks the traditional “ask, wait, answer” one-way turn-based pattern.
GPT-Live didn’t bring a breakthrough in model intelligence — it brought structural clarity to voice computing.
The core change is that it separates the interaction layer responsible for talking from the reasoning layer responsible for working. Previously, the industry tended to use a single model for both types of tasks, leading to the latency paradox.
Full-duplex, which supports simultaneous listening and speaking, does improve the interaction experience. But from a technical standpoint, there’s no fundamental breakthrough underneath.
GPT-Live’s true contribution lies in its delegation architecture. It takes the layered design developers built by hand and turns it directly into the platform’s native default capability.
For voice application developers, this validates the correctness of the layered design approach. Their prior engineering intuition and architectural choices have been confirmed at the platform level.
Currently, continuing to use the Realtime API to move business forward remains the prudent choice. It offers better cost efficiency and full autonomy. At the same time, developers should closely monitor the evolving GPT-Live developer ecosystem. Prepare early for the era of native full-duplex delegation.