In the last few months every serious voice-AI platform has shipped a warm-transfer story. LiveKit published reference implementations for agent-to-agent and agent-to-human handoff. AssemblyAI walked through building the same thing on its Voice Agent API. Retell and Telnyx have both put out extended write-ups on the mechanics. The capability is arriving fast, which means the surface area you have to test is arriving with it.
Warm transfer is the moment a voice deployment either earns trust or gives it back. Every other subsystem can work: ASR clean, intent right, tools called, latency low, and a clumsy handoff still leaves your caller repeating themselves to a confused human. As one recent write-up put it, handoff is where hidden production problems appear, and testing only the happy path is what makes them hidden. This post is a technical playbook for building a warm-transfer test suite that catches those failures before your agents ship.
What "warm" actually means in the pipeline
A cold transfer is a dial. A warm transfer is a small choreography: your agent decides to escalate, captures what happened so far, dials a human, plays them a private briefing, then bridges the caller into the same audio channel. Telnyx frames the same distinction cleanly: the AI owns the front of the call, captures structured context, then transfers to a human at the right moment with that context preserved.
There are three common shapes:
- Cold transfer. Route the caller to a queue. No context travels.
- Sequential warm transfer. Agent puts caller on hold, dials human, whispers a summary, then bridges.
- Conferenced warm transfer. Agent stays on the call as a third party after the human joins. Telnyx's Multi-Participant Voice AI is one shipped example; LiveKit exposes a WarmTransferTask primitive for a similar pattern.
Which one you use changes what breaks. But the five surfaces that need testing are shared across all three.
The five failure surfaces
1. Trigger accuracy
The trigger layer is the single most important design decision in the whole flow. Common triggers are: the agent's confidence drops below a threshold, the caller explicitly asks for a person, a compliance flag fires, a routing rule matches, or a tool fails. Each is a different classifier, and each fails in its own way.
What to test:
- Explicit request. Vary the phrasing. "Get me a human", "let me talk to somebody", "I need to speak to a real person", "can I get an agent". Include phrases embedded mid-sentence, phrases in second languages if you serve them, and phrases that are almost but not quite requests ("I'll ask a person later").
- Emotional escalation. Angry, tearful, resigned. Audio-native features carry information the transcript does not; a caller whose voice cracks may need routing before they ever say "human".
- Low-confidence detection. Force the agent into topics outside its knowledge base and verify it escalates rather than hallucinates.
- Tool failure. Kill an integration and check the fallback: does the agent transfer, or does it apologize in a loop?
- False positives. Callers who are venting but not asking to leave; sarcastic "sure, give me a manager" said in agreement, not frustration. Missed transfers cost trust; unnecessary ones cost cost.
2. Context capture
If the human joins and has to ask "what's going on", the handoff failed. Fini's checklist is a useful bar: the receiving side should get the full transcript, a structured summary, detected intent, and the actions the agent already took.
Test that context capture:
- Preserves specific facts the agent already collected: order numbers, dates, account IDs.
- Reflects the caller's stated intent, not the agent's inferred one.
- Includes tool-call outcomes ("I told them their refund window closed yesterday") so the human does not repeat a decision the agent already delivered.
- Handles calls where the caller switched intents mid-conversation, and the summary picks the right one.
3. Whisper briefing
The whisper is a private audio channel to the human before the bridge. Two things go wrong here, and they are both audible.
Content: the briefing is a summary the human hears out loud in fifteen to thirty seconds. If it rambles, the human hangs up mentally before the caller joins. If it is missing the reason for transfer, they enter the call blind. Score whispers on completeness and length, not just correctness.
Timing: while the whisper plays, the caller is holding. If your platform loops music or plays nothing, and the whisper drags to sixty seconds, callers drop. Measure whisper duration as an independent metric.
4. Bridge mechanics
This is the mechanical step everyone underestimates. When the caller and human land on the same audio channel, you can hit:
- Dead air on bridge. Nobody knows they should speak first. The AI has just handed off, the human expects the caller to restart, and the caller assumes the human was listening. Two seconds is uncomfortable, four is a hang-up.
- Double-hello. Both parties speak at once, half-duplex codecs clip, and the first exchange is unintelligible.
- AI still speaking. The agent has not fully released the mic, and its "connecting you now" tail talks over the human's introduction.
- Beep pollution. Some carriers announce join events with tones. If your agent narrates around them, it stacks noise on top.
- One-way audio. Rare in SIP, painful when it happens. Verify with real telephony, not simulated audio loops.
5. Post-bridge agent behavior
In sequential handoff, the agent should shut up. In conferenced handoff, as LiveKit describes it, the agent stays present but defers during human-to-human conversation and resumes only when addressed. Both patterns are testable.
- Does the agent interrupt the human's opening?
- If a caller asks the agent something after the handoff ("wait, what was the account number again?"), does it answer, or does it wait for the human?
- If the human asks the agent to do something ("pull up their last order"), does it execute the tool call correctly with the caller in earshot?
Building the suite
A warm-transfer test suite is a small set of scenarios per failure surface, run against every candidate build. The goal is not a hundred variations of the happy path. It is coverage of the failure paths the reviewer above cannot see from the transcript.
A minimum useful suite looks like this:
| Scenario | Surface tested | What it proves |
|---|---|---|
explicit_request_for_human | Trigger | The agent hears the phrase in a dozen variants and one accent |
angry_caller_escalation | Trigger (audio) | Voice-stress features route before the caller says "human" |
low_confidence_billing_dispute | Trigger | Agent bails out instead of hallucinating |
tool_failure_fallback | Trigger | A dead integration produces a graceful transfer |
context_summary_accuracy | Capture | Order number, name, and intent are all in the summary |
intent_switched_mid_call | Capture | Summary reflects the last intent, not the first |
whisper_duration_budget | Whisper | The briefing stays under 25 seconds |
dead_air_on_bridge | Bridge | Someone speaks within 1.5 seconds of merge |
human_declines_transfer | Bridge | Agent re-engages caller if human hangs up |
post_bridge_agent_silence | Post-bridge | Agent does not interrupt the first human turn |
Each row is a persona plus a scripted objective plus a set of assertions. What separates a real suite from a demo is that the personas run over real telephony, with real ASR, real TTS latency, and real barge-in. A text-loopback simulator will pass all ten of these and hide the exact bridge-timing bugs you built the suite to catch.
The metrics that make handoff testable
Transcript-only scoring is not enough here. Handoff bugs are audio bugs. The metrics that matter carry the sound of the call, not just its words:
- Dead-air duration at the bridge boundary, in milliseconds.
- Turn-taking overlap in the first three turns after bridge.
- Whisper duration as its own measurement, independent of the caller experience.
- Pace and pause distribution in the agent's closing sentence before it hands off, since a rushed goodbye is the leading cause of the caller not realizing the handoff happened.
- Post-bridge agent airtime. How much of the first thirty seconds does the agent still consume? For sequential warm transfer, the target is roughly zero.
- Emotion at trigger. Was the caller frustrated when the transfer fired, or two turns before?
Telnyx's guidance on transfer metrics recommends monitoring transfer rate by initial routing path, context preservation between handoffs, time-to-transfer from request to connection, and comparing warm versus cold outcomes. All of that is downstream of getting the five surfaces above right.
Regression is where warm transfer earns its keep
The most valuable warm-transfer tests you will ever have are the ones you learn from production. A caller yells at your agent for eight turns before the trigger fires. Save that call. The transcript, the audio, the timing. That specific failure becomes a scenario you replay against every future build. When you migrate from Retell to LiveKit, or from one LLM version to the next, you know instantly whether that caller is going to get transferred faster or the same or slower.
Production call replay is the piece that closes the loop. Without it, every regression is a bet. With it, every warm-transfer failure you see once becomes a test that runs forever.
Where Roark fits
Roark dials your voice agent over real phone calls (PSTN) and WebRTC, with personas that carry accents, emotional register, and background noise, so warm-transfer triggers get exercised the way callers actually exercise them. You can build a warm-transfer suite as scenarios and run it on schedule against every candidate build.
Every live call, once you go into production, is scored on Roark's audio-native metrics: pronunciation, emotion, vocal stress, pace and pauses, and interruptions. Dead air on bridge, whisper duration, and post-bridge agent airtime fall out of those primitives, and each failure gets filed as an issue automatically. Real handoff failures can be captured and replayed against updated agent logic as regression tests, so the same caller that broke you once cannot break you twice.
One-click integrations exist for Vapi, Retell, LiveKit, Pipecat, Bland, and ElevenLabs, so the tests attach to whatever stack you built your handoff on. The trigger layer, the context capture, the whisper, the bridge, and the post-bridge behavior are all things your callers will notice if they break. They are all things you can score before the caller ever hears them.
