In this article
When commissioning an AI phone agent, the decision is not simply whether it can hold a convincing conversation. You need to know which component answers the phone, conducts the live exchange, performs deeper model work, runs business functions, and transfers a caller to a person.
A demonstration can make these activities appear to be one seamless capability. Twilio’s documented GPT-Live example separates them across telephony, application code, a live voice model, a delegated model, and tools. Human escalation uses an additional routing architecture rather than occurring automatically.
This is a documentation-based component map, not a performance evaluation. No hands-on calls or measurements were conducted.
The component map
In Twilio’s inbound-call tutorial, Programmable Voice and Media Streams carry the call, a Node.js application connects the systems, GPT-Live-1 handles the caller-facing conversation, and a delegated model is configured for additional work (Twilio’s GPT-Live tutorial).

Caller
|
v
Twilio Programmable Voice + Media Streams
|
v
Node.js application
|
+--> GPT-Live-1: live speech and conversation
|
+--> Delegated model: deeper work and tool requests
|
+--> Web search
|
+--> Application-defined function
|
v
Application executes code
|
v
Result returns to model
Separate escalation route:
AI session -> handoff tool -> Twilio Studio -> Flex -> person
This diagram represents the cited examples, not a required design for every phone agent. Its value for a small-business buyer is in exposing ownership: Which component performs each action, and what should happen when it cannot complete that action?
Live conversation and delegated work
The tutorial configures one model for live voice and another for delegated work:
Live voice model: gpt-live-1
Delegated model: gpt-5.6-terra
These names are configuration choices in the retrieved tutorial. They should not be treated as requirements for every application.
Twilio describes the caller as speaking with a responsive voice model while another model is available for deeper reasoning, web search, or more complex work. The delegation configuration includes the delegated model, its instructions, and its available tools (Twilio’s GPT-Live tutorial).
That distinction matters when reviewing a proposal. “The agent can search or reason more deeply” does not explain when delegation occurs, which tools are available, or what happens if no useful result returns. Delegation is a configured capability, not evidence that every suitable request will automatically be delegated or answered correctly.
Ask the developer to identify:
- Which requests may be delegated
- What instructions the delegated model receives
- Which tools it can request
- What the caller hears while work is pending
- What happens when no usable result returns
For basic call handling, a smaller conversational scope without delegated work or external tools may be sufficient. Some call types may remain human-led.
Telephony, startup, and the greeting
In the documented example, the voice model does not handle phone transport by itself. Twilio Programmable Voice and Media Streams carry the call, while the Node.js application bridges that transport to GPT-Live-1 (Twilio’s GPT-Live tutorial).
The session also has an explicit startup sequence:
- Twilio supplies the stream identifier.
- The application sends
session.start. - That event carries the selected model and session configuration.
- GPT-Live-1 replies with
session.startedwhen ready.
The greeting is another application-controlled step. After session.started, the tutorial app sends a “say this verbatim” instruction and triggers the model to speak, causing the configured opening to occur before the caller speaks (Twilio’s GPT-Live tutorial).
That documents how the example controls its opening message. It does not establish that the wording satisfies any legal or regulatory requirement.
A tool request is not tool execution
The tutorial includes web search and application-defined functions. These should not be compressed into the claim that the model simply “takes action.”
For an application-defined function, the model returns a function call containing a name and JSON arguments. The application runs the function, sends its output back, and requests continuation of the response (Twilio’s GPT-Live tutorial).
Model requests function
|
v
Application receives request
|
v
Application code executes function
|
v
Output returns to model
|
v
Voice model explains result
A tool request does not prove that the function executed correctly, had suitable permissions, reached a business system, or returned accurate data. Those remain application and operational decisions. When considering custom application patterns, keep the model’s request separate from the code allowed to retrieve or change business information.
Human handoff is a separate route
Twilio’s documented human-escalation architecture requires additional components: a registered handoff tool, Twilio Studio, and Flex (Twilio’s handoff architecture).
In that voice flow:
- The model invokes the configured handoff tool.
- A payload containing active conversation context is stored.
- The system waits for the AI’s final response to play.
- The voice channel sends a WebSocket end message with the payload.
- The call is routed into a Studio flow.
- Studio passes context to Flex as task attributes.
- Flex routes the call according to the defined workflow.
This route is distinct from the inbound GPT-Live tutorial. Transfer therefore should not be assumed merely because a voice model can converse or request tools.
The business must also specify what accompanies the caller. Twilio discusses conversation history, identifiers, profile references, custom attributes, and summaries as possible handoff context (Twilio’s context guidance). Passing those items does not establish that they will be complete, accurate, or useful.
Commissioning checklist
Before approving a design, ask:
- Who owns the number, call routing, and media stream?
- Which component listens and speaks?
- What work can be delegated, and what triggers it?
- Which searches and application functions are available?
- Where does business code run, and what permissions does it receive?
- Who manages session startup and the opening message?
- When can a caller request a person?
- Which system selects the employee or queue?
- What context accompanies the transferred call?
- What happens if a tool or transfer route is unavailable?
- Is human transfer included, or is the flow explicitly AI-only?
These questions clarify what is included in proposed AI and application services. They do not validate performance, but they distinguish the application’s parts and the operational decisions your business still needs to make.
If useful, talk through your workflow.
No comments yet