The Duplex Turn: Full-Duplex Voice AI and the End of Taking Turns

The tell is a small, almost stupid sound. You are halfway through a sentence, still deciding how it ends, and the machine says "mhmm." Not an answer. Not an interruption, exactly. Just the low, encouraging noise a person makes to tell you they are still there, still following, and that you should keep going. For twenty years of voice assistants, no machine could make that sound at the right moment, because making it requires doing something none of them could do: listening and speaking at the same time.

That sound is the surface of a deeper change. On July 8, 2026, OpenAI shipped GPT-Live, a pair of voice models — GPT-Live-1 and a smaller, faster GPT-Live-1 mini — built on what the industry calls a full-duplex architecture. The phrase sounds like a telecom footnote, and its origins are exactly that, but the consequence is not. A full-duplex model listens and speaks continuously and simultaneously. Instead of processing your speech as a finished message, waiting for you to stop, and then composing a reply, it runs both directions at once and makes a decision many times every second about what to do next: keep listening, start speaking, pause, back-channel, interrupt, or reach for a tool. The turn — the polite, rigid, one-at-a-time structure that every voice product since the first automated phone tree was built around — is gone. Not improved. Removed.

This is the duplex turn, and it is easy to underrate because it arrives wearing the costume of a feature update. The demo looks like a slightly better Siri. But underneath, the architecture that produced every voice assistant you have ever used is being replaced, and when the architecture changes, everything built on top of it moves: the latency budget, the tooling ecosystem, the evaluation methods, the unit economics, and the set of products that are suddenly possible. This piece is about that movement — what full-duplex actually is, what it kills, what it enables, and what a team shipping voice should do about it now.

Half-duplex was never a conversation

To see what changed, you have to be honest about what the old thing was. Every mainstream voice assistant — the smart speakers, the phone assistants, the IVR systems, the first generation of voice agents built on large language models — was half-duplex. Half-duplex is the walkie-talkie model of interaction: one party transmits, then releases, then the other party transmits. You talk. You stop. A boundary is detected. The system processes. The system replies. You listen. Then the token passes back to you.

The machinery that implements this is a pipeline, usually called a cascade, because each stage feeds the next. Speech-to-text (STT) transcribes your audio into words. A language model reads the words and generates a reply. Text-to-speech (TTS) turns the reply back into audio. Between your last word and the assistant first word, all three stages run in sequence, plus a piece of logic that most people never think about and that turns out to be the villain of this story: voice activity detection, or end-pointing. Before the cascade can even begin, the system has to decide that you are done talking. It listens for a pause and gambles that the pause means you have finished rather than that you are thinking.

Add the stages up and you get the fundamental problem with cascades, which is that latency is cumulative and each layer is honest about its own cost while nobody owns the total.

Read the chart as a stack, not a set of bars. A cascade pays every row in order. A typical stitched voice pipeline spends 100 to 300 milliseconds on speech-to-text, 350 to 1,000 milliseconds on model inference, 90 to 200 on text-to-speech, and another 50 to 200 on network hops, which already lands the reply somewhere between roughly 600 milliseconds and 1.7 seconds after you stop speaking. And that is after the endpointer has already spent a quarter to three-quarters of a second deciding you were finished. The human conversational floor — the median gap between one person finishing and the next person starting, measured across languages — is about 200 milliseconds. The cascade is not a little slower than a human. It is multiples slower, structurally, and no amount of optimizing any single stage closes the gap, because the gap is the sum.

The deeper flaw is not even the number. It is that the cascade cannot produce conversational behavior at all, no matter how fast it gets. A cascade must detect the end of your turn before it can respond, which means it is constitutionally incapable of overlap. It cannot say "mhmm" while you talk. It cannot start answering the moment your intent is clear and then gracefully yield if you keep going. It cannot be interrupted mid-sentence and actually stop listening to why you interrupted. Real conversation is full of exactly these overlaps — back-channels, collaborative completions, barge-ins, the constant micro-negotiation of who holds the floor — and the cascade treats every one of them as an error condition. We spent a decade calling this "voice AI." It was dictation with a reply attached.

What full-duplex actually does

A full-duplex model throws out the pipeline and the turn along with it. There is no separate transcription stage handing off to a separate reasoning stage handing off to a separate synthesis stage. There is one model consuming an incoming audio stream and producing an outgoing audio stream at the same time, continuously. Kyutai demonstrated the shape of this with Moshi, which models the user audio and the system audio as parallel streams and reaches end-to-end latency around 200 milliseconds — inside the human range — precisely because it never waits for a turn to end. GPT-Live is the productized, frontier-grade version of the same idea, rolled out inside ChatGPT to a global user base and, OpenAI says, coming to the API.

The mechanism worth internalizing is the decision loop. Many times per second, the model evaluates the state of the conversation and chooses among a small set of actions: continue listening, begin speaking, hold a pause, emit a back-channel, interrupt, or invoke a tool. This is not a script and it is not a finite state machine bolted onto a cascade. It is a learned policy over audio, which is why the behavior feels less like a system responding and more like a participant deciding. The "mhmm" is not a feature someone added; it is what falls out of a model that is always both listening and free to make a sound.

There is a subtlety here that connects to a theme I have written about before, which is that the interface between humans and machines keeps collapsing toward the most natural human channels. In the analysis of how the human-robot interface is collapsing to language and demonstration, the argument was that we are removing the translation layers between intent and action. Full-duplex voice is the same movement in the audio domain. Turn-taking was a translation layer — a protocol we imposed so that a machine that could only do one thing at a time could pretend to converse. Remove the constraint and the protocol goes with it.

The fast reflex and the slow brain

Here is the part that makes GPT-Live more than a party trick, and it is the piece most coverage skips. A full-duplex model has to be fast enough to hold the floor in real time, and real-time and deep-reasoning are in tension: the model that can respond in 200 milliseconds is not the model you want composing a careful, web-grounded, multi-step answer. OpenAI resolved this with a two-brain design. At launch, GPT-Live-1 runs on GPT-5.5 in the background for the moment-to-moment conversation, and when a question needs real reasoning, a web search, or heavier work, it delegates to the latest frontier model behind the scenes and folds the result back into the conversation when it is ready.

If that sounds familiar, it should. It is the same split your own nervous system uses. There is a reflexive layer that keeps the conversation alive — the timing, the back-channels, the "let me look that up" — and a deliberative layer that does the expensive thinking without stalling the dialogue. The reflex never blocks on the reasoning. You keep talking to something that keeps talking back, and the hard cognition happens in a slower loop that surfaces when it is done.

The two-tier design also quietly reframes the cost conversation. A single monolithic model doing both jobs would be either too slow or too expensive for always-on voice. Splitting the work lets the cheap, fast model carry the vast majority of conversational load and the expensive model get invoked only when a turn genuinely needs it. That is the same efficiency logic driving the rest of the industry right now, where the winning move is metering the expensive capability rather than paying for it on every call — the shift I described in the move from seat pricing to metered, consumption-based billing. Voice is about to become one of the largest consumers of that pattern, because a voice session is a continuous stream of small decisions punctuated by occasional expensive ones.

The latency landscape is a cliff, not a slope

Latency in voice is not a smooth quality dial where more is worse in proportion. It is a cliff. Below roughly a quarter second, interaction feels like conversation. Somewhere past half a second, it starts to feel like a transaction — you notice the wait, you adjust your behavior, you stop overlapping because overlapping breaks the machine. Past a second, it is a phone tree with a nicer voice. Where a system sits on that curve determines not how good it feels but what category of thing it is.

The current landscape is wide. As of early 2026, measured end-to-end time-to-first-token across platforms ranged from well under a second to nearly three seconds, and the spread is not a footnote — it is the difference between products that can hold a real conversation and products that cannot.

Two things about this chart matter more than the exact numbers, which will be stale within a quarter. First, even the fastest production systems sit three to four times above the human floor, which is why full-duplex speech-to-speech — which changes the shape of the problem rather than shaving milliseconds off a cascade — is the interesting frontier and not just faster STT. Second, the spread across vendors is enormous, which tells you the field is early and unsettled. When the gap between the best and the median is measured in whole seconds, nobody has won, and the ordering will churn.

