The first-round phone screen is the most repetitive part of hiring, and most of it gets thrown away. A recruiter calls a candidate, asks five questions, takes notes, moves on. If the call drops halfway through, everything said so far is gone — the next call starts from scratch.
I built a candidate screening call agent that fixes the boring part and the fragile part. A Telnyx AI Assistant calls the candidate, conducts a five-question screen, scores each answer as it happens, and every answer lives in a durable per-candidate actor — so a dropped call resumes at the next unanswered question instead of restarting.
The video walkthrough: https://youtu.be/a03KfWduNWA
The canonical code example lives in the Telnyx code examples repo:
https://github.com/team-telnyx/telnyx-code-examples/tree/main/candidate-screening-call-agent
What Is an AI Candidate Screening Call Agent?
An AI candidate screening call agent is an outbound voice workflow that conducts first-round interviews automatically and keeps the result as durable state. It places a call to the candidate through Telnyx TeXML, a hosted AI Assistant runs the conversation, and each completed answer is recorded and scored into an actor whose identity is the candidate's phone number.
After the call, the recruiter sees a live transcript and a scorecard: per-question scores, pass/clarify/fail verdicts, an average, and a recommended next step — advance, review, or human review. If the candidate hangs up mid-screen, calling them again resumes at the next unanswered question. Nothing gets asked twice.
Why This Matters
Two problems get solved at once.
First, throughput. The first-round screen is the same five questions every time, and the human adds the least value there — they're filtering for communication and basic fit, not probing engineering depth. A machine can run that call consistently for every candidate.
Second, durability. Most call-based workflows keep their state inside the call: when the call ends, the context ends. This example inverts that. One durable actor exists per candidate phone — it holds the profile, the answer ledger, the scores, the retries, and the event history. Calls are just one channel into that state. If you redeploy the whole service tomorrow, the candidate's file is still there.
That inversion is what makes the workflow extensible: once the candidate's identity lives in an actor instead of a call, adding an SMS channel later is just another route into the same state.
What This Example Builds
The sample is built on four Telnyx products:
- Telnyx AI Assistants — hosts the entire conversation: speech-to-text, inference, text-to-speech, turn-taking, voicemail detection. The assistant is created once and reused; it uses an Ultra voice with expressive mode, waits patiently instead of interrupting, and if the candidate doesn't pick up, it leaves a callback message and stops.
- TeXML — places the outbound call. Each call carries per-call dynamic variables: the question list, the list of already-answered questions, and the candidate's phone number.
- Telnyx Edge Compute — runs a durable actor per candidate phone. The
CandidateScreenactor extends the Edge runtimeAgentclass and owns the screening workflow: opened state, answer ledger, scores, retries, and resume-after-drop. - The recruiter dashboard — one button places the call; the live transcript and scorecard stream from the actor and the AI conversations API.
The Core Workflow
The actor is the identity. Every request resolves to it by phone digits:
const stub = env.SCREENS.idFromName(actorNameForPhone("+13125550123"));
// actorNameForPhone → "candidate-screen-13125550123"
Same phone, same actor — no matter who triggers the screen, whether it's a redial, or whether the service was redeployed in between.
Opening a screen stores the profile and builds the assistant and dial payloads:
const opened = await stub.openScreen(profile);
// { actorName, assistantPayload, dialPayload, nextQuestion }
The outbound call goes through the TeXML application with the assistant and the per-call variables:
const payload = {
From: callerId,
To: destination,
AIAssistantId: assistantId,
MachineDetection: "Enable",
AsyncAmd: true,
DetectionMode: "Premium",
AIAssistantDynamicVariables: await stub.dialVariables(),
};
dialVariables() reads the actor's ledger at call time, so the call always matches the code:
async dialVariables() {
return {
questions_list: "1. what interests you about this developer advocate role?; 2. tell me about a technical concept you explained to developers recently?; ...",
answered_questions: "questions 1 and 2",
candidate_phone: profile.candidatePhone,
};
}
That last field is the whole resume story. There is no special resume flow — calling the candidate again sends the already-answered list as a dynamic variable, so the assistant skips to the next unanswered question. The state lives with the candidate, not inside the call.
Scoring happens two ways, converging on the same ledger. During the call, the assistant's score_answer webhook tool posts each completed answer to the Edge function, which routes it into the same actor:
if (url.pathname === "/screen/score" && req.method === "POST") {
const { phone, qidx, answer } = body;
const stub = env.SCREENS.idFromName(actorNameForPhone(phone));
const score = await stub.recordAnswer(qidx, answer);
return Response.json({ ok: true, score });
}
The scorer is deliberately honest. Each rubric question carries ideal signals; an answer scores from signal hits plus substance:
- fewer than 8 words → fail (too short)
- no rubric signals under 15 words → fail
- substantive but off-rubric → clarify (human review)
- 2+ signals → pass
- very long, specific answers get a bonus
In production, the same answer routes through Telnyx Decision Models for LLM-graded scoring with the same typed output: score 0–3, pass/clarify/fail, and a human-review flag.
Where This Works and Where It Doesn't
This pattern works for structured, high-volume first-round screens: hourly roles, retail, seasonal hiring, support teams — anywhere the screen is a filter with consistent criteria. The durable actor earns its keep the moment calls are long, multi-touch, or likely to drop.
It does not replace human judgment. The scores are rubric-matching against ideal signals, not a validated hiring rubric. Weak-generic answers route to human review on purpose. The value is consistency (every candidate gets the same five questions, the same way) and continuity (a dropped call is a resume, not a restart), not precision.
The identity key is also a design choice: it's the candidate's phone number, which is natural for voice and SMS. If your workflow needs identity to follow a person across channels instead, the actor naming switches to a candidate id — a one-line change.
Try the Full Example
The complete runnable version is in the Telnyx code examples repo:
https://github.com/team-telnyx/telnyx-code-examples/tree/main/candidate-screening-call-agent
git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/candidate-screening-call-agent
npm install
cp .env.example .env # fill in TELNYX_API_KEY, OUTBOUND_TEXML_APP_ID, OUTBOUND_CALLER_ID, CANDIDATE_PHONE
npm run dashboard
The dashboard places the call, streams the transcript, and scores answers — all locally. Deploying the durable actor and scoring webhook to Telnyx Edge (telnyx-edge ship) is optional; the local demo works standalone.
The video walkthrough of the live flow: https://youtu.be/a03KfWduNWA
What This Taught Me About Voice AI Workflows
The interesting part wasn't the AI — it was where the state lives.
Calls are ephemeral. Candidates are not. When the candidate's history lives in a durable actor instead of a call, three things fall out for free: dropped calls become resumes, retries become state transitions, and adding channels (voice today, SMS tomorrow) becomes routing instead of rebuilding.
That's the pattern that generalizes. Replace "screening call" with "patient intake," "loan application check," "insurance verification," or "appointment confirmation" — an outbound call, a structured conversation, and a durable per-person actor that remembers everything.