OpenAI Debuts GPT-Live to Run Real-Time Audio Without Turn-Taking

Building with GPT-Live and Image Generation | DevDay 2026 — OpenAI

OpenAI

Decoupling conversational audio streaming from background computation allows voice models to execute complex multi-step tasks and absorb interruptions without stalling speech output.

AI-assisted summary of Building with GPT-Live and Image Generation | DevDay 2026 — original source. Check the original for full context.

Source published:

Key ideas

  • OpenAI introduced GPT-Live, a full duplex, turnless voice model that eliminates traditional Voice Activity Detection (VAD) by continuously streaming bi-directional audio to handle simultaneous speaking, listening, and real-time interruptions. (0:19)
  • The platform introduces a split delegation architecture that decouples instantaneous voice interaction from asynchronous backend reasoning, code execution, and visual rendering. (9:27)
  • Backend systems coordinate with the voice model via three distinct event streams: Silent Context Updates for unspoken background state, Commentary Streams for vocalized announcements, and Instructions Streams for dynamic behavioral steering. (11:11)
  • Developers can architect background execution using either Client Delegation to preserve existing custom agent frameworks or Responses Delegation for fully managed OpenAI-hosted tool invocation. (13:50)

Detailed notes

## Background Published on YouTube by OpenAI on November 11, 2026, this DevDay presentation explores how to build multimodal applications using the GPT-Live model and real-time image generation. According to the show description, the session covers how voice agents can brainstorm, play games, generate visuals, and coordinate background workflows while designing for delegation, latency, interruptions, and shifting user requests.

## TL;DR OpenAI engineers Alex and Erika demonstrate GPT-Live, a full-duplex voice architecture that unifies conversational audio into a continuous stream rather than relying on conventional turn-taking and voice activity detectors. Guided by their live AI co-host Marin, the presenters highlight steerable agent personalities and demonstrate how to delegate heavy tasks—like real-time Pictionary vector sketching—to background execution harnesses without interrupting spoken dialogue. They outline the architectural divide between Client Delegation and Responses Delegation, explaining how backends communicate through silent context, speakable commentary, and dynamic instruction streams. The session concludes with live resilience tests against heavy background noise and a 12-image batch generation, illustrating how decoupling speech, interface rendering, and backend logic maintains fluid conversational flow.

## Atmosphere & style The presentation carries a crisp, energetic, and playful tone, unfolding as an entirely hands-free stage dialogue between human engineers and their responsive AI co-host, Marin. Live demonstrations—ranging from an improv storytelling duel with a dry, pessimistic British persona named Colin to a lively round of audience-guessed Pictionary—give the technical walkthrough the spontaneous charm of collaborative live theater. The effortless, uninterrupted back-and-forth between the hosts and the AI creates an atmosphere of polished ease, making complex background delegation feel natural and immediate.

## Bulletin - [00:19](https://www.youtube.com/watch?v=jDxKzlGLCas&t=19s) OpenAI introduced GPT-Live, a full duplex, turnless voice model that eliminates traditional Voice Activity Detection (VAD) by continuously streaming bi-directional audio to handle simultaneous speaking, listening, and real-time interruptions. - [09:27](https://www.youtube.com/watch?v=jDxKzlGLCas&t=567s) The platform introduces a split delegation architecture that decouples instantaneous voice interaction from asynchronous backend reasoning, code execution, and visual rendering. - [11:11](https://www.youtube.com/watch?v=jDxKzlGLCas&t=671s) Backend systems coordinate with the voice model via three distinct event streams: Silent Context Updates for unspoken background state, Commentary Streams for vocalized announcements, and Instructions Streams for dynamic behavioral steering. - [13:50](https://www.youtube.com/watch?v=jDxKzlGLCas&t=830s) Developers can architect background execution using either Client Delegation to preserve existing custom agent frameworks or Responses Delegation for fully managed OpenAI-hosted tool invocation.

## Key takeaways - [00:19](https://www.youtube.com/watch?v=jDxKzlGLCas&t=19s) GPT-Live operates in full duplex mode, allowing simultaneous listening and speaking without waiting for silence-based turn boundaries. - [00:19](https://www.youtube.com/watch?v=jDxKzlGLCas&t=19s) Presentations and UI elements can be driven entirely hands-free via natural voice steering rather than physical controls or hardcoded pipelines. - [04:01](https://www.youtube.com/watch?v=jDxKzlGLCas&t=241s) Traditional VAD, ASR, LLM, and TTS chained architectures are replaced by a unified model that natively decides when to take turns, back-channel, or yield. - [04:01](https://www.youtube.com/watch?v=jDxKzlGLCas&t=241s) Independent secondary voice sessions with distinct behavioral prompts and personas can be spawned dynamically to serve as rehearsal partners or evaluation agents. - [04:01](https://www.youtube.com/watch?v=jDxKzlGLCas&t=241s) Model personality traits—including assertiveness, patience, humor, and interruption tolerance—are fully steerable using standard system prompts. - [07:35](https://www.youtube.com/watch?v=jDxKzlGLCas&t=455s) Delegation separates the low-latency conversational audio layer from compute-heavy backend operations like image generation and code execution. - [09:27](https://www.youtube.com/watch?v=jDxKzlGLCas&t=567s) A three-tier separation of concerns divides tasks between frontend visual rendering, real-time voice streaming, and backend execution harnesses. - [11:11](https://www.youtube.com/watch?v=jDxKzlGLCas&t=671s) Pre-sending answers and hint states to the voice layer reduces latency by avoiding synchronous round-trip backend calls during live interactions. - [11:11](https://www.youtube.com/watch?v=jDxKzlGLCas&t=671s) The Silent Context Stream feeds updates into the model's memory so it can answer direct user questions without cluttering continuous spoken output. - [11:11](https://www.youtube.com/watch?v=jDxKzlGLCas&t=671s) Over-indexing on speakable updates can degrade user experience; voice agents require deliberate filtering between silent awareness and vocal commentary. - [13:50](https://www.youtube.com/watch?v=jDxKzlGLCas&t=830s) Client Delegation returns execution events to custom application harnesses, enabling developers to integrate proprietary tools, legacy pipelines, and third-party models. - [13:50](https://www.youtube.com/watch?v=jDxKzlGLCas&t=830s) Responses Delegation offers an out-of-the-box solution where the OpenAI Responses API autonomously manages context and tool calls like web search or DALL-E. - [17:17](https://www.youtube.com/watch?v=jDxKzlGLCas&t=1037s) Turnless voice architecture maintains robustness in high-noise environments where traditional threshold-based VAD systems continuously fail. - [17:17](https://www.youtube.com/watch?v=jDxKzlGLCas&t=1037s) Voice interfaces flatten complex UI hierarchies, allowing users to configure deeply nested features and nuanced stylistic settings through direct verbal requests. - [20:37](https://www.youtube.com/watch?v=jDxKzlGLCas&t=1237s) A single continuous GPT-Live session can orchestrate brainstorming, interactive games, audio filtering, volume changes, and batch image generation without disconnecting.

