Voice AI can delegate mid-call now. Log who's holding the baton.

A customer calls in about a billing error. Twenty seconds into the explanation, she stops mid-sentence to check something on her phone. The old voice bot would have filled that silence with "Are you still there?" and made her start over. This one doesn't. It waits, says a soft "mhmm," and keeps the line open. While she's looking, it has already sent her account number and the disputed charge to a more capable model running in the background, asking it to check for a known billing bug and draft a plain-English explanation. She looks up, finishes her sentence, and the voice picks up as if it never stopped listening. Two seconds later, a card appears on her screen showing the corrected charge.

Nothing about that exchange sounds like a problem. It sounds like the call finally working the way a call should. That's exactly what makes it worth pausing on. Somewhere in those twenty seconds, the system made four decisions on its own: that the silence was thinking and not a hang-up, that the question was hard enough to hand off, that the handoff had come back in time to fold into the reply, and that a card was the right way to close it out. If that customer later disputes the corrected amount, or if the background model gets the billing rule wrong, someone is going to ask what the voice agent actually did during that pause. The honest answer, right now, is a transcript of words and not much else.

What shipped, and what it assumes

On July 8, OpenAI introduced GPT-Live, a new family of voice models (GPT-Live-1 and a smaller GPT-Live-1 mini) rolling out globally inside ChatGPT Voice, with API access planned. Reuters confirmed the launch the same day, describing the core capability plainly: a voice model that can listen and speak at the same time, in real time, rather than trading turns.

That full-duplex design is the whole story here, more than any voice-quality improvement. A conventional voice assistant works like a walkie-talkie: it waits for you to stop, processes what you said, then replies. GPT-Live is built to run both channels continuously, the way a person on a phone call does. OpenAI's announcement describes it holding attention with a quick "mhmm" or "yeah," engaging in fast back-and-forth, or going quiet while someone thinks something through. It decides, turn by turn, whether a pause means I'm done or give me a second.

The second piece matters just as much. When a question needs a web search, harder reasoning, or more involved work, GPT-Live doesn't try to do it itself mid-sentence. It delegates to a frontier model running behind the scenes (GPT-5.5 at launch) and brings the answer back into the conversation once it's ready, sometimes as speech, sometimes as one of the new visual cards the update adds for things like weather, stocks, or sports scores. OpenAI says more than 150 million people already use ChatGPT Voice and Dictation every week, so this isn't a lab demo finding an audience later. It's a live upgrade to a channel with an existing user base the size of a mid-sized country, on day one. The company also flagged what isn't there yet: no voice with video or screen sharing in ChatGPT at launch.

Put those two pieces together and the shape of the change becomes clear. Voice AI stops being a single model answering a single question and becomes a small system managing a live conversation: one layer that stays present and responsive, handing pieces of the actual thinking to another layer that isn't in the room.

The part that isn't in the launch post

OpenAI didn't ship this without a safety layer, and it's worth reading past the announcement to the GPT-Live system card, published the same day. It describes the same full-duplex behavior: following pauses, interruptions, and changes in pace, deciding in the moment whether to respond or keep listening. Then it describes what happens when the conversation goes somewhere risky. The system can steer or interrupt a response mid-stream, play a spoken safety message, surface a text resource, or end the voice conversation outright in higher-risk cases. That monitoring runs continuously, checking inputs and generated outputs as the exchange unfolds, using the same review infrastructure OpenAI applies to text models.

The card is also direct about delegation carrying its own inheritance rule: when GPT-Live hands work to another model, the resulting output reflects that model's own safety training, not GPT-Live's. The scores it publishes back that up. On production prompts, GPT-Live-1 improved illicit-behavior handling from 0.74 to 0.97 and self-harm handling from 0.89 to 0.96; on synthetic prompts built to stress-test edge cases, self-harm rose from 0.72 to 0.98 and mental-health handling from 0.57 to 0.84. One number moved the wrong way — emotional-reliance handling slipped from 0.88 to 0.82 — though OpenAI says that shift wasn't statistically significant. Separately, OpenAI's Safety Advisory Group concluded that GPT-Live-1 and mini, without delegation, don't reach High risk in the biological, self-improvement, or cybersecurity categories it tracks. For delegated work in those areas, the safeguards belong to whichever model actually did the work. GPT-Live itself doesn't have broad independent tool access or code execution at launch. OpenAI says it plans to reassess those safeguards before opening that door further.

