How to build an AI cold-caller in Make that's indistinguishable from a human

Most "AI cold caller" tutorials stop at a Vapi demo. You connect a voice, point it at a number, and it makes one call, and everyone claps. Then you try to run it on real leads at real volume, and the whole thing falls apart. There is another way, though. NeverMiss built an AI agent named Emma that cold-calls home-service owners, handles objections, and books jobs. She runs on a stack of Make scenarios that keep her from breaking, and is so realistic that people very rarely clock her as AI. They interact with her as if she were a human SDR.

Here is how Emma actually works, end-to-end.

What makes Emma sound human

Two things give a bot away instantly. The voice, and the gap between you finishing a sentence and the agent replying. Emma is tuned for both.

The voice: ElevenLabs inside Vapi

Model eleven_multilingual_v2, speed 0.9 (a touch under natural pace so she never sounds rushed), stability 0.5 so her tone varies instead of going robot-flat, similarity 0.9 so the voice stays consistent call to call. NeverMiss tested it against OpenAI and Deepgram voices. ElevenLabs won on breath patterns and micro-pauses.

Short replies, on purpose: GPT-4o-mini at temperature 0.4 – MaxTokens capped at 80 

That cap is the whole trick. It forces human-length answers instead of an AI monologue. Nobody on a real call talks in paragraphs.

The timing: waitSeconds 0.5

Emma waits half a second before replying so she never talks over you, and Vapi's smart endpointing knows the difference between you finishing your speech and just pausing. The single biggest "feels human" behaviour is the interrupt. Cut across her, and she stops inside 1 word. 

The opener is casual: "Hey, how's it going?" No corporate script. She can also fire a function mid-call to log the outcome (a booking included) as structured data, so action happens during the conversation, not after it.

What you'll need

1. Make to orchestrate everything.

2. Vapi to host the voice agent.

3. Twilio for the phone numbers (four, rotating, for caller-ID reputation).

4. ElevenLabs for the actual voice.

5. OpenAI GPT-4o-mini, used twice (the agent's brain and the call classifier).

6. Google Sheets as the CRM. One sheet, "NeverMiss – Outbound Calls."

7. Apify and Clay for the lead scraper (more on that at the end).

The system at a glance

• Difficulty: Advanced

• Build time: 3 to 4 weeks of iterative tuning

• Best for: Anyone running outbound voice at volume

• What it solves: No dropped, double-dialled, or lost calls

Everything revolves around one Google Sheet. The sheet is the CRM and the coordination layer at the same time. It tracks which lead is currently being worked on, so no two scenarios ever go after the same one at the same time. 

LEAD ENTERS SHEET (status = new)         |   [ dialler ]   every 5 min  -- claims the lead, locks it, fires the Vapi call         |   [ call happens ]         |   [ Logger ]    instant webhook -- AI reads the call, files the outcome         |         |--> [ CallBack Dialer ]  retries no-answers         |--> [ recording sync ]   pulls audio onto the row         |--> [ Reconciler ]       catches orphans         |--> [ Watch Dog ]        rescues stuck calls

Six core scenarios, six plain-English jobs.

How to build it?

The dialler: Placing the call

Every five minutes, the scenario picks the next new lead, marks it with its own unique tag, then checks that the exact tag is still there before doing anything else. That check is what stops two runs from calling the same person at once.

• Trigger: Schedule to every 5 minutes.

• Action: Take the lead, place the call through Vapi, and save the call reference back to the sheet.

The Logger: Capturing the data from each call

This is the step that makes the data useful. Vapi fires a webhook the second a call ends. The Logger matches it back to the row and routes on what happened.

• Trigger. Instant webhook (Vapi's end-of-call report).

• Action. If the customer talked, run the transcript through GPT-4o-mini and write structured notes. If they did not pick up, set a 2-hour retry. If the row is not ready yet, park the payload for the Reconciler

Here is what the classifier writes back. One clean object per call, zero manual note-taking.

{   "outcome": "booked",   "meeting_time": "2026-06-02T09:00:00",   "decision_maker": "yes",   "interest_level": "high",   "objection": null,   "summary": "Owner wants the AC looked at, booked Tuesday 9 am." }

Three safety nets that keep it reliable

• The CallBack Dialer: Phones back anyone who didn't answer, up to a set number of tries, and only once enough time has passed since the last attempt.

• Recording sync: Adds the call audio to the sheet afterwards, so the dialler never has to wait for it. 

• Reconciler: A safety net for the rare case where a call result comes back before the system has finished setting up its lead. It holds the result and matches it to the right lead a few minutes later, so nothing gets lost.

• Watch Dog: The dead man's switch. If Vapi ever fails to fire its webhook, Watch Dog finds the call stuck in "calling," clears the lock, and re-queues it. Without it, a lead sits in limbo forever while you think everything is fine.

Booking Flow 

When Emma closes a booking, a webhook fires a final scenario that writes the appointment straight onto the Google Calendar. Customer, job type, address, and notes are attached. The booking happens inside the call. The calendar event appears without anyone touching it.

Business impact

The numbers are what make this worth building.

Every call is auto-classified and logged the moment it ends. No rep writing notes, no CRM data entry. Successful bookings average 3 minutes 40 seconds of talk time. That is the same as a human SDR, which tells you prospects were not cutting the conversation short because they suspected they were talking to a robot.

Where the automation hit the wall and how to fix it

The system works, but the problem is the data. Most home-service numbers on public directories are not direct owner lines. They route through an IVR menu ("press 1 for service"), a call centre, or a front-desk receptionist whose entire job is keeping systems like Emma away from the owner. 

And current voice AI (Vapi, Retell, Bland) is still bad at IVRs. The agent hears "press 1 for service" and either sits silent or talks to a recording. 

Public main lines have a 10 to 15% owner connection rate. That burns money.

The fix is targeting direct owner mobiles, which skip IVRs entirely. To achieve it, you need to build two more Make scenarios.

• Lead Source: Apify scrapes home-service businesses from Google Maps (owner names included) and drops each one into a Clay table.

• Lead Handoff: Clay runs a waterfall across phone providers until it gets a verified mobile, then writes that lead into the Outbound Calls sheet as “status = new”. Twilio Lookup is the final gate that removes landlines and VoIP, the numbers that would just route straight back into an IVR.

Each verified mobile costs about $0.50 to $1.00 to find, depending on your providers. Against the value of a single closed job, you only need to land a handful of them for the whole thing to pay for itself many times over. Verified mobiles land in the sheet, the dialler picks them up, and the whole system runs the way it was meant to.

4 things to remember from the get-go

• Build the locks before you need them: You will not see double-call bugs until volume hits, and by then they have already annoyed a prospect. Add the lock columns on day one.

• Cap the agent's tokens: The biggest "sounds human" lever is forcing short replies.

• Always build the watchdog: Anything that depends on an external webhook needs a scenario that notifies you if the webhook does not fire.

• Test it on direct mobile numbers first, not office phone lines: if you call a company's main office number, you usually hit an automated menu, and the AI gets stuck before reaching a person. Direct mobiles get answered by a real person, so you're testing the agent, not the menu.