How to Build an AI Hiring Phone Screen with Telnyx Voice

The first-round phone screen is the most repetitive part of hiring. A recruiter calls a candidate, asks the same five questions, takes notes, and decides whether to advance them. Do that 200 times and you've burned a full week before a single second-round interview.

I built an AI hiring phone screen that automates that first call. The AI calls the candidate, conducts a structured 5-question screen, hangs up, and produces a scorecard with scores, a recommendation, strengths, concerns, and a written summary.

The canonical code example lives in the Telnyx code examples repo:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-hiring-phone-screen-python

What Is an AI Hiring Phone Screen?

An AI hiring phone screen is an outbound voice agent that conducts first-round interviews automatically. It places a call to a candidate, greets them by name, asks a set of screening questions one at a time, listens to their answers, responds naturally, and ends the call when the screen is complete.

After the call ends, the system runs a second inference pass on the transcript to produce a structured scorecard: overall score, communication, technical depth, culture fit, a recommendation to advance/hold/pass, key strengths, concerns, and a summary.

The candidate experience is a normal phone call. They answer, talk to a friendly AI interviewer, and hang up when it's done. No app to download, no form to fill out, no scheduling friction.

Why This Matters

High-volume hiring has a math problem. If a recruiter spends 20 minutes per first-round screen and has 200 applicants, that's 66 hours of screening calls before a single person advances to round two. The first-round screen is also the most repetitive part of the process — the same questions, the same structure, the same evaluation criteria.

An AI screen doesn't replace the recruiter. It replaces the 20-minute call that the recruiter was going to make the same decision on anyway. The recruiter reads the scorecard in 30 seconds and decides whether to agree with the recommendation.

That changes the workflow from "make 200 calls" to "review 200 scorecards." The recruiter's time moves to the edges: setting the screening criteria, reviewing the results, and making the judgment calls the AI flags for human attention.

What This Example Builds

The example provides a runnable starter for building this pattern with Telnyx. It uses the AI Assistant product so the entire call — speech-to-text, inference, text-to-speech, turn-taking — is hosted by Telnyx. No webhooks, no ngrok, no local call handling.

The architecture has three pieces:

1. Trigger — a dashboard where you enter a candidate's name and phone number. One API call places the outbound call via Telnyx scheduled events.
2. The call — Telnyx hosts the AI Assistant (Voice Ultra Katie, powered by gpt-4o). It greets the candidate, asks 5 questions one at a time, listens, responds, and ends the call.
3. The scorecard — the dashboard polls the Telnyx conversations API, detects when a screen conversation finishes, runs a second inference pass on the transcript to extract a structured scorecard, and displays it.

The key design choice is using the AI Assistant product instead of raw Call Control webhooks. With Call Control, you build the state machine yourself: answer, speak, gather, infer, speak, gather, ... hangup. With AI Assistants, Telnyx handles the entire call loop. You trigger the call, poll for the transcript, and process the result. That's three API calls instead of a webhook state machine.

The Core Workflow

The trigger is a single scheduled event:

requests.post(
    f"{API_BASE}/ai/assistants/{SCREEN_ASSISTANT_ID}/scheduled_events",
    headers=HEADERS,
    json={
        "telnyx_conversation_channel": "phone_call",
        "telnyx_end_user_target": phone,
        "telnyx_agent_target": SCREEN_NUMBER,
        "scheduled_at_fixed_datetime": when,
    },
    timeout=15,
)

The AI Assistant handles the rest. It calls the candidate, greets them, asks the questions, and hangs up when done. The system prompt controls what it asks:

SCREEN_INSTRUCTIONS = """you are conducting a first-round phone screen
for the {role} role at {company}. {about}

ask these five questions one at a time, waiting for the candidate's
answer before moving to the next:
1. briefly tell me about your background and what interests you about this role
2. what programming languages are you strongest in
3. describe a challenging technical project you led recently
4. what is your timeline and salary expectations
5. do you have any questions for us

be professional warm and encouraging. keep each of your replies to one
or two sentences. after question 5, thank the candidate and say they
will hear back within 48 hours."""

After the call ends, a background watcher polls the conversations API and scores the transcript:

def score_screen(transcript_text):
    messages = [
        {"role": "system", "content": "score this phone screen transcript. "
            "return only valid json: overall_score, communication, "
            "technical_depth, culture_fit, recommendation (advance/hold/pass), "
            "key_strengths, concerns, summary"},
        {"role": "user", "content": transcript_text},
    ]
    raw = call_inference(messages, max_tokens=400)
    return json.loads(raw)

The scorecard appears in the dashboard within ~5 seconds of the candidate hanging up.

Where This Works and Where It Doesn't

This pattern works best for high-volume, surface-level screening where the questions are standardized and the evaluation criteria are consistent. Think hourly roles, retail, seasonal hiring, call centers, or any role where the first-round screen is a filter, not a deep assessment.

It does not work for senior roles where the screen needs to probe technical depth, adapt to the candidate's background, or evaluate nuanced problem-solving. The 5 questions in this example are intentionally surface-level — they filter for communication, basic fit, and interest, not for engineering ability.

It also doesn't replace human judgment. The scores are LLM assessment of a transcript, not a validated rubric. The value is in consistency (every candidate gets the same questions, the same way) and throughput (200 screens without burning a recruiter week), not in precision.

Try the Full Example

The complete runnable version is available in the Telnyx code examples repo:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-hiring-phone-screen-python

To run it locally:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/ai-hiring-phone-screen-python
cp .env.example .env
pip install -r requirements.txt
python app.py

The example includes the dashboard UI, the outbound call trigger, the conversations API watcher, the scoring inference, and a restore script to clean up the Telnyx resources when you're done.

What This Taught Me About Voice AI for Hiring

The interesting part of this build wasn't the AI. It was the workflow design.

The AI Assistant handles the call. The conversations API handles the transcript. The inference API handles the scoring. Each piece is simple on its own. The architecture is what makes it work: trigger the call, let Telnyx host it, poll for the result, process it asynchronously.

That's the pattern that generalizes. Replace "hiring screen" with "patient intake," "lead qualification," "customer feedback survey," or "policy renewal check" — the shape is the same. An outbound call, a structured conversation, a structured output. The phone is the highest-conversion channel we already have. AI makes it scalable.