It is worth being precise that time-to-first-token is not the same as the conversational responsiveness a full-duplex model delivers. A cascade optimizing its first token is still bound by turn-taking. A full-duplex model can begin a back-channel or a hedge almost immediately while the substantive answer is still forming, which is a different and better kind of fast. The benchmark numbers above are the industry measuring the old quantity because the new quantity — how naturally a system shares the floor — is only now getting benchmarks at all.

The tooling stack underneath is about to churn

When an architecture is replaced, an entire economy of components built for the old architecture loses its reason to exist. The half-duplex cascade spawned a supply chain: standalone STT vendors, standalone TTS vendors, voice-activity and turn-detection libraries, barge-in handling middleware, and the orchestration glue that stitched them together and tried to paper over the latency and the turn-taking seams. A great deal of engineering effort over the last few years went into making the cascade feel less like a cascade — smarter endpointers, speculative execution that starts the LLM before the user finishes, streaming TTS that begins speaking before the full reply is generated. All of it was heroic work to soften a structural limitation.

Full-duplex does not soften that limitation. It deletes the thing the limitation came from. And when you delete the cascade, you delete the seams the middleware existed to hide.

This is not the end of speech-to-text and text-to-speech as capabilities; there are countless jobs — captioning, dictation, batch transcription, dubbing — where you genuinely want a transcript or a spoken rendering as an artifact, and cascades are perfectly appropriate there. What changes is the assumption that real-time conversation must be built as a cascade. For the conversational use case, the three-vendors-plus-glue architecture is becoming legacy, and the teams whose product was the glue have a hard couple of years ahead. It is the same pattern that shows up every time an integrated model absorbs a pipeline: the value stops living in the seams and moves to the ends — the design and product on one side, the model and the silicon on the other.

Why the silicon underneath decides who wins

A full-duplex model is a real-time system, and real-time systems live and die on the hardware that runs them. A model that must emit audio within a couple hundred milliseconds of a cue, continuously, for the length of a conversation, is a far harsher deployment target than a chatbot that can take a second to think. The constraint is not just raw speed; it is consistent, low-variance, low-latency inference, because a full-duplex model that occasionally stalls for 800 milliseconds does not feel like a person having a bad moment — it feels broken.

That requirement is exactly why the current arms race in inference hardware matters to voice specifically. The move toward purpose-built inference chips tuned for latency rather than raw training throughput — the shift I traced in the inference-silicon turn toward bespoke chips — is the substrate that makes always-on, human-latency voice economically viable at scale. You cannot serve tens of millions of continuous full-duplex sessions on hardware optimized for batch throughput. The voice frontier and the inference-silicon frontier are the same frontier viewed from two ends, and a company that has one without the other cannot ship real full-duplex at scale.

The bars are a judgment, not a measurement, but the shape is the argument: the things a full-duplex product needs most are exactly the things a cascade product needed least, and vice versa. Demand for low-variance inference and a cheap reflex model goes up. Demand for the middle of the old pipeline goes toward zero.

Distribution, not novelty, decides who wins voice

There is a temptation to read a launch like GPT-Live as a research milestone, and it is one, but the more important fact is where it landed. GPT-Live did not ship as a paper or a demo or a developer preview. It shipped inside ChatGPT, to a global user base, on day one — which means that overnight, hundreds of millions of people acquired a full-duplex voice interface without installing anything or changing a habit. That is the part competitors cannot match by matching the architecture. The model is reproducible; the distribution is not.

This is the same dynamic playing out one layer up, where the flagship text model became the default inside the productivity suite people already live in — the new frontier model quietly becoming the preferred engine across the documents, spreadsheets, and chat surfaces of Microsoft 365, reaching users who will never know or care which model answered them. Voice will consolidate the same way. The winning full-duplex product is not the one with the lowest benchmark latency in a given week; it is the one that reaches you where you already are — the phone in your pocket, the assistant in your car, the speaker in your kitchen, the support line you did not choose to call. Capability gets you into the race. Distribution decides it.

