By Sagar Shankaran, Founder of CallSphere
Side-by-side architecture deep dive: Vapi Squads chained handoffs vs CallSphere OpenAI Agents SDK hierarchical orchestrator with return-to-parent flow.
Key takeaways
Vapi Squads wire multiple assistants into a chain inside a single call — one assistant transfers to the next, and the new assistant runs to completion. CallSphere uses the OpenAI Agents SDK with a hierarchical orchestrator pattern: a parent agent dispatches to specialists and the specialist returns control when done. The first model is great for predictable linear flows. The second is required when you need branching, fallbacks, and "go back to triage if scheduling fails" semantics.
If your call flow is "always greet, then qualify, then book," Vapi Squads will work. If your flow has loops, retries, and policy-driven routing, you want hierarchy.
Voice calls are messy. People interrupt themselves, change topics, hang up mid-sentence, restart with a new question. A clean chain (A → B → C) breaks the moment a caller in C says "actually, can you check the records again?" — you need to hop back to A or sideways to a Records specialist.
Vapi Squads model agents as a directed graph of transitions. Once you transfer, you live in the new agent's frame. You can transfer again, but you cannot "return to parent." That makes the call topology essentially a tree with leaves — you walk down, you do not walk back up.
CallSphere's hierarchy explicitly supports return-to-parent. Specialists complete, the orchestrator regains control with the specialist's structured result merged into context, and the orchestrator decides what is next.
A typical Vapi Squad config looks like this:
{
"name": "Real Estate Squad",
"members": [
{ "assistantId": "asst_greeter", "first": true },
{ "assistantId": "asst_qualifier" },
{ "assistantId": "asst_scheduler" }
],
"membersOverrides": {
"asst_greeter": {
"transferList": [
{ "destination": "asst_qualifier", "message": "Transferring you to qualification" }
]
},
"asst_qualifier": {
"transferList": [
{ "destination": "asst_scheduler", "message": "Booking specialist now" }
]
}
}
}
The flow is: greeter → qualifier → scheduler. Each assistant has its own system prompt, tools, and voice. Transitions are explicit and unidirectional unless you wire a back edge manually (which the model has no way to know about during reasoning).
Hear it before you finish reading
Talk to a live CallSphere AI voice agent in your browser — 60 seconds, no signup.
Strengths:
Weaknesses:
CallSphere builds on the OpenAI Agents SDK. The basic shape is a parent orchestrator plus N specialist agents that the orchestrator can hand off to and that return when done.
from agents import Agent, Runner, handoff
scheduling_agent = Agent(
name="SchedulingAgent",
instructions="...",
tools=[search_providers, schedule_appointment, send_sms],
)
records_agent = Agent(
name="RecordsAgent",
instructions="...",
tools=[lookup_patient, fetch_visits],
)
orchestrator = Agent(
name="Orchestrator",
instructions="""You triage healthcare calls. Hand off to scheduling for
appointment work, records for chart questions, and escalate to human for
clinical questions. Always summarize what the specialist returned before
closing the call.""",
handoffs=[
handoff(scheduling_agent, on_complete="return_to_parent"),
handoff(records_agent, on_complete="return_to_parent"),
],
)
result = await Runner.run(orchestrator, transcript)
The key flag is on_complete="return_to_parent". When scheduling_agent finishes its job (or hits a stop condition), control returns to the orchestrator with a structured handoff result attached to context. The orchestrator can then:
This is structurally equivalent to a function call returning, vs Vapi Squads' more JSR-style "jump and never come back."
CallSphere's Real Estate voice agent ships with a hierarchy of:
A typical conversation does not visit each specialist once. A buyer asks about a 3-bedroom in Sunnyvale (Property Search), then asks "can I afford this on $180K?" (Mortgage), then returns to Property Search to refine. Hierarchy makes this trivial; chained Squads would require manual back-edges between every pair.
A real handoff trace from a Real Estate call (sanitized):
Still reading? Stop comparing — try CallSphere live.
CallSphere ships complete AI voice agents per industry — 14 tools for healthcare, 10 agents for real estate, 4 specialists for salons. See how it actually handles a call before you book a demo.
[00:00.512] orchestrator: hand_off → property_search
payload: { intent: "search", filters: { city: "Sunnyvale", beds: 3 } }
[00:08.341] property_search: vision_analyze(photo_id=ph_4k2)
[00:11.119] property_search: search_listings(filters)
[00:13.882] property_search: complete → return_to_parent
result: { listings: [...3 items...] }
[00:14.110] orchestrator: hand_off → mortgage_prequal
payload: { income: 180000, target_price: 1.4M }
[00:18.502] mortgage_prequal: prequal_calc(...)
[00:19.881] mortgage_prequal: complete → return_to_parent
result: { max_loan: 1.1M, monthly: 7200 }
[00:20.044] orchestrator: hand_off → property_search
payload: { intent: "search", filters: { city: "Sunnyvale", beds: 3, max_price: 1.1M } }
That third hand-off (back into property_search with a tighter budget) is the exact case Vapi Squads cannot model cleanly.
| Dimension | Vapi Squads | CallSphere Hierarchy |
|---|---|---|
| Topology | DAG of assistants | Tree with return-to-parent |
| Return semantics | Explicit transfer back, manual | First-class return_to_parent |
| State sharing | Shallow (transfer message) | Full conversation + structured payload |
| Voice per agent | Easy (per-assistant) | Easy (per-specialist config) |
| Tool isolation | Per-assistant | Per-specialist |
| Reentry into prior agent | Manual transfer rule | Native handoff |
| Failure recovery | Hangup or transfer to fallback | Orchestrator catches and reroutes |
| Debugging | Vapi dashboard per call | Full handoff trace + Postgres logs |
| Agent count practical | 3-5 | 5-10 specialists comfortable |
stateDiagram-v2
[*] --> Orchestrator
Orchestrator --> PropertySearch: intent=search
Orchestrator --> Mortgage: intent=affordability
Orchestrator --> TourSchedule: intent=tour
Orchestrator --> Human: complex/legal
PropertySearch --> Orchestrator: complete (return)
Mortgage --> Orchestrator: complete (return)
TourSchedule --> Orchestrator: complete (return)
PropertySearch --> Mortgage: cross-handoff via parent
Mortgage --> PropertySearch: refine search
Human --> [*]: warm transfer
Orchestrator --> [*]: call ends
Hierarchy makes "specialist failed, fall back to human" trivial:
@handoff_returns
async def scheduling_complete(result: SchedulingResult, ctx: Ctx):
if result.status == "failed":
# Orchestrator picks this up and routes to human
return ctx.handoff_to(human_specialist, reason=result.error)
return ctx.close_call(summary=result.summary)
The Squads equivalent requires every member to know about the human-fallback assistant and emit a transfer rule for it.
Not as a first-class primitive. You can simulate it with a transfer rule that points back to the prior assistant, but the inbound assistant has no awareness it is "resuming" — it starts fresh.
Yes — the After-Hours voicemail agent is a single specialist with no orchestrator, because the flow is genuinely linear (capture, classify, route).
Three levels in production today: orchestrator → specialist → sub-specialist (e.g., Real Estate Tour Schedule has a sub-specialist for virtual vs in-person). Anything deeper tends to be a smell.
The OpenAI Agents SDK runs on OpenAI models, but the hierarchy pattern is portable. The CallSphere implementation can be ported to Anthropic or open-weight models with minor adapter work.
A hand-off costs roughly 80-150ms of additional roundtrip vs a flat agent because of the structured result merge. Below the human-perceivable threshold for voice.
The demo at /demo walks through a hierarchical Real Estate call with live trace, and /features documents the orchestrator + specialist patterns shipped per vertical.
Written by
Sagar Shankaran· Founder, CallSphere
LinkedInSagar Shankaran is the founder of CallSphere, where he builds production AI voice and chat agents deployed across healthcare, hospitality, real estate, and home services. He writes about agentic AI, LLM engineering, and shipping voice agents that handle real calls in production.
See how AI voice agents work for your industry. Live demo available -- no signup required.
Tbilisi professional-services firms serving relocating founders and IT companies use CallSphere AI voice and chat agents to answer enquiries 24/7 in English, Georgian and Russian and book consultations.
A how-to for Colombian education and tutoring SMBs to answer parents and students instantly, book trial classes 24/7 in Spanish and English, and grow enrollment with a CallSphere AI agent.
Ethiopian coffee exporters and cooperatives lose buyer enquiries across time zones. See how a CallSphere AI voice and chat agent answers international coffee buyers 24/7 in Amharic and English.
A practical how-to for Palau eco-resorts and dive operators on capturing every high-value, multilingual enquiry with a CallSphere AI voice and chat agent, while honouring Palau’s marine-conservation commitments.
How salons, spas and wellness SMBs across the UAE, Saudi Arabia and Qatar use CallSphere AI voice and chat agents to capture every booking 24/7 in Arabic, English and expat languages, and cut no-shows.
How estate agents and property managers in Luxembourg City and across the Grand Duchy use CallSphere to capture multilingual viewing and enquiry calls 24/7, GDPR compliant.
© 2026 CallSphere Inc. All rights reserved.
Made within San Francisco
Watch how CallSphere handles real customer calls, schedules appointments, and processes payments — live.
Try Live DemoBook a DemoCalculate Your ROI