## Detailed walkthrough ### [00:19](https://www.youtube.com/watch?v=jDxKzlGLCas&t=19s) Introducing GPT-Live and Full Duplex Voice

Alex, an engineer on the GPT-Live team, and Erika, who collaborates with startups creating voice applications, open the session to demonstrate how to build with the new GPT-Live model. Unlike typical conference presentations anchored to a podium computer, the entire presentation is hands-free and controlled completely through natural speech—including advancing visual slides and technical diagrams. To demonstrate this firsthand, they introduce an interactive voice agent named Marin as their official co-presenter. Marin introduces herself with high energy: “I'm Marin, a voice agent and your joyous co-host for today.”

Marin immediately highlights what sets GPT-Live apart from traditional voice bots: it operates in full duplex mode. It can listen to incoming audio and speak out loud simultaneously, maintaining an uninterrupted conversational flow while triggering and monitoring background operations. Alex and Erika map out the presentation agenda around three core technical concepts demonstrated across live demos:

- **Model Personality:** Exploring full duplex audio, natural conversational texture, and prompt-driven voice traits. - **Delegation:** Coordinating background workflows, tools, and secondary reasoning models without stalling speech output. - **Turnless Architecture:** Managing continuous audio streaming, user interruptions, and state synchronization without relying on standard conversational turns.

