OpenAI Launches GPT-Live-1 API: Decoupled Full-Duplex Voice and Asynchronous Agent Delegation

For two years, voice-enabled AI applications have operated under an awkward technical compromise: turn-based Voice Activity Detection (VAD). A client would stream audio into a buffer, wait for the user to stop talking, wait for a silence threshold of 300 to 800 milliseconds to confirm the turn had ended, run inference on a single monolithic model, and stream back an answer. If the user interrupted or uttered a conversational filler like “yeah,” the system either crashed through the interruption or awkwardly aborted its entire context.

Today, OpenAI launched the public API for GPT-Live-1. The release introduces a dedicated full-duplex model accessed through a new endpoint, v1/live/sessions. Rather than forcing one model to listen, think, reason, call tools, and synthesize speech inside a single synchronous loop, GPT-Live-1 introduces an architectural separation: a lightweight, full-duplex conversational frontend that listens and speaks simultaneously, paired with an asynchronous delegation bus that passes heavy tasks to backend models like GPT-5.6 Terra, GPT-5.6 Luna, the frontier GPT-6 Astra reasoning engine, or external multi-agent systems.

The commercial terms are aggressive: $0.05 per minute of active session time, billed strictly by the second with no rounding up to the nearest whole minute. For developers building real-time customer service pipelines, phone agents, or desktop copilots, this release changes the foundational topology of conversational software.

What Happened

The official announcement and the developer documentation establish the core specifications:

• The model identifier is gpt-live-1. It is accessible exclusively through the v1/live/sessions endpoint. Standard endpoints like v1/chat/completions, v1/responses, and the legacy v1/realtime endpoint do not accept gpt-live-1.
• Input and output modalities are strictly audio and text. Image and video inputs are not supported at the voice model layer; any visual context must be ingested through backend delegation.
• Session pricing is set at $0.05 per minute ($3.00 per hour), calculated on a continuous per-second basis. Backend execution (such as tool execution or inference on delegated models like GPT-5.6 Terra) is billed separately at the standard token rates of those respective models.
• Rate limits are bounded by concurrent active sessions rather than tokens per minute: Tier 1 accounts receive 25 concurrent sessions, Tier 2 receives 50, Tier 3 receives 200, Tier 4 receives 300, and Tier 5 reaches 500. Free tier accounts do not have access.
• The knowledge cutoff is July 31, 2025. The model relies entirely on backend delegation and retrieval tools for current events and private data lookups.
• Supported audio transports include WebRTC (for browser and mobile clients), primary WebSockets (for server-to-server audio streams), sideband WebSockets (for out-of-band administrative control and tool execution), and direct SIP integrations via partners including LiveKit, Twilio, Telnyx, and Daily.

Full-Duplex Architecture: Eliminating Turn-Based Silence Delays

The technical heart of GPT-Live-1 is full-duplex audio processing. In conventional voice pipelines, the system switches between listening and speaking states. This requires a silence detector to decide when a speaker has finished. If the silence threshold is set too low (e.g., 200ms), a natural mid-sentence pause cuts the speaker off. If set too high (e.g., 700ms), every conversational turn begins with dead air.

GPT-Live-1 discards this state machine. The model streams incoming audio while simultaneously generating outgoing audio chunks. An internal decision loop evaluates the acoustic and linguistic stream more than 20 times per second. This sub-second evaluation enables three behaviors that were previously brittle or impossible:

1. Natural Interruption Handling: When a user speaks while the model is talking, the model decides within tens of milliseconds whether the incoming sound is ambient background noise, a brief backchannel acknowledgment (“right”, “uh-huh”), or an actual interjection intended to steer the conversation.
2. Acoustic Backchanneling: The model can produce subtle vocalizations (such as “mhmm” or quick affirmative nods) while continuing to ingest incoming speech, signaling active listening without seizing the conversational turn.
3. Pacing and Cadence Control: Because generation is not blocked on a completed input turn, the model can adjust its rate of speech dynamically based on prompt directives.

Decoupled Delegation: Responses Mode vs. Client Mode

In earlier architectures, such as the Claude Agent Stack or standard OpenAI Realtime preview endpoints, tool calling required the conversational audio loop to pause while tools executed. If a tool call took three seconds, the caller heard three seconds of silence or required engineered filler phrases.

GPT-Live-1 resolves this through architectural decoupling. The voice frontend handles the live audio stream, while reasoning and external actions run asynchronously over an event bridge. The API provides two delegation topologies:

