Short answer: on October 15, 2026, OpenAI added native Decisions integration to GPT-Live, so a voice session can request a decision without first routing through your application. That shortens the path from what a user says to what the system decides. It doesn't move responsibility. Your application still has to decide which actions are allowed, who is authorized to trigger them, when a human must confirm, and whether the change actually happened. A decision from the model is an answer. It isn't permission to change a business system.
For an owner running a voice-driven internal tool, that's the whole business implication. A faster path is useful, and it also means fewer natural pauses where your own code used to look at a request before anything moved. Those checks need to be deliberate now, not a side effect of the old architecture.
What changed on October 15
The OpenAI API changelog lists the entry under October 2026, dated Oct 15: "Added native Decisions integration in GPT-Live. Your app can act while your user is speaking or react to what Live says. Let Live call Decisions directly through native delegation, or trigger decisions as input or output transcript deltas arrive." That's the announcement date. The entry doesn't state a separate rollout or retirement date, so confirm availability in your own account rather than assuming it.
The linked voice guide spells out the difference between the two paths: "With custom delegation, Live notifies your app, which then calls Decisions. With native delegation, Live calls Decisions directly." Native delegation, in its words, "skips a round trip through your app."
Where the risk actually sits
With custom delegation, your app sat in the middle by design. Every decision request passed through code you wrote, which made it a convenient place to check scope, identity and intent. Native delegation removes that hop for the decision itself. So the question becomes simple: what does your application do with a decision once it arrives?
The guide also warns: "Live can combine pending deltas, and results can arrive out of order." That one line matters more than the speed gain. People change their minds mid-sentence. A request built from a partial transcript can be superseded a second later, and a result that lands late can describe a state that's already stale. Treat ordering as something your app enforces, not something it assumes.
Controls that should stay in your application
- An explicit allowlist of actions the voice tool may take. Anything not on it gets refused, whatever the decision says.
- Authorization checked against the actual user and their role at the moment of execution, not inferred from the conversation.
- Human confirmation before consequential changes: money movement, record deletion, access changes, anything customer-facing. A spoken yes should be captured as a distinct confirmation step.
- Idempotency and sequencing, so a combined or late-arriving result can't apply twice or overwrite a newer request.
- Read-back verification. Report success only after reading the real result from the target system, not after the call returns.
- An audit trail that records the transcript segment, the decision, who confirmed it and what the system state was afterward.
OpenAI's own example follows the same pattern: "When cabin_temperature is increase, change the setting, verify it, and send the result with session.commentary.append." Change, verify, then report. It's a vehicle illustration, not evidence about business workflows, but the shape transfers well to a ticketing system or an ERP.
How to test before you enable it
If you already run a GPT-Live integration on custom delegation, don't flip the path in production and watch. Run the cases that break voice systems in practice: a request that should resolve to no action, a user who corrects themselves halfway through, two results arriving in the wrong order, and a downstream system that fails or times out after the decision is made. Your tool should refuse cleanly, keep the newest valid intent, and say plainly when something didn't happen.
None of this argues for or against adopting the feature. It's a paid API, and whether the latency gain is worth it depends on your use case. What it does argue for is writing down the boundary between interpreting a conversation and authorizing a change, and making sure that boundary lives in code you control.