Read that whole document and a pattern emerges that the launch post doesn't spell out. OpenAI built GPT-Live to make its own decisions, in real time, about when to keep talking, when to go quiet, when to call for backup, and when to stop the conversation entirely. That's a genuinely useful design. It's also a system with several independent decision points happening inside a single phone call, and each one is a place things can go right or wrong.

A transcript answers the wrong question

Both documents assume the call goes well. The gap only shows up once you imagine it going sideways.

Say the customer from the opening scene calls back a week later, unhappy that the corrected charge didn't match what she was quoted. Or say a different call, on a harder topic, gets interrupted by the safety layer partway through, and the system plays a spoken safety message and ends the session. In either case, someone on the operations side is going to be asked to explain what happened, and a transcript of what was said won't answer it. A transcript tells you what was said. It does not tell you who was holding the conversation at each moment, or why.

Was the model quiet because it was listening, or because it had handed the question off and was waiting on a result? Did the customer's pause get read as consent to keep going, or as a request to stop? What did the background model actually receive, and what did it send back: the full account record, or just the disputed line item? That's not a hypothetical. It's a data handling question, and right now it's answered by trust in the system rather than a record anyone can point to. Did the visual card match what was said aloud, or fill in a gap the spoken answer left open? If the safety layer intervened, was that a judgment call worth reviewing, or a hard stop that worked exactly as designed?

None of those questions live in an audio recording. They live in the handoffs between one system component and another, in the moments the conversation quietly changed hands. Call center teams already know this problem from human agents. A good phone system doesn't just record the call; it timestamps holds, transfers, and escalations, because that's where disputes actually get resolved. Full-duplex, delegating voice AI reintroduces the same structure, just faster and less visible, because the "transfer" now happens inside a single continuous-sounding exchange instead of an audible click and a new voice.

The conversation baton log

The fix isn't a better transcript. It's a record of custody: who or what was holding the conversation at each point, and what happened when it changed hands. That's the same discipline behind workflow controls for any AI system that acts on its own between two human checkpoints, applied here to a conversation instead of a task queue. Call it a conversation baton log, and build it around eight fields.

A voice session without a named owner (row one) is a voice session nobody will step up to explain later. Baton state (row two) is the field a transcript can't reconstruct on its own — full-duplex behavior means the system can be doing more than one of these at once, listening while a delegated task runs in the background, so the log has to capture that overlap, not just a single state per turn. And the delegated-task row has to record what was actually sent and returned, not just that a handoff happened: "checked billing system, returned corrected amount" is a record; "delegated to background model" is not.

None of these fields require slowing the conversation down. They require deciding, before a live voice agent goes anywhere near a real customer or employee, that every handoff it makes will leave a mark.

Where this fits with the rest of the shift

This is the voice-specific version of a pattern we've been tracking as AI features generally move from single calls to ongoing work with state and delegation, the same shift we covered when Gemini's Interactions API turned single calls into trackable jobs. Voice adds something text-based delegation doesn't have to deal with: the handoff happens inside a conversation that sounds continuous and personal, which makes it easy to forget a handoff happened at all.

It also sits next to two boundary problems we've written about that get sharper once a voice layer starts delegating on its own. The call rehearsal card is about walking through one call before it happens, so identity checks and clinical boundaries aren't left to improvisation. This is the companion piece for after the call: what got recorded once the model started making its own decisions about when to keep listening and when to reach for help. And the reason an AI support bot shouldn't reset credentials unsupervised applies just as directly here. A voice agent that can delegate reasoning mid-call is one step from delegating action mid-call, and the stop rule has to be decided before that step gets taken, not discovered afterward.

Full-duplex voice AI is a genuine improvement. Waiting on hold for the model to finish thinking was never good design, and a system that can listen while it works is closer to how a competent human assistant actually behaves. The part worth getting right before rollout isn't the voice quality. It's making sure that when the conversation quietly changes hands, somebody can still say, with evidence, exactly who was holding it.

If you're putting a live, delegating voice model in front of real customers or employees, bring the workflow before you bring the transcript. BaristaLabs will help you define the baton states, the delegation record, and the stop rule while it's still a design question, not after the first disputed call.