Mode A: Responses Delegation (OpenAI-Managed)

In this configuration, OpenAI manages the entire loop between GPT-Live-1 and a hosted reasoning model. Developers configure a backend model (such as gpt-5.6-terra for complex analysis or gpt-5.6-luna for rapid lookups) inside the session parameters.

When a user asks a question requiring database records or calculations, GPT-Live-1 recognizes the requirement and emits a delegation event. OpenAI’s infrastructure routes the request to the configured backend model, supplies conversation context, runs authorized functions or web searches, and returns the structured answer to GPT-Live-1, which synthesizes it into the voice stream. Throughout this process, GPT-Live-1 continues talking with the user, acknowledging the pending request rather than hanging in silence.

Mode B: Client Delegation (Autonomous Control Plane)

For enterprise applications, healthcare systems, or multi-agent workflows built on custom frameworks, Responses delegation is often insufficient because private data cannot flow through an unvetted proxy. Client delegation solves this by handing complete execution authority back to the developer’s server.

Under client delegation, when GPT-Live-1 encounters a request requiring external action, it emits a session.delegation.created event containing task metadata. The event does not carry raw audio; it passes structured intent. The application’s server orchestrator (which can be a LangGraph graph, an MCP server network, or an internal microservice) executes the necessary validation, verifies permissions, runs database queries, and formats a clean response. The server then injects the verified result back into the session using response.item.create and response.create.

Architectural Comparison

The following table summarizes the structural differences between the two delegation modes:

GPT-Live-1 Delegation Modes Comparison

System Workflow Pipeline

The interaction between the user, the full-duplex voice frontend, the delegation bus, and backend systems follows a distinct decoupled flow:

Technical Implementation: Session Configuration

Configuring a GPT-Live-1 session requires establishing the conversational instructions and the delegation parameters at startup. Unlike traditional monolithic prompts that pack business logic, JSON schemas, and vocal tone into one massive system message, GPT-Live-1 enforces prompt separation.

The spoken layer prompt (session.instructions) must remain short, focusing on pacing, persona, and delegation conditions. The backend prompt (delegation.responses.instructions) houses the strict business rules, verification requirements, and database formatting constraints.

The following Python example illustrates establishing a session with managed Responses delegation, configured for priority execution:

from openai import OpenAI
from openai.types.live.session_config_param import SessionConfigParam

client = OpenAI()

# Define session parameters with decoupled delegation
session_config: SessionConfigParam = {
    "model": "gpt-live-1",
    "modalities": ["audio", "text"],
    "instructions": (
        "You are an engineering support assistant for cloud infrastructure. "
        "Keep spoken replies brief, conversational, and direct. "
        "When an incident status or cluster diagnostic is requested, delegate immediately "
        "to the backend service and acknowledge the request naturally."
    ),
    "delegation": {
        "type": "responses",
        "responses": {
            "model": "gpt-5.6-terra",
            "service_tier": "priority",
            "instructions": (
                "Query Kubernetes cluster state and telemetry databases. "
                "Verify service health before returning status. Return concise, "
                "technically verified summaries with node counts and error codes."
            ),
            "tools": [
                {
                    "type": "function",
                    "name": "get_cluster_telemetry",
                    "description": "Fetch real-time cluster health and CPU/RAM metrics",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "cluster_id": {"type": "string"},
                            "namespace": {"type": "string"},
                        },
                        "required": ["cluster_id"],
                    },
                }
            ],
            "tool_choice": "auto",
            "parallel_tool_calls": True,
        },
    },
}

# Session creation over v1/live/sessions endpoint
session = client.live.sessions.create(**session_config)
print(f"Session established: {session.id}, status: {session.status}")

Transport Protocols and Sideband Architecture

Production voice applications face distinct network constraints depending on whether they run in a browser, a native mobile app, or a telephony carrier network:

