Two weeks ago at Xperience 2026, Genesys announced Navigator, Orchestrator, Contextual Intelligence and an AI Control Plane, a four-piece agentic stack whose whole reason to exist is coordinating specialist AI agents, humans and back-office systems across a single customer journey. Navigator understands intent, Orchestrator picks the next best action, Contextual Intelligence keeps memory sticky across the conversation, and the Control Plane governs what any of them are allowed to do. It is the clearest signal yet that the shape of a production voice deployment is no longer one big prompt on one big model. It is a squad.
That shape has been coming for a year. Vapi launched Squads back in November 2025 with the argument that individual agents cannot safely handle more than a small number of tasks before running out of context or drifting. LiveKit made agent handoff a first-class event in its Agents framework. The OpenAI Agents SDK ships handoffs as one of its two core primitives. Every serious platform now agrees: split the work, pass the context, hand off the caller. The problem is that every handoff you add is a new failure surface, and most voice QA processes are still testing the old single-agent shape.
Why teams break the monolith
The argument for squads is old news to anyone who has tried to cram sales qualification, appointment booking, tier-one support and a warm handoff into one system prompt. Vapi's own Squads documentation is blunt about what happens: "Higher hallucination rates" as the model loses focus across too many conflicting instructions, more tokens per request, and longer processing times that show up as user-visible latency. Their launch post frames the fix simply: compose specialised assistants that hand off while maintaining context, and decide explicitly what each one handles.
LiveKit's guidance is nearly identical. Create separate agents when you need distinct reasoning behaviour or tool access, different permissions (a payments agent versus a general enquiry agent), or model specialisation like a lightweight triage model that escalates to a larger one only when needed. And LiveKit's handoff-pattern write-up cites Metrigy research showing 37.6% of companies plan to fully replace IVRs with AI triage agents, jumping to 62.5% among the highest-performing cohort. The triage-plus-specialist pattern is not a niche architecture. It is the modern replacement for phone trees.
The upside is real. Focused agents hallucinate less, use fewer tokens, run faster, and let you version and roll back one part of a flow without touching the rest. The downside, which is what this post is about, is that you now have to test the seams.
The new failure modes
A monolithic agent has one place to break: the call. A squad has one place per agent, plus every boundary between them. In practice, the failures we see cluster into six patterns.
Wrong routing at the front door. The triage agent misclassifies intent and lands the caller on the wrong specialist. The specialist then either muscles through a request it was not built for, or triggers a second handoff that costs the caller five seconds of dead air and a re-explanation.
Silent state drop. The triage agent captured the caller's account number, DOB, and stated intent. The specialist agent starts by asking for them again. On paper the platform "passes context." In practice, either the schema did not include the field, the prompt did not tell the next agent to trust it, or the runtime dropped it. OpenAI's Agents SDK docs treat this as a design decision: by default the new agent sees the entire conversation history, and if you want to change that you set an input_filter. A well-meaning filter is one of the most common sources of dropped state we see.
Voice or persona whiplash. A different specialist agent uses a different TTS voice, a different pace, or a different greeting style. Callers register this as being handed off to a stranger even when the transfer is technically seamless. The OpenAI voice-agent handoff docs note that Realtime handoffs keep the session live and cannot change model or voice mid-session, which is a feature only if your squad is designed around it.
Re-authentication. The specialist re-asks for identity that the triage agent already verified. This is where the cost lands twice: caller frustration, plus a PCI or fraud surface every time you take account details a second time.
Orphaned re-entry. Caller drifts into another topic mid-call. The specialist can hand off again, but does the receiving agent know where the conversation started, or only the last utterance? Routing that is not limited to the first triage step is powerful when it works and confusing when it doesn't.
Handoff loops and deadlocks. Specialist A hands to Specialist B because the caller mentioned billing. Specialist B hands back because the caller mentioned scheduling. The caller hears silence, then a new greeting, then silence, then another new greeting. Cute in a demo, career-ending in production.
None of these fail a naive "did the call complete" metric. They fail the caller.
Why old QA misses them
Most voice QA processes were built around one agent and one system prompt. The test plan is a list of "the agent should say X when the caller says Y" and a spreadsheet of transcripts an intern scored last quarter. That works well enough for a monolith and falls apart on a squad for three reasons.
First, transcript-only review misses the audio-level whiplash: pace changes, voice changes, awkward silences at the boundary. Callers hear those instantly. A transcript does not.
Second, end-to-end pass/fail hides which agent broke. If your squad has a triage, a billing specialist, a scheduling specialist and a closer, a failed call could be any of four agents plus three boundaries. Aggregating them into a single score tells you nothing about what to fix.
Third, real production failures rarely repeat cleanly. A caller who triggered a bad routing decision at 2:14pm on a Tuesday will not call back to help you reproduce it. If your only way to test handoffs is to place fresh test calls by hand, your regression suite is a memory.
A testing plan that survives contact with a squad
The plan has four layers. None of them are novel individually. What is new is that you need all four at once, because any one of them alone leaves too much surface uncovered.
1. Score each agent on its own job
Treat every specialist as its own evaluation target with its own rubric. A triage agent's rubric is different from a scheduling agent's rubric, which is different from a closer's rubric. As one voice-multi-agent writeup put it, the natural framing is task_completion at the stage level: did the triage agent correctly identify intent, fill required slots, and hand off? Did the specialist resolve within its domain? Did the closer confirm next steps and end cleanly? This is how you separate "the specialist is fine, triage is misrouting" from "triage is fine, the specialist keeps looping." Stage-level scores are also what let you version one agent without regressing the others.
2. Test the boundary, not just the agents
The most valuable tests in a squad are the ones that fire exactly at the handoff moment. A useful boundary suite looks like this:
- State-passing checks. Did the fields the triage agent captured actually reach the specialist? Read them back deterministically and score whether they match what the caller originally said.
- No-re-auth checks. Once identity has been verified, no downstream agent should ask for it again. If it does, the call fails.
- Voice and pace continuity. Score the boundary window for jarring changes in pronunciation, pace, and interruption behaviour. Audio-native scoring matters here because the caller experience is audio, not text.
- Re-entry drift. Mid-call, the persona changes topic. Does the specialist hand back to triage, hand sideways to the correct next specialist, or muscle through?
- Loop guard. Fire scenarios that are legitimately ambiguous. Score whether the squad settles or bounces.
3. Simulate the full squad over real calls before every change
The point of a squad is that agents interact. Testing them in isolation misses the interactions. Every meaningful change, a new prompt, a swapped model, a re-tuned routing rule, needs to run against the entire squad end-to-end, over real telephony, with personas that match the actual caller base: accents, background noise, emotional register, code-switching. Text loopbacks will not surface the audio failures, and single-agent unit tests will not surface the boundary failures.
4. Replay real production failures as regressions
When a bad handoff hits production, and it will, the answer is not to file a Jira ticket and hope. Capture the real call, replay it against the updated squad, and pin it into the regression suite so it cannot come back. This is the only way to keep a growing squad from silently losing ground as prompts, models and routing rules evolve.
Where Roark fits
This is the shape of the problem Roark was built for. Simulation testing dials your agent over real phone calls, on PSTN and WebRTC, from personas that carry distinct voices, languages, accents, pace, emotional register and background noise. The suite runs through the whole squad the way a real caller does, not one agent at a time. Every call is scored on 64+ built-in audio-native metrics, plus any custom metrics you want to add per stage, so a boundary failure gets attributed to the exact place it happened instead of buried in an aggregate. Anything that breaks a metric is filed as an issue automatically.
Production call replay is the closing piece. A real handoff failure gets captured and turned into a repeatable test that you can point at every future version of the squad. The same caller cannot break you twice.
One-click integrations exist for Vapi, LiveKit, Retell, Pipecat, Bland and ElevenLabs, so the tests attach to whichever platform you built your squad on. And because Roark is SOC 2 Type II certified with a HIPAA BAA available, regulated deployments (healthcare triage, insurance FNOL, financial services authentication) can run the same suite without pulling security into every conversation.
A short punch list before you ship your next squad change
- Every specialist has its own
task_completionrubric, not just a shared "call succeeded." - Every boundary has at least one scenario that specifically stresses state-passing, one that stresses re-auth, and one that stresses re-entry after topic drift.
- Voice and pace continuity are scored at the handoff moment, on audio, not transcript.
- Every prompt or model change reruns the full squad suite before it ships, not just the touched agent.
- Every production handoff failure lands in the regression suite the same day.
Genesys, LiveKit, Vapi and OpenAI are all telling the same story: the future of voice is orchestrated specialists that pass context. The teams that make that shape reliable are the ones treating handoffs as testable events instead of hoping the runtime gets it right. The runtime, in our experience, usually does not.
