Build a CallSphere-Style Multi-Agent for Real Estate Lead Qualification

TL;DR — In real estate, speed-to-first-response is the metric. A 4-specialist setup (qualification, showing, pre-approval, follow-up) gets every lead a real conversation in under 30 seconds, mirrors CallSphere's OneRoof Property pattern, and can run on a single VM.

What you'll build

A multi-agent voice stack for a brokerage that hits inbound seller and buyer leads in under 30s, qualifies budget/timeline/financing, books showings on the listing agent's calendar, and triggers SMS follow-up sequences.

Prerequisites

1. CRM with API: HubSpot, Salesforce, FollowUpBoss, or similar.
2. MLS access (RESO Web API) for live listings.
3. OpenAI Realtime + Twilio Voice + SMS.
4. Python 3.11+, openai-agents[voice], fastapi.
5. Cal.com per agent for showing slots.

Architecture

flowchart TB
  C[Caller/Lead] --> TR[Triage]
  TR --> Q[Qualification]
  TR --> S[Showing]
  TR --> P[Pre-approval]
  TR --> F[Follow-up]
  Q --> CRM[(CRM)]
  S --> CAL[Cal.com]
  P --> LEN[Lender API]

Step 1 — Qualification specialist

```python @function_tool async def score_lead(budget_cents: int, timeline_months: int, financing: str, areas: list[str]) -> dict: score = 0 if budget_cents >= 50000000: score += 30 if timeline_months <= 3: score += 40 if financing in ("cash", "pre-approved"): score += 20 if len(areas) <= 3: score += 10 return {"score": score, "tier": "hot" if score >= 70 else "warm" if score >= 40 else "cold"}

@function_tool async def upsert_lead_to_crm(name: str, phone: str, email: str, score: int, tier: str, notes: str) -> dict: return await crm.contacts.upsert(name=name, phone=phone, email=email, properties={"score": score, "tier": tier, "notes": notes}) ```

Step 2 — Showing specialist

```python @function_tool async def find_listings(price_min: int, price_max: int, beds: int, baths: float, areas: list[str]) -> list[dict]: return await mls.search(price_min, price_max, beds, baths, areas, limit=5)

@function_tool async def book_showing(listing_id: str, slot_iso: str, lead_phone: str, agent_id: str) -> dict: booking = await cal.bookings.create( event_type=AGENT_EVENTS[agent_id], start_time=slot_iso, attendees=[{"phoneNumber": lead_phone}], metadata={"listing_id": listing_id}) ref = f"RE-{slot_iso[:10].replace('-','')}-{booking.id:03d}" await sms.send(lead_phone, f"Showing confirmed. Ref {ref}") return {"ref": ref, "booking_id": booking.id} ```

Step 3 — Pre-approval triage

```python @function_tool async def send_preapproval_link(lead_phone: str, lender_id: str) -> dict: link = await lender.application_link(lender_id, callback=lead_phone) await sms.send(lead_phone, f"Get pre-approved in 6 minutes: {link}") return {"sent": True} ```

Step 4 — Follow-up scheduler

```python @function_tool async def schedule_followup(lead_id: str, days: int, message: str) -> dict: when = datetime.utcnow() + timedelta(days=days) return await crm.tasks.create(lead_id=lead_id, due=when, body=message, type="ai_followup") ```

Step 5 — Triage prompt

```md You are the front desk for Westside Realty. Within 2 exchanges: classify the caller as buyer, seller, or current-client. Hand off to qualification (buyer/seller) or follow-up (current). Always disclose AI use at the start. ```

Step 6 — Inbound bridge

Twilio Media Streams → RealtimeRunner(starting_agent=triage). Same shape as previous tutorials. Add a 30-second SLA timer that pages the on-call agent if Realtime can't connect.

Step 7 — Outbound nurture

For warm leads, run a daily cron that pulls "tier=warm, no-touch >7d" and dials with the follow-up agent context.

Common pitfalls

• MLS rate limits. Cache listings for 5 minutes per query.
• TCPA compliance. Outbound to consumer cell phones requires written consent.
• Agent calendar drift. Use Cal.com webhooks to sync back into the CRM.

