After GPT-Live-1 and GPT-6 Astra: How Developers Should Use Realtime Voice, Agents, and the API Realtime voice, AI agents, and a practical API walkthrough

In one line: two names landed the same week, and a lot of people treated them as another stronger ChatGPT — what actually stalls developers is not the model name, but whether the voice layer, the reasoning layer, and the local execution plane should be wired together. Below we split realtime voice, the agent backend, and the API, then cover billing and isolation.

Split two jobs first: the model that talks and the model that acts

In September 2026, OpenAI shipped two building blocks in a row: GPT-6 Astra started rolling out on the 3rd, and GPT-Live-1 entered the API on the 10th. An earlier piece on the site, GPT-6 release timing forecast, answers “when it arrives.” Astra security concerns answers “how wide the blast radius is once you turn it on.” This article answers the third question: it’s here — how should developers wire it up.

Official docs split the jobs cleanly. GPT-Live-1 is the full-duplex voice frontend: listen, speak, handle barge-in, and decide when to hand work to the backend. Astra (or Terra / Luna) is the layer that reasons, looks things up, and calls tools. The Realtime API put voice, reasoning, and tools on the same model. GPT-Live splits conversation from tasks, and the session can keep going while the backend works.

GPT-Live-1: how to wire the realtime voice layer

GPT-Live-1 showed up in ChatGPT first, then entered the API on 10 September. It can listen and speak at the same time. On Full Duplex Bench, official evals put it about 30 points above GPT-Realtime-2.1; paired with Astra (medium reasoning), it ranked first on Tau3, which scores end-to-end voice agents. Speak’s early eval said language learners were interrupted nearly 80% less often than on the old turn-taking stack.

What developers actually choose is the connection, not another “better-talking Chat Completions”:

• WebRTC: browser voice. Mic and speaker ride media tracks; JSON events ride the data channel. The browser only emits SDP; the project key stays on the server.
• WebSocket: server-side audio integration. One connection carries both audio and control events.
• Phone / SIP: bring an existing call in. If you already run LiveKit, Twilio, Telnyx, or Daily/Pipecat, use the official partner path.

Rate limits are concurrent sessions, not tokens: Free is unavailable; Tier 1 is 25 sessions, Tier 5 goes to 500. Voice-layer pricing is $0.05 per minute, billed per second, not rounded up to a full minute. Knowledge cutoff is 31 July 2025. It does not take images, and it does not support Structured Outputs or fine-tuning.

After you create a session, wait for session.started before you speak. For sideband monitoring or hot instruction updates, add a server-side sideband WebSocket; audio still rides the main connection. Transcription, keyword biasing, and turn detection are built in — you do not need another STT layer.

GPT-6 Astra: how to wire the agent backend

Astra is the text-reasoning flagship, model ID gpt-6-astra, on Responses / Chat Completions / Bedrock — not on the Live session itself. Enterprise ChatGPT workspaces ship off by default; an admin has to turn it on. API pricing is about $10 per million input tokens and $50 per million output tokens. Eligible customers can enable Zero Data Retention.

When you wire it into a voice product, Astra should only appear in the delegation config — not as a parallel chat completion fighting for the same conversation. Official docs give two delegation modes:

Pick the mode when you create the session. Changing it mid-session returns immutable_field_update; you have to open a new one. Responses delegation supports function and web_search, plus the backend model’s own reasoning / text / max_output_tokens. Custom functions still run on your server, with permissions and confirmation. For lower latency, set delegation.responses.service_tier to priority (if the project has Fast enabled).

Astra’s safety boundary does not loosen just because you “wired it into voice.” The public build still refuses advanced offensive tasks; enterprise workspaces stay off by default. What it costs to hang a high-privilege agent on a daily computer is in Astra security concerns and when to hand Claude Code real permissions.

Three shipping combinations: pick the scene, then the model

OpenAI writes this itself: use a cheaper backend for scheduling and order lookups; escalate to Astra for messy support cases. Do not default to “voice product = Astra all the way.”

Only combo C needs the identity / disk / log split in how much infrastructure one AI agent actually needs. Always-on coding agents should not share a .env with a voice session either — see how to run a 24/7 AI coding agent.

API walkthrough: WebRTC + Responses delegation

