Half-Duplex Is Dead. GPT-Live-1 Won the Turn-Taking War at $0.05 a Minute

Half-Duplex Is Dead. GPT-Live-1 Won the Turn-Taking War at $0.05 a Minute

OpenAI's full-duplex voice API nearly doubles the interactivity score to 80.1% and prices by the minute. Here's where that math works — and where it quietly doesn't.

The single hardest problem in voice interfaces was never transcription. It was knowing when to shut up. Every voice product for fifteen years has re-solved the same thing — how to let a human interrupt the machine mid-sentence without the whole exchange collapsing into cross-talk — and every time we’ve called the fix something new. GPT-Live-1 is the latest name for it. This one comes with a price tag stapled to the front, which is the actually interesting part.

The beats that got us here

Roughly 2011–2018 — push-to-talk and the tyranny of the endpoint. Siri, Alexa, the first IVR bots. You spoke, a voice-activity detector guessed you were done, and the system took its turn. Interrupt it and you got garbage. This was half-duplex: one party transmits at a time, like a walkie-talkie. Nobody called it that in the marketing. Everybody who built it knew that’s what it was.

2023–2024 — the streaming era and the barge-in patch. Realtime speech-to-speech models arrived and latency dropped from seconds to a few hundred milliseconds. Good enough to feel like a conversation, right up until you tried to cut the model off. The workaround was a pipeline of hacks: run VAD on the input, cancel the model’s audio buffer when you detected speech, hope the timing lined up. It worked in demos. It fell apart the moment a caller said “no, wait—” over the top of the bot.

This week — GPT-Live-1 ships full-duplex as a production API. Both directions open at once. The model talks and listens on the same connection, simultaneously, the way two people on a phone do. No buffer-cancellation dance, no VAD guesswork bolted on the side. That’s the engineering claim, and it’s the right one to have finally made.

The number OpenAI is leaning on: 80.1% on its interactivity test, up from 45.4% for the predecessor. Nearly double. OpenAI hasn’t published the methodology in any detail I’d stake a deployment on, so treat 80.1 as a vendor’s own scorecard measuring vendor-defined interactivity — meaning turn-taking, interruption handling, overlap recovery. The jump is real and it tracks with what full-duplex should buy you. It is not a promise that your call-center bot stops talking over grandmothers. Test that yourself.

The meter is the story

$0.05 per minute. Flat, per minute of connection, and that’s the line item that will decide your architecture faster than any benchmark. Run it:

  • A 10-second voice command — “set a timer, what’s the weather” — costs about 0.8 cents. Trivial. Ship it.
  • A 10-minute support call is $0.50. Now multiply. A thousand of those a day is $500/day, roughly $15,000 a month, before you’ve added your LLM reasoning, telephony, or a human fallback tier.
  • A bot that sits on an open line waiting — kiosk, always-listening assistant, a call on hold — bills for silence. The meter doesn’t care that nobody’s talking.

So the design rule writes itself. Full-duplex earns its keep when the interruption is the product: live support, real-time coaching, language practice, anything where a person cutting in mid-sentence is the whole point. It’s a waste when the interaction is a short command or an exchange that tolerates a beat of latency. If a caller can wait 800ms for a reply, you don’t need a persistent bidirectional socket — a streaming turn-based call is cheaper and you’re not paying for dead air. Async is not dead. Async just got a competitor with a taxi meter.

What the integration actually looks like

It’s a persistent bidirectional connection — a WebSocket or WebRTC session — with audio flowing both ways as events, not an HTTP request you await. The shape, generically, before you check the current event names in the docs:

snippet.pyPython
import websockets, json, asyncio
​
async def live_session(url, headers, mic_frames):
    async with websockets.connect(url, extra_headers=headers) as ws:
        async def send_audio():
            async for frame in mic_frames:          # your mic capture loop
                await ws.send(json.dumps({
                    "type": "input_audio.append",   # confirm exact name in docs
                    "audio": frame,                 # base64 PCM
                }))
​
        async def recv_audio():
            async for msg in ws:                    # model audio arrives WHILE you send
                event = json.loads(msg)
                if event["type"] == "output_audio.delta":
                    play(event["audio"])            # and it can be cut off mid-stream
​
        await asyncio.gather(send_audio(), recv_audio())

The mental shift is that send and recv run concurrently for the life of the call. There’s no “now it’s my turn.” That’s the entire point, and it’s also the part that will bite you in six months — every minute that socket is open is a nickel, so idle-timeout logic and a hard session cap belong in v1, not v2.

Next beat on the calendar: OpenAI publishes the interactivity methodology, or it doesn’t. Watch which. A benchmark you can’t reproduce is a marketing asset; a benchmark you can is a spec. The meter, meanwhile, is running whether they explain the score or not.

Related Post