How CallSphere does this in production

OneRoof Property is exactly this pattern at production scale — 10 specialists over WebRTC + Pion + NATS. Healthcare's FastAPI :8084 ships 14 HIPAA tools. Salon's 4 ElevenLabs agents emit GB-YYYYMMDD-### refs (the RE-YYYYMMDD-### pattern above mirrors this). 37 agents · 90+ tools · 115+ DB tables. Flat $149/$499/$1499 pricing. Try /demo or /affiliate for partner referrals.

FAQ

TCPA? Inbound is fine; outbound to consumer cells requires PEWC.

MLS access? RESO Web API + a participating broker.

Multi-broker setup? agent_id everywhere; isolate by team.

Bilingual? Realtime handles Spanish/English seamlessly.

Cost? ~$0.07/min — at 1000 leads/mo, ~$280.

Sources

• RESO Web API
• Cal.com docs
• OpenAI Agents SDK voice
• /demo

## How this plays out in production Past the high-level view in *Build a CallSphere-Style Multi-Agent for Real Estate Lead Qualification*, the engineering reality you inherit on day one is graceful degradation when the realtime model stalls — fallback voices, repeat prompts, and confident "let me transfer you" lines that still feel human. Treat this as a voice-first system from the first prompt: the agent's persona, its tool surface, and its escalation rules all flow from that single decision. Teams that ship fast tend to instrument the loop end-to-end before they tune any single component, because the bottleneck is rarely where intuition puts it. ## Voice agent architecture, end to end A production-grade voice stack at CallSphere stitches Twilio Programmable Voice (PSTN ingress, TwiML, bidirectional Media Streams) to a realtime reasoning layer — typically OpenAI Realtime or ElevenLabs Conversational AI — with sub-second response as a hard SLO. Anything north of one second of perceived silence and callers either repeat themselves or hang up; that single number drives the whole architecture. Server-side VAD with proper barge-in support is non-negotiable, otherwise the agent talks over the caller and the conversation collapses. Streaming TTS with phoneme-aligned interruption keeps the cadence natural even when the user changes their mind mid-sentence. Post-call, every transcript is run through a structured pipeline: sentiment, intent classification, lead score, escalation flag, and a normalized slot extraction (name, callback number, reason, urgency). For healthcare workloads, the BAA-covered storage path, audit logs, encryption-at-rest, and PHI-safe transcript redaction are wired in from day one, not bolted on at compliance review. The end state is a system where every call produces a row of structured data, not just a recording. ## FAQ **What is the fastest path to a voice agent the way *Build a CallSphere-Style Multi-Agent for Real Estate Lead Qualification* describes?** Treat the architecture in this post as a starting point and instrument it before you tune it. The metrics that matter most early on are end-to-end latency (target < 1s for voice, < 3s for chat), barge-in correctness, tool-call success rate, and post-conversation lead score distribution. Optimize whatever the data flags as the bottleneck, not whatever feels slowest in your head. **What are the gotchas around voice agent deployments at scale?** The two failure modes that bite hardest are silent context loss across multi-turn handoffs and tool calls that succeed in dev but get rate-limited in production. Both are solvable with a proper agent backplane that pins state to a session ID, retries with backoff, and writes every tool invocation to an audit log you can replay. **How does the IT Helpdesk product (U Rack IT) handle RAG and tool calls?** U Rack IT runs 10 specialist agents with 15 tools and a ChromaDB-backed RAG index over runbooks and ticket history, so the agent can pull the exact resolution steps for a known issue instead of hallucinating. Tickets open, route, and close end-to-end without a human in the loop on the easy 60%. ## See it live Book a 30-minute working session at [calendly.com/sagar-callsphere/new-meeting](https://calendly.com/sagar-callsphere/new-meeting) and bring a real call flow — we will walk it through the live IT helpdesk agent (U Rack IT) at [urackit.callsphere.tech](https://urackit.callsphere.tech) and show you exactly where the production wiring sits.