The smallest useful path: the browser captures the mic → your HTTPS server creates a Live session with the project key and exchanges SDP → media tracks speak → the data channel receives transcripts and delegation events. The Session config below is the official Astra version — docs default to gpt-5.6-terra; swap to Astra for a flagship voice agent.

/** @type {import("openai/resources/live/live").SessionConfig} */
export const session = {
  model: "gpt-live-1",
  instructions: "You are a customer-support voice assistant. Handle greetings, clarification, and progress updates yourself. Order lookups, reschedules, and refunds must be delegated to the backend.",
  delegation: {
    type: "responses",
    responses: {
      model: "gpt-6-astra",
      instructions: "Handle only authorized order lookups and reschedules. Write operations go through functions first; wait for the application to confirm before continuing.",
      tools: [
        { type: "web_search" },
        {
          type: "function",
          name: "lookup_order",
          description: "Look up read-only status by order ID",
          parameters: {
            type: "object",
            properties: { order_id: { type: "string" } },
            required: ["order_id"]
          }
        }
      ],
      tool_choice: "auto",
      parallel_tool_calls: true
    }
  }
};

On the server, call POST /v1/live/sessions with the project key, swap the browser’s SDP offer for an answer, and hand it back to RTCPeerConnection. Neither the key nor the Session config should leave this server. When a function actually runs, read call_id / name / arguments from the nested response.output_item.done, run the authorized action, then append the result as a Responses item. response.output: [] in a terminal snapshot does not mean there is no pending function call.

# Pseudocode: exchange SDP on a trusted server. Never send OPENAI_API_KEY to the browser
import os, requests

def create_live_session(sdp_offer: str, session_config: dict) -> str:
    r = requests.post(
        "https://api.openai.com/v1/live/sessions",
        headers={
            "Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
            "Content-Type": "application/sdp",
        },
        params={"model": "gpt-live-1"},
        data=sdp_offer,
        timeout=20,
    )
    r.raise_for_status()
    return r.text  # SDP answer → browser setRemoteDescription

During a session you can hot-update the backend model, instructions, and tools with session.update — no reconnect. Setting delegation to null switches to Client mode, and you cannot switch an already-running Responses session back. Sideband supervision can pull the conversation back with session.instructions.append (delegation_id: null). That only affects the Live model; it does not change the Astra prompt, and it does not cancel a delegation already in flight.

Billing, rate limits, and isolation

Voice and reasoning are two bills. For token unit prices, see the token price comparison; here we only record what people miss when Live and Astra are wired together.

The isolation checklist is the same as the security piece, except a voice product adds “the session stays up”:

1. Keys stay on the server. The browser only submits SDP and plays audio.
2. Write tools default to human confirmation. Lookups can be automatic; refunds, inventory changes, and code pushes must pass your confirmation gate.
3. Split the agent identity from the daily desktop. Put high-privilege functions, Git tokens, and production .env on a dedicated Cloud Mac node. The main machine only reviews logs and merges.
4. Logs must answer three sentences. Which Live session, which delegation, what changed. If you cannot answer those, you do not have an audit trail.
5. Keep enterprise workspaces off by default. An admin turns them on when needed. A personal subscription should not wire Astra into a production repo in one step.

The correct read: GPT-Live-1 lowers the cost of speaking, not the blast radius. The common misread is “the voice layer is expensive, so run Astra the whole way and finish it in one delegation.” The stable move is combo B for volume, combo C for hard cases — and no write operations on a laptop.

FAQ

Are GPT-Live-1 and GPT-6 Astra the same model?
No. Live-1 is the full-duplex voice frontend; Astra is the text-reasoning and tool backend. Official docs recommend pairing them, not asking one model to do both jobs.

Should I migrate from the Realtime API to GPT-Live-1 immediately?
Prioritize browsers and new voice products. A stable Realtime pipeline can wait until you compare latency and barge-in. Changing the delegation mode requires a new session; you cannot hot-switch.

Does a voice session fold Astra token charges into the same bill?
No. They do not land in one line item. The voice layer bills per second, about $0.05 per minute; Astra and tools bill separately at their Responses rates.

Can I put the API key in the frontend page?
No. The project key must stay on a trusted server. The browser only submits SDP; the server calls POST /v1/live/sessions and returns the answer.