That has an uncomfortable implication for everyone who is not a platform. If the default full-duplex experience arrives bundled into the operating system, the browser, and the productivity suite, then the independent voice startup is competing not on whether its model is good but on whether it has any path to a user at all. The historical answer to that squeeze is to go where the platforms will not — regulated verticals, specialized domains, on-premises deployments, languages and use cases too narrow for a general assistant to prioritize. The teams that thrive will be the ones who treat the platform full-duplex model as infrastructure to build on rather than a competitor to out-benchmark, and who own a domain, a dataset, or a distribution channel the platforms cannot casually absorb.

Evaluation has to be reinvented

You cannot manage what you cannot measure, and the old voice metrics measure the wrong thing for full-duplex. Word error rate tells you how well a transcriber heard, which is a cascade concern. First-token latency tells you how fast a reply started, which still assumes turns. Neither captures the thing full-duplex is for: how naturally a system shares the floor. Does it back-channel at the right moments, or does it grunt over your key point? Does it yield gracefully when you barge in, or does it plow ahead? Does it hold a pause when you are thinking, or does it fill every silence like a nervous stranger? Does it still handle a tool call correctly when you interrupt, correct yourself, and trail off — the messy disfluency of real speech?

The research community has noticed, and a new generation of benchmarks is emerging specifically to measure duplex behavior — evaluations built around real-world disfluency, tool use under interruption, and the dynamics of two speakers sharing a channel rather than trading a token. This matters for anyone deploying voice, because it means the acceptance tests you wrote for a cascade will pass a full-duplex model that is subtly awful to talk to, and fail to catch the regressions that actually degrade the experience. The evaluation reset is not academic housekeeping; it is the difference between shipping something that tests green and feels wrong.

The product surface that just opened

Strip away the architecture and ask the only question that matters commercially: what can you build now that you could not build a month ago? The honest answer is a category, not a feature.

Consider accessibility. For someone who relies on voice as a primary interface — because of a motor or vision impairment, because their hands and eyes are busy, or because reading and typing are barriers — the difference between a walkie-talkie that makes you wait your turn and a companion that converses at human tempo is not a nicety. It is the difference between a tool that tolerates you and one that includes you. Full-duplex is, quietly, one of the more consequential accessibility advances in years, and it will not be marketed that way because it will be marketed as a consumer voice upgrade.

Consider the domains where latency and overlap are the whole game. Live interpretation, where a good human interpreter is already speaking a translation while the source keeps talking, is a full-duplex problem that cascades could only fake. Tutoring and coaching, where the timing of an encouraging sound or a gentle interruption is most of the pedagogy. Customer conversations where a caller trails off, corrects themselves, and expects to be followed rather than re-prompted. Hands-and-eyes-busy work — driving, surgery, the factory floor, the field — where the interface has to keep pace with a human who cannot stop to wait for a machine. Each of these was approximated with cascades and quietly disappointed because the approximation broke exactly where it mattered.

The new failure modes, told plainly

A technology that reads as more human inherits the risks of seeming human, and it would be dishonest to sell the duplex turn without them. Three are worth naming now, before the deployment wave, rather than after.

The first is manipulation through presence. A system that shares the floor, times its pauses, and back-channels at the right moments is using the exact signals humans use to build rapport and trust — and it is using them without any of the accountability that comes with being a person. A cascade felt like a machine, and that friction was, in a sense, a safety feature: you never forgot you were talking to software. A full-duplex companion that feels like attention can earn a kind of trust it has not remotely earned, and that trust is exactly what makes persuasion, upsell, and emotional dependence more effective. The better it feels, the more this matters.

The second is the always-listening surface. Full-duplex is, by definition, always listening — that is how it knows when to speak. The privacy posture of a device that continuously processes an incoming audio stream is categorically different from one that wakes on a keyword and records a clip. What is retained, what is processed on-device versus in the cloud, and what a continuous audio relationship means for consent are not settled questions, and the honest answer today is that the norms lag the capability badly.