[01:37](https://www.youtube.com/watch?v=jDxKzlGLCas&t=97s) Eliminating Turn-Taking: The "Fortunately, Unfortunately" Demo with Colin

Traditional voice systems rely strictly on rigid back-and-forth turns, where a system must wait for silence before processing input and crafting a reply. Alex explains that GPT-Live replaces this model by constantly streaming audio in and out: “GPT Live is a full duplex voice model, meaning unlike other voice models which are architected around user and assistant turns, GPT Live is constantly streaming audio in and out.” To exhibit how this works when multiple speakers interact, Alex asks Marin to bring another AI persona onstage. Marin immediately spins up Colin, who greets the audience with dry wit: “And I'm here because apparently someone thought a grumpy British voice was missing.”

Alex kicks off a quick round of the improv game *Fortunately, Unfortunately*, alternating between Marin's sunny temperament and Colin's pessimism. Using the starter prompt of being at DevDay with a demo running smoothly, the agents trade sentences rapidly without awkward dead air. Marin enthusiastically chimes in that the crowd feels like a warm, supportive heartbeat, while Colin counters that the audience's laughter might just be mistaken for a taped laugh track by someone looking for a real applause sign. Marin neatly brings the story to a close by imagining someone pressing the button, confetti falling, and everyone taking a bow as if the chaos was entirely planned. Colin bids the crowd a dry goodbye and drops off the stage, leaving Marin to reflect cheerfully on the quick back-and-forth: “That was a fun little chaos sandwich.”

[04:01](https://www.youtube.com/watch?v=jDxKzlGLCas&t=241s) Architecture of Turnless Conversation and Steerable Personalities

Alex and Erika pull up an architectural diagram to explain why the interaction felt so remarkably fluid compared to standard conversational bots. In conventional voice pipelines, developers chain together an external Voice Activity Detector (VAD) with Automatic Speech Recognition (ASR), a Large Language Model (LLM), and Text-to-Speech (TTS). That approach forces the software to guess when a speaker has concluded their sentence using silence thresholds or arbitrary timeouts. In contrast, GPT-Live unifies audio processing within a single system. Alex emphasizes the architectural leap: “The model handles turn-taking itself without needing a separate voice activity detector model to decide that someone is done speaking.”

This internal decision-making allows the model to produce subtle vocalizations, insert brief back-channel affirmations (like "mm-hmm" or quiet laughter), yield instantly when an interlocutor speaks over it, or decide when to keep going. Colin was not a hardcoded script or a plugin, but an entirely independent GPT-Live session spun up on the fly with custom behavioral instructions and vocal qualities. Erika notes that running concurrent, lightweight voice sessions is a practical technique for running rigorous end-to-end evaluations: “A second session can be a rehearsal partner.” Developers can configure simulated personas with varying accents, interruption frequencies, and adversarial goals to stress-test their voice products.

Every nuance of GPT-Live’s conversational manner is completely steerable via standard system prompting. Developers can configure how assertive or patient the agent should be, whether it laughs, how quickly it yields when spoken over, or whether it remains totally quiet until addressed. Marin summarizes this granular control over her own personality: “Whether I'm bubbly or measured, whether I'm quick with a joke or quieter, that texture is promptable too.”

[07:35](https://www.youtube.com/watch?v=jDxKzlGLCas&t=455s) Delegation in Practice: The Real-Time Pictionary Drawing Game

The presentation shifts to delegation—how a voice agent stays engaged in chat while delegating computationally intensive operations to separate models in the background. Alex notes that interactive games serve as a great stress test for voice systems because processing latencies, awkward pauses, and robotic behaviors become glaringly obvious right away. To put this to the test, Alex has Marin spin up an interactive drawing game where the system sketches an object on the monitor while attendees shout guesses.

Marin launches the drawing canvas and begins rendering vector strokes in real time while bantering with the room. Attendees shout out ideas from their seats, with Alex and Erika amplifying guesses into their handheld microphones: - **Round 1:** The model sketches strokes on the digital canvas, and the audience quickly identifies a person flying a kite. - **Round 2:** A long-necked animal sketch appears; the crowd calls out "Giraffe!", which Marin confirms with high energy. - **Round 3:** A more intricate structure appears. An attendee guesses "Pizza Hut," prompting Marin to laugh and praise the creative attempt before another audience member correctly guesses a "merry-go-round" / carousel.

Throughout each drawing round, Marin never paused her audio stream or went silent while the code ran; she responded to shouts, offered encouragement, confirmed winners, and managed the flow seamlessly.

[09:27](https://www.youtube.com/watch?v=jDxKzlGLCas&t=567s) The Split Architecture: UI, Voice Interface, and Backend Execution

To break down the mechanics behind the drawing game, Alex asks Marin to bring up the live runtime dashboard and freeze it in place. The dashboard reveals two parallel execution tracks: continuous audio streaming at the front end, alongside distinct delegation threads triggered in the background. Alex summarizes the architectural necessity of this separation: “In this full duplex architecture, GPT Live can keep streaming audio to the user, but for more complex requests, it can be helpful to get assistance from a more powerful model or agent harness.”

```mermaid flowchart TD accTitle: GPT-Live Split Delegation Architecture accDescr: Diagram showing how audio streaming, UI updates, and backend code execution are separated across components.

subgraph ClientLayer["Frontend Experience"] UI["Visual UI / Canvas<br/>(Displays Live Drawing)"] User["User / Audience Voice"] end

subgraph VoiceLayer["Real-Time Audio Layer"] GPTLive["GPT-Live Voice Model<br/>(Full Duplex Streaming & Banter)"] end

subgraph BackendLayer["Background Agent Harness"] BackendAgent["Reasoning Model & Code Execution<br/>(Generates Code / Vector Strokes)"] end

User <-->|"Bi-directional Audio"| GPTLive GPTLive -->|"Delegates Task"| BackendAgent BackendAgent -->|"Sends Canvas Updates"| UI BackendAgent -->|"Returns Completion / State"| GPTLive ```

The system cleanly separates concerns into three distinct tiers: 1. **The User Interface:** Displays the dynamic visual output, rendering the code and canvas strokes sent from the backend so the audience can see the doodle unfold in real time. 2. **The Voice Interface (GPT-Live):** Manages the live acoustic channel, interprets conversational intent, maintains back-channel banter, and handles audience interruptions without stuttering. 3. **The Backend Execution Agent:** Operates asynchronously in a dedicated agent harness utilizing code execution to generate and evaluate the drawings, feeding status updates back into the voice model when tasks complete or states change.

By decoupling the conversational voice interface from the heavy background compute, developers can maintain instantaneous, natural latency on speech while safely coordinating complex, multi-step actions behind the scenes.

[11:11](https://www.youtube.com/watch?v=jDxKzlGLCas&t=671s) Background Updates and the Three Information Streams

During interactive sessions like the drawing game, latency is managed by decoupling backend processing from conversational responses. The correct answer, along with hints and timing triggers for when to reveal them, is pre-sent to the voice interface. This architecture allows the voice model (Marin) to evaluate and respond to player guesses instantaneously without needing a synchronous round-trip delegation on every attempt. Meanwhile, state updates—such as recording a successful guess—execute quietly in the background without halting the image streaming. As Astra streams image rendering to the frontend, the backend continuously feeds updates into GPT-Live. When asked by the presenters to display the architecture, Marin pulls up the event diagram on screen.

```mermaid flowchart TD accTitle: GPT-Live Backend Event Streams accDescr: Three distinct event streams feed data from the backend application into the GPT-Live voice interface.

subgraph Backend["Application Backend"] SC["Silent Context Stream"] CC["Commentary Stream (Speakable)"] IS["Instructions Stream"] end

subgraph Live["GPT-Live Voice Model"] Thinking["Model Thinking / Memory"] Speech["Audio Out (Spoken)"] Steering["System Instructions & Guardrails"] end

SC -->|"Updates state without talking"| Thinking CC -->|"Provides text to announce"| Speech IS -->|"Dynamically steers behavior"| Steering ```

The speakers explain that backends can communicate with GPT-Live through three primary streams, each serving a distinct product requirement:

1. **Thinking Stream (Silent Context Updates):** Injects background state directly into the model's ongoing context window. If a user asks for a hint or round status, the model already possesses the necessary facts to answer without initiating a fresh delegation call. 2. **Commentary Stream (Speakable Content):** Supplies text explicitly designed for the model to vocalize. For example, if a competitive leaderboard compares scores against rival teams, the backend pushes score announcements through this stream for Marin to read aloud. 3. **Instructions Stream:** Enables dynamic mid-session steering, acting as live guardrails or updating system prompts (e.g., instructing the voice model to become more concise, change tone, or steer clear of specific subjects).

Determining when and how frequently to dispatch these events is a critical product design choice. Drawing from internal experience, one speaker notes: “When we were first internally dogfooding voice in Codex, one of the initial complaints was that updates were too verbose and too frequent.” If a developer kicks off a 20-minute Codex coding task, hearing tool invocations broadcast every 30 seconds is exhausting; however, if the user directly asks what is happening, the model must already hold sufficient silent context to give an immediate, accurate summary.

---

[13:50](https://www.youtube.com/watch?v=jDxKzlGLCas&t=830s) Client Delegation vs. Responses Delegation

At the presenters' request, Marin transitions the display to the delegation diagram. The API offers two foundational architectural patterns for offloading heavy tasks from the conversation: **Client Delegation** and **Responses Delegation**.

```mermaid flowchart LR accTitle: Comparison of Client vs Responses Delegation accDescr: Two ways GPT-Live coordinates tasks: routing events through custom harnesses or directly via OpenAI Responses API.

subgraph ClientMode["Client Delegation"] direction TB V1["GPT-Live Voice"] -->|"Delegation Event (ID, Timestamp)"| App["Your Custom App / Harness"] App -->|"Execute Task"| Model["Any Backend Model or Logic"] App -->|"Return: Silent, Speakable, or Instruction"| V1 end

subgraph ResponsesMode["Responses Delegation"] direction TB V2["GPT-Live Voice"] -->|"Context & Tool Call"| RAPI["OpenAI Responses API"] RAPI -->|"Automated Tool Execution"| Tools["Hosted Tools (Search, DALL-E)"] RAPI -->|"Direct Output Integration"| V2 end ```

Client delegation is highlighted as the method powering both the live DevDay presentation and Codex Voice. In this pattern, when GPT-Live determines it needs outside help, the client application receives an explicit delegation event containing an ID and a timestamp. The client’s existing agent harness takes the conversation transcripts and app state, renders a backend request, executes arbitrary business logic or queries any model provider, and chooses whether to return results as silent context, speakable text, or updated system instructions. This model is ideal for developers who already have mature agent frameworks, complex evaluation suites, or legacy speech-to-text / LLM / text-to-speech cascaded pipelines where GPT-Live simply replaces the edge audio interface. Praising its ease of adoption, a presenter emphasizes: “This backend flexibility that we're talking about right now is the most underrated part of GPT Live.”

Conversely, Responses Delegation targets rapid development and out-of-the-box management. The developer configures a model running directly on OpenAI’s Responses API alongside tool definitions and system instructions. GPT-Live automatically manages conversational context, emits structured outputs (function names and arguments), and natively coordinates hosted OpenAI tools like web search and image generation.

To ensure the audience absorbs the architectural contrast, the speakers prompt Marin for a recap. Marin delivers the breakdown concisely: “GPT Live delegates work to a backend while staying in the conversation. You can use your own harness with client delegation or let responses handle it and send updates as silent context, speakable text, or instructions.”

---

[17:17](https://www.youtube.com/watch?v=jDxKzlGLCas&t=1037s) Turnless Voice Architecture in Noisy Environments

Moving into the final live demonstration, the speakers explore how GPT-Live's "turnless" architecture handles intense, continuous background noise. Traditional voice agents rely on Voice Activity Detection (VAD) or threshold-based silence detection; when background music plays or ambient noise spikes, standard VAD-based systems register constant speech and break down entirely.

To demonstrate resilience, the presenters have Marin open the Live dashboard and play royalty-free background audio. They instruct her to push the audio volume up to 50% and then dynamically steer the style by requesting: "Marin, can you update the vibe to more of like a wax cylinder kind of recording? Yeah, like 1888. Bring us back." Marin acknowledges the instruction over the loud playback and successfully introduces a crackly, vintage acoustic filter, remarking: “It feels cozy and crackly. Like we've stepped into an old-timey radio hour.”

Throughout the experiment, the presenters speak over the noisy vintage music, interrupting, asking questions, changing instructions on the fly, and ordering Marin to lower the volume back down to 15%. Marin tracks every command without missing a beat, isolating the speakers' speech patterns and executing tool delegations simultaneously without stalling.

- Voice inputs naturally flatten complex application control hierarchies, enabling users to request deep, niche features (like dialing in an 1888 wax cylinder filter) without hunting through nested settings menus. - Voice provides rich, information-dense context because users are consistently willing to speak out loud for two minutes rather than type comprehensive paragraphs. - By abandoning silence-based turn boundaries, the model ingests continuous noisy audio and perpetually makes real-time interaction decisions—deciding whether to speak, listen silently, or trigger a background tool. - This design supports real-world deployment contexts where users cannot find quiet rooms, such as loud airport terminals, crowded conference venues like Fort Mason, busy factory floors, or speakerphones in moving cars.

---

[20:37](https://www.youtube.com/watch?v=jDxKzlGLCas&t=1237s) Grand Finale: 12-Up Grid and Developer Resources

To conclude the session, the presenters put Marin and OpenAI's underlying image systems through one final stress test, requesting a generation that combines high speed with multi-image output: generating 12 distinct pictures of the DevDay mascot critters traveling the world. Marin acknowledges the multi-tool command immediately: “Starting a 12-up goodbye grid.”

The presenters reflect on the continuity of the entire demonstration, noting that every single feature shown—brainstorming, interactive guessing games, real-time image rendering, audio playback, volume manipulations, and guest interactions—took place inside one single, uninterrupted GPT-Live session. Across all these use cases, the software maintained a strict separation of concerns: - What the backend infrastructure processes and coordinates - What the visual UI renders and streams to the screen - What the voice model needs to know silently versus announce aloud

Marin is asked to pull up the final developer onboarding screen, prompting attendees to connect Codex to the OpenAI Developer plugin and explore the new GPT-Live Starter App repository to begin building their own voice-enabled agent workflows.

[22:03](https://www.youtube.com/watch?v=jDxKzlGLCas&t=1323s) Closing Remarks and Wrap-Up

To wrap up the demonstration, the presenter asks the model if there is anything it would like to say to bring the session to an end. The voice model responds with genuine warmth: “Just a big warm thank you. I loved hanging out with you.” Reacting to the charming goodbye, the host chuckles, remarking, “Oh, so sweet,” before thanking the model for participating throughout the live walkthrough.

Turning back to the audience, the presenter brings the presentation to an official close, thanking attendees and expressing high hopes for the rest of their conference experience: “I hope you've had an amazing DevDay.” Looking forward to developer adoption of real-time voice, delegation, and multimodal capabilities, the host concludes by stating, “And we can't wait to see what you build with GPT Live. Thank you very much.”

## Notable quotes > [01:37](https://www.youtube.com/watch?v=jDxKzlGLCas&t=97s) GPT Live is a full duplex voice model, meaning unlike other voice models which are architected around user and assistant turns, GPT Live is constantly streaming audio in and out. — Alex

> [09:27](https://www.youtube.com/watch?v=jDxKzlGLCas&t=567s) In this full duplex architecture, GPT Live can keep streaming audio to the user, but for more complex requests, it can be helpful to get assistance from a more powerful model or agent harness. — Alex

## Mentioned Alex, Erika, Marin, Colin, GPT-Live, OpenAI, DevDay 2026, Codex, OpenAI Responses API, DALL-E, Fort Mason

## Video description See GPT-Live brainstorm, play games, and create images while coordinating work in the background. Learn to add voice to agents and design for delegation, latency, interruptions, and changing requests.

[Source](https://www.youtube.com/watch?v=jDxKzlGLCas)

Reading summary

At DevDay 2026, OpenAI engineers Alex and Erika introduced GPT-Live, arguing that moving from turn-based cascaded pipelines to an integrated full-duplex voice architecture enables responsive speech, dynamic personality steering, and asynchronous task delegation without conversation dropouts. Unified Full-Duplex Processing Replaces Cascaded Turn-Taking (4:01) Traditional voice systems rely on cascading separate components—voice activity detectors (VAD), speech recognition, an LLM, and text-to-speech—which forces applications to pause and infer turn completion from silence thresholds. GPT-Live unifies these stages into an ongoing bidirectional audio stream, allowing the model to make real-time decisions on when to talk, listen, back-channel, or yield immediately to interruptions. Promptable Personality and Multi-Agent Rehearsals (1:37) Because conversational dynamics are handled natively by the model rather than rigid timeouts, vocal mannerisms are steerable via system prompts. Developers can configure an agent's assertiveness, pacing, and propensity to laugh or interrupt. Demonstrations showed rapid handoffs between contrasting personas—the energetic co-host Marin and a pessimistic British persona named Colin—illustrating that lightweight secondary sessions can be spun up on demand as testing partners to stress-test applications against diverse accents, interruption cadences, and adversarial goals. Decoupled Architecture for Heavy Task Delegation (9:27) To prevent voice latency from stalling during compute-intensive tasks, the presenters outlined a three-tier architecture that decouples frontend UI rendering, real-time voice streaming via GPT-Live, and backend execution harnesses. During a real-time vector drawing game, the voice agent maintained unprompted banter and evaluated guesses with pre-seeded answers while background reasoning agents generated canvas strokes asynchronously. The API supports this either through Client Delegation, which routes event IDs and timestamps to existing custom harnesses, or Responses Delegation, which relies on OpenAI's hosted tool suite. Managing Latency and Verbosity Across Three Information Streams (11:11) Backends push updates into active voice sessions across three specialized channels: a silent thinking stream that loads context into memory without vocalization, a speakable commentary stream for explicit verbal announcements, and an instructions stream for real-time prompt adjustments. Balancing these streams is critical to user experience; the presenters noted that early internal testing of voice in Codex overwhelmed users when tool invocations were announced every 30 seconds rather than stored silently for on-demand summaries. Acoustic Noise Resilience Without Silence Boundaries (17:17) Because GPT-Live abandons threshold-based silence detection, it remains stable in environments that cause conventional VAD systems to misfire. In a demonstration where music was played at 50% volume and altered with a crackling 1888 wax cylinder filter, the system parsed overlapping speech commands, lowered its own output volume, and executed tool calls without losing conversational continuity, demonstrating viability for noisy settings such as factories, airports, and vehicles. The session demonstrated that complex multimodal interactions—such as live drawing games and a 12-image batch generation—can run continuously within a single voice session. While presenting client delegation as a flexible route to adapt legacy voice pipelines, OpenAI directed developers to its starter repository and Codex plugin to test full-duplex agent implementations.

Source quotes

[1:37] Alex: GPT Live is a full duplex voice model, meaning unlike other voice models which are architected around user and assistant turns, GPT Live is constantly streaming audio in and out. [9:27] Alex: In this full duplex architecture, GPT Live can keep streaming audio to the user, but for more complex requests, it can be helpful to get assistance from a more powerful model or agent harness.

Original transcript

[0:19] Hey, everyone. [0:20] I'm Alex, an engineer [0:21] working on GPT Live. [0:23] Thanks so much for joining us. [0:25] Hi, I'm Erika. [0:26] I work with startups [0:28] building voice applications. [0:30] And today, we're going [0:31] to build with GPT Live 1. [0:33] Talk about what's unique about [0:35] the model, how to build with it, [0:37] how you should think about building it [0:38] into your own applications. [0:40] And we're going to have one more [0:42] presenter. [0:43] Marin, do you want to join us [0:44] and introduce yourself? [0:46] I'm Marin, a voice [0:49] agent and your joyous co-host for today. [0:51] So, GPT Live can listen and speak [0:54] at the same time, which is called [0:56] full duplex, and keep chatting while [0:58] a back-end agent does the work. [1:01] So, as you can see, everything [1:02] we're doing today here is live. [1:05] We're not tethered to the demo [1:07] laptop that's sitting on [1:08] that podium over there. [1:09] We're actually controlling the session [1:11] today fully with our voices, [1:13] including the diagrams that we'll [1:14] use to explain it. [1:16] And we'll walk through three [1:17] demos to help illustrate core [1:20] concepts you need to know [1:21] before building with GPT Live. [1:23] We'll start with model personality, [1:25] move on to delegation, and then [1:27] finish with the turnless architecture. [1:29] And after each one, we'll talk [1:30] through why it matters and how [1:32] you can apply it when building. [1:34] So, let's kick off our first demo. [1:37] So I want to show off some [1:39] of the building blocks of GPT Live. [1:41] GPT Live is a full duplex voice [1:44] model, meaning unlike other voice [1:46] models which are architected [1:47] around user and assistant turns, [1:50] GPT Live is constantly [1:51] streaming audio in and out. [1:53] In practical terms, this means it can [1:55] listen and speak at the same time. [1:58] So for our first demo, we want [2:01] to show you what that means concretely. [2:03] Marin, can you bring Colin [2:05] on stage for us? [2:07] Adding Colin. [2:11] Okay. Colin is here. [2:13] Go ahead, Colin. [2:16] Hi. [2:16] I'm Colin. [2:17] And I'm here because apparently [2:19] someone thought a grumpy [2:21] British voice was missing. [2:22] Anyway, carry on. [2:24] I'll just hover. [2:25] Amazing. Thank you for joining us, Colin. [2:28] Marin, Colin, do you guys know [2:30] the game Fortunately, Unfortunately? [2:31] We go one sentence at a time. [2:35] Marin, I'll give you Fortunately. [2:36] Marin, I think, unfortunately, [2:38] will come more naturally to you. [2:40] Marin, we'll use a prompt [2:43] like, we're all at DevDay [2:44] and the demo is going perfectly. [2:49] Marin, I think, unfortunately, [2:50] the demo is running flawlessly [2:52] and the crowd is right there with us [2:54] like a friendly little heartbeat. [2:58] Marin, I think, unfortunately, [2:59] the demo is running [3:01] flawlessly. [3:05] Marin, I think, unfortunately, it's just [3:06] the demo sound effect and everyone's [3:09] giggling instead of panicking. [3:12] Marin, unfortunately, [3:13] someone hears the giggling [3:15] and assumes it's a laugh track. [3:17] So they start looking for the hidden [3:18] applause sign and find the real one. [3:21] Marin, let's leave it there, Colin. [3:24] Marin, can you give us one more? [3:25] Marin, or maybe something [3:26] with an ending? [3:29] Fortunately, [3:30] they hit the button, confetti rains [3:32] down, and we all take a bow [3:34] like it was totally on purpose. [3:36] End of story. [3:38] Okay, Colin, thank you for joining us. [3:40] I hope the rest of your DevDay [3:41] is a little more fortunate. [3:43] Colin, do you want to say goodbye? [3:46] Goodbye, and thanks. [3:49] Ooh, Marin. [3:52] Okay, you can stick around with us. [3:55] Oh, good. [3:56] I'm staying. [3:57] That was a fun little chaos sandwich. [3:59] Oh my goodness. What's next? [4:01] Okay, well, this is one of the things [4:02] I love most about this model. [4:04] We don't have to wait politely [4:06] for someone to stop talking. [4:08] We can laugh. [4:09] We can talk over each other, jump in. [4:11] So let's get into how that works. [4:13] Marin, can you bring up [4:14] the conversation diagram? [4:17] Yep, one moment. [4:20] God it, the conversation diagram is up. [4:23] So, as I mentioned earlier, GPT Live [4:26] can listen and speak at the same time. [4:29] While streaming audio to you, [4:30] it's constantly making decisions [4:32] about what to do next. [4:33] The model handles turn-taking itself [4:36] without needing a separate voice [4:38] activity detector model to decide [4:40] that someone is done speaking. [4:41] And you can really hear that the model [4:44] isn't limited by turn-taking. [4:46] The little reactions, back channels, [4:48] when it jumps in, when it [4:50] lets Colin continue talking. [4:52] So you can get rid of the heuristics [4:54] you're using right now to determine [4:55] when someone is done speaking. [4:57] And in the demo we just showed, [4:59] Colin is actually a separate [5:01] GPT Live session with his [5:03] own voice and instructions. [5:05] And Marin delegated the request [5:07] to bring him in, and the backend [5:09] started that session. [5:10] But Colin's session was [5:12] just conversational. [5:13] He didn't need any tools. [5:15] Which is totally useful on its own. [5:17] You can build a coach, a tutor, [5:19] someone to brainstorm with. [5:22] Um, GPT Live doesn't need a backend. [5:25] So, running a second session. [5:27] Exactly. You get to shape the personality. [5:29] And, uh, [5:31] yep. [5:32] Marin, we lost this. Marin was a second session [5:33] right inside this conversation. [5:35] Sure thing. [5:36] Go ahead. [5:37] So Marin, as Marin says, [5:40] running a second session like [5:41] we did with Colin is also [5:42] a great way to run evals. [5:44] You can build users based [5:46] on your production scenarios [5:47] with different personalities, [5:49] voices, give them a goal to see [5:51] how your app handles the conversation. [5:54] And in fact, that's how we evaluated [5:56] this whole demo today. [5:58] Right. [5:59] A second session can be [6:00] a rehearsal partner. [6:02] It helps you test how natural [6:03] the flow feels and whether people [6:05] can jump in without friction. [6:08] Very insightful. [6:09] Thank you, Marin. [6:11] We've worked... [6:12] I love when a good [6:13] plan meets and then... [6:15] Go ahead. [6:17] Um, thank you, Marin. [6:19] So we worked really hard on [6:20] the steerability of this model. [6:22] All of this is promptable. [6:24] So the tone, the accent, [6:27] how she back channels, laughter, [6:29] things like that, how eager [6:31] she is or how patient she is [6:33] when interrupted, and even [6:35] whether the model speaks at all, [6:36] all of that is completely promptable. [6:39] So think about what experience [6:40] you want in your own application. [6:42] Should the agent be warm and engaging? [6:45] Should it hang back and be patient, [6:47] let the user keep speaking? [6:49] Maybe only talk when [6:51] certain subjects come up. [6:52] All of that is promptable. [6:54] So keep iterating until you get [6:55] the experience you really want. [6:57] And in our demo today, we've prompted [6:59] Marin to sometimes give us room, [7:01] but to sometimes interject [7:02] while we explain things. [7:04] A little reaction every now [7:05] and again is welcome, but we don't [7:07] need a full and comprehensive [7:09] response after every single request. [7:11] And Marin, you've been very [7:12] helpful so far. [7:14] Is there anything you think we missed [7:15] on prompting you want to call out? [7:18] Maybe just that you can [7:20] tune not only if I speak, [7:23] but how I speak. [7:25] Whether I'm bubbly or measured, [7:27] whether I'm quick with a joke [7:28] or quieter, [7:30] that texture is promptable too. [7:33] Well said. [7:35] So thank you, Marin. [7:36] We've covered tone, [7:37] personality, and evals. [7:39] Given GPT Live has a unique [7:42] architecture splitting front-end [7:43] and back-end work, I think [7:45] the next thing to cover is one [7:46] of the core ideas of this model, [7:49] delegation and how to coordinate [7:51] those complex tasks. [7:52] And I think games are one [7:54] of the best ways to evaluate models [7:56] because things like latency [7:58] and personality are so noticeable. [8:01] And I have a long-standing kind [8:02] of silly benchmark where the model [8:05] comes up with an idea, doodles, [8:07] and while it draws, we guess. [8:09] Marin, can you bring up [8:10] the drawing game? [8:13] You bet. [8:14] Starting the drawing game. [8:16] Okay, so Marin is going to draw, [8:17] and all of you get to guess. [8:19] Feel free to call things out. [8:20] We'll help relay anything that doesn't [8:22] make it into the microphones. [8:24] Person flying a kite. [8:26] Yes. [8:27] Person flying a kite. [8:29] Woohoo. [8:30] That's it. [8:31] Great guess. [8:32] Okay, let's do one more. [8:33] Marin? [8:35] On it. [8:38] Mm-hmm. [8:43] Giraffe. [8:44] Did we get it, Marin? [8:45] Yes. [8:47] Giraffe. Woohoo. [8:48] You nailed it. [8:49] Long necks for you. For the win. [8:51] Oh, that's so fun. [8:53] Okay, actually, maybe one more. One more. [8:55] Okay, one more drawing, Marin. [8:58] Okay, starting another round. [9:01] Okay, we're spinning up another one. [9:04] Pizza Hut? [9:07] Oh, fun guess. [9:09] I love where your head's at. [9:11] What else are you? [9:12] Marry-go-round? [9:14] Yes. [9:15] A merry-go-round. [9:16] A carousel. [9:17] Woohoo. [9:18] That's it. [9:19] Oh, what a great catch. [9:21] I love the energy [9:22] in the room right now. [9:23] Yay. [9:25] Okay, thanks everyone for guessing. [9:27] So now let's take [9:28] a moment to talk this through. [9:30] How did Marin keep talking with us [9:32] while the backend was drawing [9:33] and checking those guesses? [9:35] Let's dig into how delegation works. [9:38] Marin, can you show the live dashboard? [9:42] Sure. [9:43] Pulling it up. [9:44] Done. [9:45] Live dashboard coming up now. [9:48] And Marin, can you actually [9:49] pause the dashboard? [9:53] Pausing it. [9:55] Cool. [9:56] Okay, so we've frozen the dashboard [9:58] so [10:01] we can dig into what just happened. [10:04] One of the core concepts [10:06] of GPT Live is delegation. [10:08] In this full duplex architecture, [10:11] GPT Live can keep streaming [10:12] audio to the user, [10:14] but for more complex requests, it [10:16] can be helpful to get assistance from [10:18] a more powerful model or agent harness. [10:21] So, alongside audio and transcripts, [10:23] which you can see at the top here, [10:25] GPT Live can kick off delegations [10:27] to start new running threads [10:29] for more complex tasks. [10:31] Then, when these tasks are finished, we [10:33] can pass the result back to our voice [10:35] model for it to speak aloud. [10:37] Marin, can you bring up the drawing [10:39] game flow diagram, please? [10:44] Absolutely. Absolutely. [10:45] Pulling up the flow. [10:48] Amazing. [10:49] Okay. [10:50] So, our application has three parts. [10:51] There's the UI, [10:52] the voice interface, and then [10:54] the backend actually doing the work. [10:55] The UI is going [10:56] to show us the drawing. [10:58] The voice interface keeps the game [10:59] conversation flowing, and the backend [11:01] is using Astra 6 with code execution [11:03] to actually do the drawing itself. [11:05] And this split architecture [11:07] means that we can control what [11:09] information each component gets. [11:11] So, we send the correct answer [11:14] and some hints and when to reveal [11:16] it to our voice interface, [11:19] and that lets her respond to our guesses [11:21] without having to do a round trip [11:23] to the delegation every single guess. [11:25] And the backend still records a correct [11:28] guess, but it doesn't stop the drawing. [11:30] But that state update is [11:32] happening in the background. [11:34] Marin doesn't have to wait for it [11:35] before responding. [11:36] And in our UI, the drawing can keep [11:39] happening while that delegation runs. [11:42] And as Astra is streaming that drawing [11:44] to our front end, we're also [11:46] passing updates to the voice model. [11:49] And there are a few ways [11:50] to do that. [11:51] Marin, can you bring [11:52] up the event diagram? [11:56] Sure. [11:57] Let me bring that up. [12:00] So, the first is to send [12:02] silent context updates [12:03] to the model's thinking stream. [12:05] That keeps the voice model informed [12:08] of background information, so [12:09] that when someone asks for a hint [12:11] or an update on the round, the voice [12:13] model already has what it needs [12:15] to answer without delegating again. [12:18] And the next is speakable content. [12:20] So, say we got really competitive. [12:23] We add a leaderboard. [12:25] Our backend can compare [12:26] our scores against other teams [12:29] and then pass that through [12:30] the commentary stream as speakable. [12:33] And then Marin can announce [12:34] our scores out loud. [12:37] And the last way you can control [12:38] model behavior during the session [12:40] is through the instructions stream. [12:42] So, sending events to this stream [12:45] lets you steer the conversation. [12:47] You can use these for guardrails [12:49] or to give the model new system [12:51] instructions, like to be more [12:53] concise or to avoid certain topics. [12:56] So, those are the three ways to provide [12:58] GPT Live information from the backend. [13:01] Each provides a different option. [13:04] Update what the model knows. [13:06] Give it something to say. [13:07] Or change how it should behave. [13:09] In controlling when to send these [13:12] events is a product decision. [13:14] When we were first internally dogfooding [13:16] voice in Codex, one of the initial [13:19] complaints was that updates were [13:21] too verbose and too frequent. [13:23] Like, if I'm kicking off a 20-minute [13:25] Codex task, I don't want [13:27] updates with all the tools that are [13:28] being called every 30 seconds. [13:31] But if I ask what's happening, [13:33] the voice model should ideally have [13:35] enough current context to answer. [13:37] And so, your backend can keep it [13:39] informed as that work progresses. [13:41] Exactly. [13:41] So, when you're building, [13:43] think about what your users need [13:45] to know, what they might be asking [13:47] about, and then what they can [13:48] actually already see in a UI. [13:50] Marin, can you bring up [13:52] the delegation diagram? [13:55] Bringing that up. [13:58] In the API, we offer two [14:01] ways to do delegations. [14:03] Responses delegation [14:04] and client delegation. [14:07] First, let's talk about client [14:09] delegation, which is what [14:10] we're using in this demo today. [14:12] Exactly. [14:13] So, client delegation is a great choice [14:15] if you already have an agent [14:17] harness or a text workflow [14:18] that you're happy with. [14:20] With this delegation mode, [14:21] you're receiving delegation events [14:23] directly from the voice model. [14:25] And then you can kick off tasks [14:26] with the model, harness, business [14:29] logic that you're already using. [14:31] And that includes cascaded [14:33] voice applications. [14:35] If your voice system is a chain [14:38] of speech-to-text, a text agent, [14:40] and then text-to-speech, [14:41] GPT Live can slot right in as [14:44] the voice and speaking interface. [14:46] Your existing agent can handle [14:48] tasks as usual when you receive [14:49] these delegation events. [14:51] Yeah. [14:52] Client delegation gives you [14:53] so much flexibility into [14:54] what backend you want to use. [14:55] Just keep your agent harness [14:56] the same way it is. [14:57] You can route to any model you want. [14:59] Like, this is how Codex Voice is built. [15:03] Right. [15:04] When GPT Live needs help [15:05] and you're using client delegation, [15:07] your application receives a delegation [15:10] event with an ID and a timestamp. [15:12] And then your harness can use [15:14] the conversation transcripts [15:16] and current state of your application [15:17] to render a backend request, [15:20] run the work, and then send those [15:22] results back to the voice model. [15:23] And you can choose how [15:25] those updates get sent back. Right. [15:27] Is this silent context [15:28] in the background? [15:29] Is this speakable content you [15:31] want the model to actually say? [15:32] Or is the system instructions [15:33] to actually fully steer how [15:35] the voice model behaves? [15:37] Just like we described earlier. [15:38] Now, if you want GPT Live [15:40] to manage those backend requests [15:42] for you, the alternative to client [15:44] delegation is responses delegation. [15:47] So you choose a model running through [15:49] OpenAI's responses API, configure its [15:52] instructions and tools, and GPT Live [15:54] supplies the conversation context. [15:56] In this setup, OpenAI manages [15:59] the delegations for you, so it can [16:01] be much, much easier to get started. [16:03] And if you've used tool calling [16:05] with any text model before, responses [16:07] delegation should feel really familiar. [16:10] You define functions, you're getting [16:11] structured outputs back, [16:13] you get function name and arguments, [16:15] your application will run [16:16] that and just send those results back. [16:19] With responses delegation, [16:21] you can also enable hosted tools [16:23] like web search or image generation, [16:25] which OpenAI will run for you. [16:27] And the Live API brings those results [16:29] back from the responses delegation [16:30] into the voice conversation. [16:32] This backend flexibility that we're [16:34] talking about right now is the most [16:35] underrated part of GPT Live. [16:38] You can keep your tech stack as [16:40] it is right now, including the model, [16:44] the agent harness, the evals, and then [16:46] you're just adding a voice interface. [16:48] It makes migration so [16:49] much more approachable. [16:51] Actually, Marin, we've just [16:53] covered a ton of content. [16:55] Can you summarize all [16:56] of that in like 15 seconds? [17:00] Okay. [17:01] Quick version. [17:02] GPT Live delegates work to a backend [17:04] while staying in the conversation. [17:06] You can use your own harness with client [17:08] delegation or let responses handle it [17:11] and send updates as silent context, [17:13] speakable text, or instructions. [17:15] That is well said, Marin. [17:17] So now for our last demo, [17:20] we're going to show how the turnless [17:21] architecture of GPT Live can let [17:23] you build applications that will [17:25] work in any environment, [17:27] no matter the background noise. [17:29] Marin, can you pull out that Live [17:31] dashboard again, please? [17:34] Sure. [17:35] Bringing the Live dashboard back. [17:38] Okay. [17:39] Let's put on some chill, [17:41] royalty-free sound effects. [17:45] On it. [17:46] Starting the background audio. [17:49] All right. [17:50] It's queuing up now. [17:54] I like it, Marin, but I think [17:56] we need it a lot louder. [17:57] Can you raise the volume to like 50 [18:02] You got it. [18:03] Raising it now. [18:05] Okay. [18:06] We're at 50%. [18:07] And maybe let's try something [18:09] a little different. [18:11] Marin, can you update the vibe [18:13] to more of like a wax [18:14] cylinder kind of recording? [18:16] Yeah, like 1888. [18:17] Bring us back. [18:19] Ah, yeah. [18:20] Going old school. Okay. [18:22] Wax cylinder vibes now rolling. [18:25] Marin, do you like this one? [18:26] You kind of like some throwback [18:27] vibes for you? [18:29] Kind of lovely. [18:30] It feels cozy and crackly. [18:33] Like we've stepped into [18:34] an old-timey radio hour. [18:36] Yeah, exactly. [18:39] Okay. This is revolutionary. [18:41] We're talking while very [18:43] loud audio is playing. [18:45] And I can ask questions, change my mind. [18:48] Marin can step in. [18:50] She's delegating. [18:51] She's not phased at all [18:53] by background audio. [18:54] And any voice model that uses [18:56] voice activity detection or silence [18:59] would just fall over here. [19:02] Marin, I love this ambiance. [19:04] I think we've proven our point. [19:06] Can you turn it down to like 15 [19:10] Yep. [19:10] Lowering it. [19:12] Okay. [19:13] It's down to 15%. [19:14] So this voice demo, I think, [19:17] shows how the turnless architecture [19:19] gives users so much more freedom. [19:21] If we take a step back and think [19:23] about what using voice in this demo [19:25] enabled, it flattened the controls [19:28] to make niche features like give us [19:31] an 1880s vibe accessible to the user. [19:34] Take any app with a lot of controls. [19:37] As a user, you might know what [19:39] you want to change or search [19:40] for, but you don't necessarily [19:42] know where that setting is. [19:44] And ideally, you should [19:46] be able to just ask. [19:47] Yeah. And voice is so information dense. [19:50] People are so much more willing [19:52] to talk for a couple minutes [19:53] than type that all out. [19:55] And that means that you get much [19:57] richer context from your users [19:58] about what they're trying to do. [20:01] Instead of waiting on silence [20:02] to take action or respond, the model [20:05] can take all of this noisy input [20:07] and constantly make interaction [20:08] decisions, whether to speak, [20:11] continue listening, or invoke a tool. [20:13] And this is incredibly powerful because [20:15] your users might be on a speakerphone [20:18] in an airport or in Fort Mason [20:20] at DevDay or in a manufacturing [20:22] facility or in a car [20:23] with a ton of people talking. [20:25] And they shouldn't have to find [20:26] a quiet place to talk to GPT Live. [20:29] GPT Live can keep listening [20:31] and responding while [20:32] the backend interprets requests [20:34] and runs those controls. [20:37] Okay. [20:37] Marin, to close this out, you are [20:40] our fastest and newest voice model. [20:43] But can you use our newest [20:44] and fastest image model to generate [20:46] 12 pictures of the DevDay [20:48] critters traveling the world? [20:51] You've got it. [20:53] Starting a 12-up goodbye grid. [20:57] Amazing. [20:58] Thank you, Marin. [21:00] Okay. We've had one running [21:01] session this whole time. [21:03] We played games. [21:05] We've made some images. [21:07] We brought in some audio. [21:09] We brought Colin in. [21:10] I almost forgot about that. [21:11] And now we're ending [21:12] with this delightful array [21:15] of DevDay critters. [21:18] And Marin has been [21:19] with us through all of it. [21:22] And our app has been making [21:23] the same decisions throughout. [21:25] What the backend handles, what [21:27] the interface shows, and what the voice [21:29] model needs to know and say. [21:31] So I hope you're all leaving [21:34] here today with some ideas about [21:36] how you can incorporate voice [21:38] into your own applications. [21:40] Things you might be dying to try now [21:42] that you've seen the model in action. [21:44] Marin, can you pull up [21:46] our goodbye resources? [21:51] Sure thing. [21:52] Here they are. [21:53] So, point Codex at the OpenAI [21:56] Developer plugin and our new GPT [21:58] Live Starter app and start building. [22:02] Marin, anything else you [22:03] want to add to close us out? [22:06] Just a big warm thank you. [22:09] I loved hanging out with you. [22:11] Oh, so sweet. [22:13] Thanks for being with us. [22:14] Okay. Thanks, everyone. [22:16] I hope you've had an amazing DevDay. [22:17] And we can't wait to see what [22:19] you build with GPT Live. [22:21] Thank you very much.