Decisions Integration in GPT-Live: Setup, Triggers, and Migration
Learn how the native Decisions integration in GPT-Live routes voice requests, configures transcript triggers, and bypasses client delegation hops.
- Native Decisions integration connects gpt-live-1 directly to gpt-6-luna without routing requests through client applications.
- Delegation handles complex multi-action routing during speech, distinguishing device settings from heavy server execution via the Responses API.
- Transcript triggers run on session.input_transcript.delta or session.output_transcript.delta to drive reactive animations and UI cues in real time.
- Updating questions mid-call requires sending session.update and awaiting the matching session.updated confirmation event before appending items.
Native Decisions Integration in GPT-Live Architecture
On 2026-10-15, OpenAI published an update in the OpenAI API changelog bringing native Decisions integration in GPT-Live via the v1/live/sessions API. The integration allows voice applications powered by gpt-live-1 to evaluate user intent, select predefined action values, and trigger UI reactions before an audio turn completes. Rather than requiring client devices to intercept streaming transcript text and issue distinct inference requests, the Live session manages the delegation loop directly.
Previously, developers relied on custom client delegation. Under that pattern, the voice server communicated intent to the client software over WebRTC, the client software dispatched an external call to the Decisions engine, and the client software returned the resulting classification back to the session. Native delegation removes that intermediary round trip. When configured, gpt-live-1 invokes the lightweight gpt-6-luna model inside OpenAI infrastructure, delivering structured evaluations directly through session events. For systems coordinating tool calls or multimodal feedback, you can evaluate patterns in our overview of function and tool calling across Claude, GPT, and Gemini.
Native integration addresses two primary architectural requirements in low-latency voice agents: discrete intent delegation and transcript-driven interface reactions. Delegated actions allow an agent to isolate hardware controls from heavy generative workloads that require tools. Meanwhile, transcript-level triggers observe incremental chunks of user input or assistant output, producing instant categorical choices for interface avatars, indicators, or visual feedback components.
Configuring Native Delegation for Cabin Controls and Tool Routing
To activate native delegation, client applications must establish a WebRTC session using credentials granted the api.decisions.write permission scope. Standard Live connection headers apply; no Decisions-specific alpha header is necessary. The session payload places a delegation property inside the root session configuration object alongside existing transport settings. The session-level instructions instruct the conversational model on when to delegate, while each question schema defines the discrete categorical choices gpt-6-luna must return.
Consider a vehicle voice assistant managing interior temperature, window defogging, and external routing. The assistant needs to alter physical states when requested while escalating travel queries to external search tools. The session.delegation schema establishes independent choice questions that evaluate simultaneously across the incoming voice context.
{
"model": "gpt-live-1",
"instructions": "Delegate the driver’s whole request, including cabin controls, navigation, and local search. Wait for the app to report what happened, then tell the driver in natural language.",
"delegation": {
"type": "decisions",
"decisions": {
"model": "gpt-6-luna",
"questions": [
{
"type": "choice",
"name": "cabin_temperature",
"instructions": "Choose temperature_up if the driver feels cold or wants more heat, temperature_down if they feel hot or want to cool down, or none if the request is unrelated.",
"choices": [
{ "value": "temperature_up" },
{ "value": "temperature_down" },
{ "value": "none" }
]
},
{
"type": "choice",
"name": "windshield_defogger",
"instructions": "Choose on if the driver reports a foggy windshield or asks to defog it, off if they say the glass is clear now or ask to turn the defogger off, or none if the request is unrelated.",
"choices": [
{ "value": "on" },
{ "value": "off" },
{ "value": "none" }
]
},
{
"type": "choice",
"name": "needs_response",
"instructions": "Choose yes if any part of the request goes beyond these cabin controls, such as getting directions or finding restaurants. Otherwise choose no.",
"choices": [{ "value": "yes" }, { "value": "no" }]
}
]
}
}
}
When a driver states that they feel a little cold, the native delegation process forwards the transcript to Decisions. In a single request, Decisions independently resolves temperature_up for the temperature question, none for the defogger question, and no for the response requirement. Because gpt-6-luna performs this classification immediately, your local client software receives early notice to adjust physical settings without parsing unstructured text.
Handling Active State Updates, Commentary, and Responses Escalation
When the WebRTC session emits session.delegation.created, client code must preserve the associated delegation.id. Subsequent decisions arrive through decision.event objects carrying matching delegation_id values. Applications must verify that incoming payloads feature an event.type of decision.completed, then retrieve each named output from event.decision.answers. A value of none denotes that the respective subsystem requires no operational changes.
Whenever local hardware states change—such as setting the dashboard target to 22 °C in automatic mode with the windshield defogger off—the application records this context back into Decisions using decision.item.create. Appending state snapshots only when physical variables change retains the static prefix, optimizing token usage via prompt caching mechanisms. To understand cache dynamics across providers, review our analysis of prompt caching explained across Claude, GPT, and Gemini.
{
"type": "decision.item.create",
"event_id": "evt_cabin_after_temperature_up_1",
"item": {
"type": "message",
"role": "user",
"content": [
{
"type": "input_text",
"text": "Use the latest cabin state snapshot as the current state. Cabin temperature is set to 22 °C in automatic mode. Windshield defogger is off."
}
]
}
}
After receiving decision.item.created, client code informs the ongoing conversation using session.commentary.append with the active delegation_id. If user input extends past local controls—for instance, asking to defog the windshield, navigate to San Francisco, and discover restaurants—Decisions marks needs_response as yes. The client then turns on the defogger, updates the cabin state snapshot, and issues a server-side request to the Responses API using gpt-6.1-sol with api.responses.write permission.
curl https://api.openai.com/v1/responses \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6.1-sol",
"instructions": "The car has handled the cabin controls. Use the tools for the rest of the request, then briefly tell the driver what happened based on the results.",
"input": "Driver: My windshield is foggy, so please defog it, navigate to San Francisco, and find me some good restaurants there.\nCabin results: Windshield defogger confirmed on. Temperature unchanged.",
"tools": [
{
"type": "function",
"name": "start_navigation",
"description": "Start navigation to a destination and report whether the route started.",
"parameters": {
"type": "object",
"properties": { "destination": { "type": "string" } },
"required": ["destination"],
"additionalProperties": false
},
"strict": true
},
{
"type": "function",
"name": "find_restaurants",
"description": "Find well-rated restaurants in the named city or area.",
"parameters": {
"type": "object",
"properties": { "location": { "type": "string" } },
"required": ["location"],
"additionalProperties": false
},
"strict": true
}
]
}'
The backend handles function calls such as start_navigation and find_restaurants in standard sequence until generating a final answer. The application then feeds the concise summary of tool results back into the voice session via session.commentary.append. gpt-live-1 consumes this commentary to synthesize spoken confirmation to the user.
Real-Time Avatar and Gesture Control with Transcript Triggers
Beyond discrete task delegation, native Decisions supports low-latency reactive behavior via session.triggers. Instead of waiting for full conversational turns or complete sentence boundaries, triggers fire concurrently with streaming transcript deltas. Developers building digital avatars, dynamic character displays, or accessibility indicators can configure choice questions that evaluate expressions and gestures in real time.
Triggers can observe either inbound speech using session.input_transcript.delta or outbound agent speech using session.output_transcript.delta. When an incoming delta arrives containing a phrase like “I got the job!”, the input trigger prompts Decisions to select choices for expression, intensity, and physical gesture while the user continues speaking. To track how event streams flow across modern provider interfaces, see our reference on streaming LLM responses and event schemas.
{
"type": "decisions",
"event_type": "session.input_transcript.delta",
"decisions": {
"questions": [
{
"type": "choice",
"name": "expression",
"instructions": "Choose your expression as you listen to the person's latest words.",
"choices": [
{ "value": "neutral" },
{ "value": "happy" },
{ "value": "sad" },
{ "value": "concerned" }
]
},
{
"type": "choice",
"name": "intensity",
"instructions": "Choose how strongly to show that expression.",
"choices": [
{ "value": "low" },
{ "value": "medium" },
{ "value": "high" }
]
},
{
"type": "choice",
"name": "gesture",
"instructions": "Choose a gesture that fits what you just heard.",
"choices": [
{ "value": "none" },
{ "value": "nod" },
{ "value": "shake" },
{ "value": "lean" }
]
}
]
}
}
When evaluated, the session delivers a decision.event containing a trigger_id, the source_event_type, and the associated source_event_id. For example, hearing positive news can resolve to expression of happy, intensity of medium, and gesture of nod. Conversely, hearing negative statements like “I didn’t get the job” yields sad, low intensity, and a slight nod. Because transcript deltas can coalesce or arrive out of sequence over network channels, applications should map events to source_event_id and apply only the most recent state for each speech direction.
Comparing Delegation Architecture, Processing Hops, and Engine Roles
Understanding the division of labor between native delegation, custom client delegation, and separate backend execution pipelines is essential when structuring real-time conversational stacks. Each architectural choice shifts where decisions are parsed, what network hops occur, and which models perform evaluation.
| Execution Mechanism | Decision Evaluator | Network Hops | Configuration Target |
|---|---|---|---|
| Native Decisions Delegation | gpt-6-luna (OpenAI direct) | Direct internal session route | session.delegation |
| Custom Client Delegation | gpt-6-luna (Client triggered) | Live to client to Decisions to Live | Client event hooks |
| Responses Function Calling | gpt-6.1-sol (Server tool run) | Client to server to Responses API | https://api.openai.com/v1/responses |
| Transcript Triggers | gpt-6-luna (Live managed) | Internal delta triggers to client | session.triggers |
Native delegation offloads classification overhead from the main conversational voice engine gpt-live-1 to the specialized gpt-6-luna model. Because token pricing varies between smaller routing engines and larger reasoning models, selecting dedicated endpoints directly influences operational expenditure. You can calculate workload estimates using the LLM API cost calculator or inspect baseline token figures on the LLM API pricing reference.
Implementation Gotchas, WebRTC Event Filtering, and Checklist
Integrating native Decisions introduces specific lifecycle rules that require careful state management across the WebRTC data channel. The most critical operational considerations include:
- Delegation immutability: The delegation type must be declared during initial session creation. It remains fixed for the duration of that WebRTC session.
- Dynamic question updating: You can alter question lists during an active session by issuing session.update. However, your client must await the corresponding session.updated confirmation event before creating new decision items for that step.
- WebRTC filter configuration: If client code filters incoming WebRTC data events, allow session.delegation.created and decision.event. For transcript triggers, additionally allow session.input_transcript.delta, session.output_transcript.delta, or both.
- Event sequencing: Live can combine pending deltas, causing decision events to return out of strict numerical order. Retain source_event_id markers to apply only the freshest state updates.
- Visual synchronization: Drive mouth shapes and phoneme visemes directly from raw audio streaming rather than trigger deltas. Reserve trigger deltas for facial expressions, gestures, and general head poses.
- Commentary lifecycle: Always provide the relevant delegation_id when submitting session.commentary.append back to the active session.
By following this architecture, developers eliminate client-side routing latency, simplify multi-step intent delegation, and keep voice interactions fluid and responsive.