1. WebRTC Media Streams: For browser applications, audio is transmitted via standard WebRTC peer connections. Raw audio flows across dedicated RTP media tracks, while control signals and transcription deltas travel across an interleaved WebRTC data channel. This minimizes client CPU load and eliminates WebSocket framing overhead.
2. Server WebSockets: For backend applications ingesting raw PCM audio streams, the primary WebSocket carries base64-encoded audio chunks via session.input_audio.append and receives output audio chunks via session.output_audio.delta.
3. Sideband WebSockets: One of the most powerful capabilities in the new API is sideband control. When client audio connects directly to OpenAI via WebRTC (reducing client-to-server latency), the developer’s server can attach to the exact same session over a secure sideband WebSocket. The server receives transcription deltas, monitors tool invocations, and enforces authorization rules without intercepting or transcoding the real-time audio stream.
4. SIP and Telephony: Direct integration with SIP trunks enables enterprise telephony providers (such as Twilio and Telnyx) to bridge telephone calls directly into GPT-Live-1 sessions without spinning up intermediate WebRTC gateway servers.

Migration from the Realtime API: Critical Event Breaking Changes

Teams migrating existing applications from OpenAI’s earlier Realtime API (v1/realtime), alongside the broader platform transitions detailed in our OpenAI deprecations migration guide, must adapt to substantial event stream modifications. Because full duplex eliminates turn boundaries, several familiar events have been restructured or removed entirely:

Realtime API vs. GPT-Live-1 Event Mapping

The absence of a response.done event marking the conclusion of spoken audio is a critical architectural shift. In a full-duplex system, speaking and listening overlap. A server cannot assume the assistant has finished talking simply because a generation buffer emptied, because buffered client-side audio may still be playing. Developers must track actual playback progress in the client audio context rather than relying on server-side completion signals.

Limitations and Unresolved Engineering Constraints

While GPT-Live-1 represents a major milestone for real-time AI, engineering teams must evaluate several technical limitations before deploying it to production:

• Loss of Raw Acoustic Waveform in Delegation: When GPT-Live-1 triggers client delegation, the resulting session.delegation.created event contains semantic text and metadata, not the raw audio buffer. If an application relies on acoustic signals (such as detecting answering machine tones, dual-tone multi-frequency DTMF signals, or acoustic emotion classifiers), the delegated backend cannot make that determination. Developers must run a parallel audio analysis pipeline alongside GPT-Live-1 to capture acoustic artifacts.
• Strict Modality Boundary: The voice frontend cannot ingest images, PDFs, or video streams. If a user says “Look at this error on my screen,” the voice model cannot parse the image directly. The client application must capture the screen, upload it via the Files API or a backend sideband, and inject the visual description into the delegated Responses context.
• Fixed Voice Profiles and Provenance: To prevent voice cloning and impersonation risks, GPT-Live-1 does not support arbitrary custom voice cloning. Developers must select from a fixed catalog of pre-trained voices. In addition, all synthetic audio generated by GPT-Live-1 contains embedded SynthID acoustic watermarking to ensure cryptographic provenance.
• Cold Start Connection Latency: While sub-second audio turn-taking is rapid once established, initial session establishment over WebRTC requires SDP handshake negotiation and server authentication. Teams building telephony workflows should pre-warm sessions before routing calls to eliminate startup clipping.

Actionable Playbook for Developers

1. Audit Existing Voice Workflows: If your current architecture uses turn-based VAD with silence detection thresholds over 400ms, evaluate migrating to GPT-Live-1 to eliminate latency gaps and speech collisions.
2. Decouple Your Prompts: Strip heavy schemas, domain rules, and formatting requirements out of your voice instructions. Keep session.instructions focused strictly on conversation tempo and conversational guardrails; move all business logic into delegation.responses.instructions.
3. Select Delegation Mode by Security Needs: Use Responses delegation for standard information retrieval where OpenAI-managed tools suffice. Use Client delegation whenever data protection, custom agent orchestration (such as MCP), or multi-step approval workflows are required.
4. Implement Client-Side Playback Tracking: Update client-side audio pipelines to drive visual indicators (such as speaking waves or UI animations) from actual WebRTC playback buffers, rather than relying on server-side generation signals.
5. Recalculate Budget Pipelines: Audit billing models against the $0.05 per minute rate ($3.00 per active hour). Because billing is strictly per second, short, fast phone queries (e.g., 45-second verification calls) will cost approximately $0.0375 in session fees plus backend tokens, offering significant savings compared to minimum-minute rounding services.

Sources

• OpenAI official announcement: Introducing GPT-Live
• OpenAI API documentation: Getting started with GPT-Live
• OpenAI developer guide: Delegation and tools in GPT-Live
• OpenAI model catalog: GPT-Live 1 specifications and pricing
• OpenAI migration guide: Moving from Realtime API to GPT-Live