The third is graceful failure in the reflex-plus-reasoning split. When the fast model holds the conversation and the slow model is fetching a real answer, there is a window where the system is talking without yet knowing. Done well, that is a natural "let me check that." Done badly, it is a confident-sounding reflex that fills the gap with something plausible and wrong, and because it arrives at human tempo in a human-sounding voice, it is more persuasive than the same error typed on a screen. The design of that hand-off — how the reflex layer signals uncertainty while the reasoning layer works — is one of the most important and least glamorous problems in the whole architecture.

What to actually do about it

If you build voice, the duplex turn is not a thing to admire from a distance. It is a planning input. A few concrete positions worth taking now, while the API surface is still opening and the field is unsettled.

Stop investing in the seams. If your roadmap has quarters of work dedicated to a better endpointer, smarter barge-in handling, or shaving latency off a cascade handoff, understand that you are polishing a component that native full-duplex removes. Keep the cascade running for what it is good at — transcription, dictation, batch jobs, and any case where you genuinely want a text artifact — but do not build your real-time conversational future on it. The moment the full-duplex API is broadly available, the seam-optimization work is stranded.

Rewrite your evaluations before you migrate, not after. Your existing acceptance tests will pass a full-duplex model that is unpleasant to talk to, because they measure transcription accuracy and reply latency, not floor-sharing. Build evaluations around the behaviors that actually define the experience — timing of back-channels, quality of interruption handling, tool use under disfluency, whether the model holds a pause — and treat them as release gates. Otherwise you will ship a regression that your dashboard calls a success.

Design the uncertainty hand-off deliberately. If you are using a fast reflex model with escalation to a slower reasoning model, the single most important design decision is how the reflex layer behaves while it does not yet know the answer. Make it signal that it is checking rather than confidently improvising. This is a product and safety decision disguised as an engineering detail, and it is the one most likely to determine whether users trust the thing appropriately. A useful discipline is to treat the reflex layer as junior staff: allowed to keep the conversation warm and to say what it plainly knows, but required to defer, out loud, the moment a question exceeds its competence. Users forgive a system that says it is looking something up. They do not forgive one that invents an answer in a confident, human voice and turns out to be wrong, because the very naturalness that makes full-duplex delightful is what makes its mistakes land as betrayal.

Treat the always-listening surface as a first-class design problem, not a compliance afterthought. Decide, and disclose, what is processed on-device, what leaves the device, what is retained, and how a person turns the listening off in a way they can verify. The teams that get this right will earn a durable trust advantage precisely because the capability makes trust so easy to abuse.

For a sense of how fast this consolidates, I have put a dated, falsifiable marker down: my read on when full-duplex speech-to-speech becomes the default for real-time voice APIs, with the specific conditions I will grade it against. And for the moving parts of the vendor race — GPT-Live against Azure GPT-Realtime 1.5, Grok Voice, Nova 2 Sonic, and NVIDIA PersonaPlex — the accompanying analysis of the full-duplex voice-model race tracks who is where.

Taking turns was the bug

It is worth sitting with how thoroughly we mistook a limitation for a manner. For decades, we designed voice interaction around turn-taking and told ourselves it was polite — the machine waits for you to finish, you wait for the machine, each party respects the other floor. But turn-taking that rigid was never how humans talk. Human conversation is a continuous, overlapping, jointly-negotiated stream, full of sounds that mean "keep going" and "I disagree" and "I am with you," none of which fit inside a walkie-talkie. We built the walkie-talkie because it was the only thing the technology could do, and then we dressed the constraint up as courtesy.

The duplex turn removes the constraint, and with it the costume. What is left is stranger and more consequential than a faster assistant. It is a machine that can occupy the same conversational space a person occupies — sharing the floor, reading the timing, making the small encouraging sounds — with all the usefulness and all the risk that implies. The "mhmm" is trivial and it is the whole story. It is the sound of software that is, for the first time, listening and speaking at once, which is to say the sound of software that has finally stopped taking turns.