Half-Duplex Agent

Half-duplex agents are voice AI systems that transmit in only one direction at a time: while the agent is speaking, it is effectively deaf to new input except for interruption cues; while the user is speaking, the agent stays silent and waits for an end-of-turn signal before it responds. It’s the walkie-talkie model of conversation, and it has been the default architecture for voice assistants since the earliest IVR systems.

It sits opposite full-duplex, where both sides can transmit and receive at once — overlapping speech, real backchannels (“mm-hmm” while the other party keeps talking), and instant reaction to a mid-sentence interruption. Most production voice agents shipped through 2025 and into 2026 are half-duplex with barge-in: strict turns, but the user is allowed to cut the agent off mid-sentence.

The Half-Duplex Stack

A half-duplex agent is built from several sub-tasks running in sequence:

1. Mic capture + Voice Activity Detection (VAD): mechanically segments incoming audio into speech vs. silence, running even while the agent talks, purely to catch a barge-in.
2. Streaming speech-to-text: partial transcripts arrive as the user talks, feeding the endpointing model in real time.
3. Endpointing / turn detection: a classifier judges semantic completeness — not just trailing silence — to decide the user is actually done, so the agent doesn’t jump in on a mid-sentence pause.
4. LLM / dialogue manager: generates the response once, and only once, the turn is confirmed to have ended.
5. Text-to-speech playback: the agent transmits alone; new user speech is only acted on as a barge-in interrupt, not as a new turn.

graph TD
    classDef default fill:#ffffff,stroke:#4338CA,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef data fill:#EEF0F7,stroke:#0D9488,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef process fill:#F7F8FC,stroke:#6366F1,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef output fill:#4338CA,stroke:#4338CA,stroke-width:2px,color:#ffffff,rx:8px,ry:8px;

    A([Mic Input + VAD]):::data --> B(Streaming Speech-to-Text):::process
    B -->|Partial transcript| C(Endpointing: Is the Turn Over?):::process
    C -->|Turn confirmed| D(LLM / Dialogue Manager):::process
    D --> E(Text-to-Speech):::process
    E --> F([Speaker Output, Channel Closed to New Turns]):::output

Endpointing: How the Agent Knows You’re Done

The weakest link in a half-duplex system is deciding when the user has finished talking. Older systems used pure silence-timeout VAD — wait N milliseconds of quiet, then respond — which is simple but slow, and wrongly fires on natural mid-sentence pauses. Modern endpointing reads the live partial transcript and predicts semantic completeness, letting the agent respond before the trailing silence even finishes. This shaves real time off the perceived response gap without making the agent more trigger-happy about cutting users off.

Half-Duplex vs. Full-Duplex

The 2025–2026 Shift Toward Full-Duplex

Through 2025, “which API sounds the most human?” was largely a solved problem. The competitive question moved to which platforms support true full-duplex interaction. ByteDance’s Seeduplex, released in April 2026 and benchmarked against its own half-duplex Doubao predecessor, reported roughly a 50% reduction in combined false-response and false-interruption rate, 250ms faster end-of-turn detection, 40% fewer talk-over incidents, and an 8.3-point gain in call satisfaction. Sierra’s τ-voice benchmark frames the remaining gap as four separate axes an agent has to get right simultaneously — pause handling, turn-taking, backchanneling, and interruption handling — which is why full duplex has taken years longer to reach production than natural-sounding TTS did.

Official Implementation Snippet

Configuring “half-duplex with barge-in” usually means choosing an endpointing strategy and wiring a small state machine that only accepts one active speaker at a time:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI()

async def half_duplex_session():
    async with client.realtime.connect(model="gpt-realtime-1.5") as connection:
        # server_vad waits for trailing silence; semantic_vad reads the
        # transcript for completeness and can fire before silence even starts
        await connection.session.update(session={
            "turn_detection": {"type": "semantic_vad", "eagerness": "medium"},
        })

        state = "LISTENING"

        async for event in connection:
            if event.type == "input_audio_buffer.speech_started" and state == "SPEAKING":
                await connection.response.cancel()   # barge-in: yield the channel
                state = "LISTENING"

            elif event.type == "input_audio_buffer.speech_stopped":
                state = "THINKING"

            elif event.type == "response.output_audio.delta":
                state = "SPEAKING"                    # channel closed to new turns
                play(event.delta)

asyncio.run(half_duplex_session())

Context and Limitations

Half-duplex with barge-in remains the pragmatic default for most production deployments — customer support lines, IVR replacements, scheduling assistants — because it is far easier to test and keep coherent than full-duplex. It struggles in scenarios that depend on natural overlap: live translation, coaching or tutoring use cases where the agent should backchannel while listening, and any conversation where users expect to think out loud without being interrupted or interrupting.

References

• Full-Duplex Voice Agents: Simultaneous Speech (2026) — Evalgent
• Best Full-Duplex Voice AI APIs in 2026, compared — Seeduplex
• Real-Time vs Turn-Based Voice Agents in 2026 — Softcery
• τ-voice: benchmarking real-time voice agents — Sierra
• τ-Voice: Benchmarking Full-Duplex Voice Agents (arXiv)
• Turn detection and endpointing for voice agents — AssemblyAI
• Turn detection: VAD, endpointing, and model-based detection — LiveKit
• Introducing Seed Full-Duplex Speech LLM — ByteDance Seed