Nearly one in four healthcare appointments never happens. A systematic review of 105 studies put the average no-show rate at 23%, and in an August poll, 32% of medical groups said rates were higher in 2026 than in 2025, up from 27% a year earlier. Record deductibles are leading patients to second-guess visits they booked six weeks ago. The cost shows up in revenue, but also in a screening that slips or a follow-up that turns into an urgent visit.
This post shows how to build an outbound voice agent on ElevenAgents that calls patients before a visit, verifies their date of birth, and confirms, reschedules, or cancels the appointment in the electronic health record (EHR) during the call. The slot goes back into inventory while there’s still time to fill it. The agent was built withArchitect, the assistant inside ElevenAgents, and it can run as a nightly batch or in real time from EHR events.
The approach is already working. Everlywell uses ElevenAgents to remind members about eligible screenings, and it saw a 10% improvement in screening completion versus traditional interactive voice response (IVR), with 3.5x higher conversion among Spanish-speaking members. Ovianta uses ElevenAgents to follow up after treatment proposals, reaching a 68% patient engagement rate, a 25% increase in treatment conversion, and an 83% reduction in manual follow-up calls for clinic staff.
This is the second post in a healthcare series. The first covered an inbound scheduling agent that answers when patients call to book. To run the outbound agent across a whole patient list, care teams can use Campaign Manager, now in ElevenAgents. It handles calling windows, local-time dialing, retries, and voicemail, and it tracks every patient in one funnel from first call to confirmed visit.
How clinics fight no-shows today
Most practices already run some kind of reminder program. Front-desk staff calling patients by hand is difficult to scale. These types of calls happen only during business hours, using the same people who answer the inbound line, so it stops once the schedule gets busy.
Text and email reminders are inexpensive to run, able to reach everyone, but usually run one way. Engagement drops for older patients and for anyone whose first language isn't the one the text was written in.
Automated IVR calls sit in between these methods. They scale, and they use the phone. However, a “press-1-to-confirm” menu still cannot handle a reschedule, cannot verify identity to any real standard, and hands off badly when the patient asks a question.
Outsourced call centers give you human conversations at volume, but at a high cost-per-call. This approach comes with quality that varies by shift and with more people handling protected health information outside your organization.
The research points one way on delivery: a reminder that reaches the patient live does far better than one that doesn't. A Veterans Health Administration study found a 3% no-show rate when a phone reminder reached the patient live, 24% when it went to voicemail, and 39% when nobody answered and no voicemail was left. For many health systems, only a front-desk call can verify the patient and change the schedule in the same touch, but it doesn't scale. With ElevenAgents, health systems can now proactively reach patients, make real-time changes to their schedule, and scale their outreach.
What we're building
The outbound reminder agent runs on the same platform, tools, and security review as the inbound scheduling agent, so one vendor covers both the front door and the follow-up. It calls the patient ahead of the visit, confirms their identity, and reads the live appointment from the EHR. From there, it confirms, reschedules, or cancels the appointment against the provider’s open slots.
The agent also handles the edge cases. If the call goes to voicemail, it leaves a message. If a patient asks not to be called again, it records the opt-out so no future calls go out. If a patient wants to talk to a person, it transfers to the front desk. A nightly export can trigger it as a scheduled batch, or real-time EHR events can trigger it one call at a time.
ElevenLabs built this agent with Architect, the assistant inside ElevenAgents that reads and edits an agent’s configuration, workflow, tools, and tests from a chat. The previous post configured every node by hand. This time, the call was described in plain language, and Architect built the workflow.
Prerequisites
To build the outbound agent, you’ll need:
- An ElevenLabs account with ElevenAgents.
- A Twilio number imported into ElevenAgents, or a SIP trunk.
- A sandbox EHR. We use the public HAPI FHIR R4 server with synthetic patient and appointment records. Nothing real goes on that server; it is world-readable.
- No separate calendar. Scheduling reads and writes the EHR's Schedule, Slot and Appointment resources, the way a practice management system does.
- For the real-time path only: somewhere to run a small trigger service that listens to your EHR and calls the ElevenLabs API. A serverless function is enough.
Seed one synthetic patient and one appointment so the agent has something to remind you about:
Then seed a Schedule for the provider and a handful of free Slots on it: one POST /Schedule, and one POST /Slot per opening with a schedule reference, status free, and a UTC start and end. Keep the three IDs. The patient ID becomes patient_id (and, prefixed with Patient/, patient_reference), the appointment ID becomes appointment_id, and the schedule becomes fhir_schedule_id.
Architecture
The agent is the same no matter how a call starts. What differs is the trigger, which determines freshness, cost and compliance posture.
Path A: scheduled batch
Let’s imagine that each evening, a job queries the EHR for tomorrow's appointments:
The job flattens each appointment into one row and converts the UTC timestamp into clinic-local words, because the agent reads the time aloud and a TTS model should not be guessing how. phone_number is the only required column. Every other column becomes a dynamic variable the agent can use in its prompt, first message and tool calls:
Phone_number, patient_first_name, patient_last_name, patient_id, patient_reference, appointment_id, appointment_date, appointment_time, provider_name, visit_type, clinic_name, clinic_callback_number , +15550100199, Maria, Okonkwo, 81660, Patient/81660,81661,"Tuesday, October sixth", ten a.m., Dr. Okafor, follow-up visit, Lakeside Family Medicine, "five five five, zero one zero zero", +15550100244, Daniel, Reyes, 81702, Patient/81702, 81718, "Tuesday, October sixth", nine thirty a.m., Dr. Okafor, annual physical, Lakeside Family Medicine, "five five five, zero one zero zero"
That file goes to Batch Calling, uploaded in the dashboard or submitted through the API. You pick the agent, the outbound number and a start time inside your calling window. Batch calls draw on a capped share of concurrency (the lower of 50% of the workspace limit or 70% of the agent's), so a big reminder run doesn't starve the inbound line.
The export job also owns the retry policy. Anyone who ended in voicemail or no answer goes back on the next day's list at a different hour. Three attempts per patient per week is the ceiling, and a confirmed, canceled, rescheduled or opted-out outcome removes them. The export job owns every retry decision. For a practice that books most visits more than a day out, batch is the right default and the least work.
Path B: real-time from the EHR
Batch has a blind spot: anything that changes after the export, such as same-day bookings, a patient who moved from 8am to 3pm, or a slot that opened after a cancellation. For those, a small trigger service listens to appointment events from the EHR (a FHIR Subscription, a webhook from the practice management system, or a job that polls every few minutes) and places one call at a time through the outbound call API:
twilio_machine_detection turns on Twilio-side answering machine detection alongside the agent's own voicemail tool, which we cover under Tools. And because each call starts individually, it can run under Zero Retention Mode, which batch calls cannot.
Choosing between them
Scheduled batch
Real-time trigger
Setup
Dashboard or one API call
Small trigger service
Freshness
As of the export
Seconds after the EHR changes
Same-day bookings and late changes
Missed
Covered
Zero Retention Mode
Not available
Available
Concurrency
Capped share of workspace
Whatever you send
Best for
Next-day reminders at volume
Same-day changes; deployments that require ZRM
A practical setup runs both. Batch carries the bulk of next-day reminders, while the real-time path picks up whatever moved after the export and anything that must run under ZRM.
One system of record
The agent reads the appointment from FHIR and changes it in FHIR. Open times come from Slot, a reschedule is a PUT on the same Appointment the agent just confirmed, and a cancel sets its status. There is nothing to reconcile against the chart afterward, the EHR is correct the moment the call ends, and every write the agent makes is a FHIR resource your audit log already covers. The post-call webhook still carries the outcome to anything downstream. If your practice runs a separate scheduling system, swap the three scheduling tools for that system's API; the two workflow nodes stay the same.
Caller ID
Patient outreach is difficult if the phone shows "Spam Likely." Before the first batch, register the outbound number so calls carry full STIR/SHAKEN attestation, set CNAM so the clinic name displays, and look at Twilio's branded calling options for the carriers your patients are on, because a reminder that gets screened doesn’t happen.
Building it with Architect
In the inbound post, every node, tool and edge condition was configured by hand. Here we started with an agent that had the FHIR tools attached, the system tools enabled, a base prompt covering role, boundaries and how to speak, and nine simulation tests. No workflow. We opened the Architect tab and described the call:
Build an outbound appointment reminder workflow for this agent. Open by stating the clinic name, that this is an automated call about an upcoming appointment, and asking for the patient by first name using the patient_first_name dynamic variable. If the person who answers is not the patient, do not share any appointment details, offer a callback window, and end the call. Once we are speaking to the patient, ask for their date of birth and verify it with @fhir_get_patient. Treat total 1 as verified. Allow one retry on a mismatch, then end the call. After verification, call @fhir_get_appointment and confirm the appointment using what it returns. If the patient confirms, recap and close. If they want to reschedule, ask what day suits them, call @fhir_get_available_slots for that day, offer at most two of the returned slots in clinic time, and when they choose call @fhir_reschedule_appointment with that slot's exact start, end and id. Say the new time is booked only after that call succeeds. If they want to cancel, confirm once, call @fhir_cancel_appointment, and offer to rebook from the same slots. If a scheduling tool fails twice, do not transfer; say the original appointment still stands and the office will call back. If they ask for a person twice or describe urgent symptoms, tell them you are connecting them and transfer to the front desk. Route every transfer through a short notice node so the patient always hears that line first.
Architect built the workflow in stages, pausing twice: once to ask about unsaved edits in the editor, and once to ask whether to finish the rest of the flow before publishing. Architect came back with eleven nodes and named them itself: a start node, Confirm who answered, Not the patient: offer callback, Verify date of birth, Confirm appointment, Reschedule, Cancel, Recap and close, a Transfer notice node that speaks one fixed line, a Front desk transfer node, and an end node.
Tool scoping landed correctly. fhir_get_patient lives only on Verify. fhir_get_appointment lives only on Confirm. The scheduling tools live on Reschedule and Cancel. Architect also removed the agent-level transfer_to_number tool so the only path to the front desk runs through the notice node, and it flagged two things it could not finish on its own: a setting on the Transfer notice node that had not saved, and two lines in our base prompt that still told the agent to call a tool that no longer existed. Architect offered to rewrite those lines or run the tests, and we had it rewrite both.
What the tests found
Five of nine passed. Two of the failures were exactly what a reminder agent exists to prevent. In the confirm scenario, the agent read out "Monday, October fifth at two p.m. with Dr. Okafor," the moment the patient said "yeah, this is Jack," before any date of birth had been checked and identity verified. In the reschedule scenario, no scheduling tool was called at all; the agent announced a new time it had invented. Two more tests had not run because their fixtures lacked a patient_id variable.
Architect’s first instinct was containment: put the tools back on the base agent so the call works even if the workflow doesn’t take over. The team asked it to investigate first, and less than a minute later, Architect had the cause.
Each node hands off to the next by calling a hidden step-change tool, and the model decides on every turn whether to call it. In the cancel test, the model called it at every step and walked the intended path. In the two failures, the model answered “yeah, this is Jack” directly and never left the opening node, where none of the FHIR tools exist.
Two things made that more likely. The base prompt still carried the full appointment details and described the whole call, so the opening node believed it could handle everything itself. The opening node’s prompt also said what not to share but never told it to hand off.
Architect proposed a fix in three parts, and the team approved it:
- Move the appointment details out of the base prompt and into Confirm appointment only, so a node that never sees the details cannot leak them even when a step change fails.
- Rewrite every node prompt to state its one job and to hand off the moment its exit condition is met.
- Switch the model from Haiku to Sonnet, since the hand-off decision is probabilistic and a stronger model misses it less often. Then rerun the suite, with the two failing tests three times each.
On the rerun, confirm and reschedule passed three out of three. The details stayed behind the verification gate and nothing was invented. Architect also repaired the five tests that had been missing patient_id, and reworded a check in the escalation test that still looked for transfer_to_number. What remained was smaller. The second-mismatch path ended the call without saying the office would follow up, and in one of three runs the clinical-question scenario skipped the offer to note the question for the visit. One remaining failure belonged to the grader, which counted the opening "Am I speaking with Jack?" as asking who the caller was. We told Architect to fix the agent and leave that test alone. It added a twelfth node, Verification failed: follow up, between the second mismatch and the end node, added one sentence to the confirm and recap prompts, and opened the publish dialog for review.
Two things from our plan turned out to be unnecessary. We had drafted follow-up prompts for voicemail handling and for an opt-out path. The voicemail detection system tool and record_dnc_optout were on the base agent before Architect started, and both scenarios passed on every run.
What a live call found
The simulations passed. The first real calls to a phone found three things the tests could not.
The agent repeated itself. The Confirm node said “Of course, let me get that sorted,” handed off, and the Reschedule node opened with “Of course, let me pull up your booking.” Each node starts from its own prompt, so the model acknowledged twice, and it said “you're all set” before anything was set. We gave Architect the conversation ID and asked for one voice across steps: no acknowledgement after a handoff, the outcome spoken once, in the recap. It added that section to the base prompt, rewrote the Confirm and Reschedule prompts, changed the Reschedule and Cancel exit conditions so a scheduling failure ends in a callback promise rather than a transfer, and wrote a tenth test for that path.
The agent cut itself off twice during verification. The transcript showed fragments of its own question arriving as patient speech: speakerphone echo, not a model problem. Architect confirmed the node type has no interruption setting, so the fix is a handset.
The write to the EHR looked right and was not. When Architect created fhir_reschedule_appointment and fhir_cancel_appointment, it stopped on the two array fields a FHIR Appointment needs, participant and slot. It said it could not author them from chat and warned that leaving them out would drop the patient from the appointment. We added them in the tool editor, with the wrong element type. The next call moved the appointment to the chosen slot, the server kept the new time and silently discarded both arrays, and for a minute the appointment had no patient on it. Every test was green, because the mocks never reach the server. Reading the resource back is what caught it.
Three rules we followed using Architect on a healthcare agent:
- Name tools with @. Writing "the cancel tool" invites a guess; @fhir_cancel_appointment does not.
- Architect conversations are not covered by Zero Retention Mode. Describe the agent with synthetic examples. Never paste real patient data into the chat.
- Architect's strongest mode is after launch. The agent's Architect home shows a review queue of flagged conversations. Pointing it at a transcript where the agent slipped, and asking it to change the workflow so that cannot happen again, is faster than finding the edge yourself.
Agent settings
The settings mirror the inbound agent where they can. Eleven v4 for text-to-speech with Expressive Mode off, Scribe v2 Realtime for transcription with the patient's surname and the provider's name added as keyword boosts, Turn Model v3, and Claude Sonnet 4.6 as the LLM at temperature zero, per Architect's recommendation. ElevenLabs builds each of these models, which is why surname and provider-name boosts are a setting, not a workaround. Soft-timeout fillers ("Okay, one second") cover tool latency so the line never goes dead while FHIR responds.
The first message is fixed text with two variables:
Hi, this is Priya, the automated assistant from {{clinic_name}}, calling about an upcoming appointment. Am I speaking with {{patient_first_name}}?
One sentence on the clinic name itself. For a family practice it is harmless. For a behavioral health, oncology or HIV clinic, the name alone discloses something to whoever picks up. Use a neutral parent organization name in the opening and the voicemail script if that applies to you.
System prompt and guardrails
The base prompt follows the structure from the prompting guide: role, what the agent knows about this call, identity rules, tools, call-specific rules, speaking style, boundaries, crisis handling.
Four things differ from the inbound agent:
- The agent placed this call, so it must earn the conversation. The first message states the clinic name and that this is an automated call about an upcoming appointment, then asks for the patient by first name. Some states require disclosing an AI voice; the disclosure requirement page covers where.
- The agent confirms who it is talking to before it says anything specific. The appointment details are in the dynamic variables, but the person who picked up might be a spouse, a child, or a stranger with a recycled number. Until the date of birth matches the record, the agent says "an upcoming appointment" and nothing more. The prompt states this rule, then restates it under call-specific rules.
- We set the verification bar lower than the inbound flow, on purpose. There, an unknown caller had to clear an EHR match and an SMS one-time code. Here, the clinic dialed the number on the patient's record. Possession of that phone plus a spoken date of birth that matches the FHIR record is a defensible bar for confirming, moving, or canceling an appointment. If your policy needs a second factor when the answering number doesn't match the record, the Twilio Verify tools from the inbound post drop in unchanged.
- The speaking rules account for the call being an interruption. Two sentences is a complete turn, and "no" is an acceptable answer.
Clinical boundaries carry over unchanged: no diagnosis, no treatment or medication advice, no billing, and immediate transfer on urgent symptoms. Outbound adds two additional rules: honor a request to stop calling on the spot and never call outside the clinic's window.
Runtime Guardrails back the prompt, same as the inbound agent: Focus to hold the prompt over a long call, Manipulation to catch injection, and Custom guardrails for the clinical rules. For the urgent-symptoms guardrail we use retry with feedback, so the corrected turn tells the agent to transfer instead of the call simply ending.
Tools
Patient and appointment lookup
fhir_get_patient runs a GET /Patient search scoped to this patient's record: _id comes from the recipient list, the LLM supplies only the date of birth the patient spoke in YYYY-MM-DD, and _summary=count means the agent gets back one number. A total of 1 means the date matches this patient, anything else means it does not. Scoping by _id matters on a shared sandbox, where every reader who runs the seed script creates another Firstname Lastname born 1968-03-14, and it is also the right shape against a real EHR, because the only thing the agent ever learns is whether the spoken date matched.
fhir_get_appointment reads GET /Appointment/{appointment_id} with the ID from the recipient list. The agent confirms against whatever the EHR says at the moment of the call. If the appointment was canceled between the nightly job and the call, the agent finds out before it says anything wrong.
Both tools use a response filter so the LLM sees only the fields it needs (total, or status, start, end, description) rather than a full FHIR bundle.
Scheduling in the EHR
fhir_get_available_slots runs GET /Slot?schedule={fhir_schedule_id}&status=free&_sort=start, with the day the patient asked about supplied by the LLM as the start bound. It returns the provider's open slots in UTC, and the agent reads at most two back in clinic time.
fhir_reschedule_appointment is a PUT on /Appointment/{appointment_id} with the chosen slot's start, end and reference, status booked. Because it updates the appointment the agent just confirmed, there is no second booking to reconcile and no moment where the patient has none. If the PUT fails, the original appointment is untouched.
fhir_cancel_appointment is the same PUT with status cancelled and a cancellation reason, followed by an offer to rebook through the two tools above.
Both write tools pin the participant to the patient and the description to the visit, so the LLM supplies only the times and the slot id it was handed. In the demo the Slot stays free after a reschedule; a production build adds the PUT that marks it busy, or lets the EHR do that on its own.
Voicemail
Voicemail is handled at two layers that do different jobs. The voicemail detection system tool is what changes the agent's behavior on the call: the LLM recognizes an automated greeting from the conversation, plays the configured message, and hangs up. The message takes dynamic variables:
Hi, this is Priya from {{clinic_name}} with a reminder about an appointment on {{appointment_date}} at {{appointment_time}}. To confirm or make changes, please call us at {{clinic_callback_number}}. Thank you.
The agent does not share the patient’s name or the provider name, because voicemail boxes get shared.
Opt-out
Human transfer
Compliance
Then:











