Recruiter screening

Reliable voice agents look more like code than conversations.

Most voice platforms ship one giant LLM and hope it stays on script. We compose voice agents from small, testable sub-agents — each one a linear sequence of primitives.

Below: the thesis, the primitives, and what it looks like for recruiter screening.

5 min read · concrete example included
The thesis

A reliable voice agent is composed, not prompted.

ElevenLabs, Vapi, Bland start from one capable agent you steer with a prompt, then add workflows and tools on top. We start from the other end — a library of small, specialized sub-agents that compose into the call.

An orchestrator picks the right ones for each role. Cross-cutting listeners run across the whole call to score things like communication skill.

Workflow
orchestrator picks
sub-agent
verify_identity
Greets the candidate, confirms the right person, checks it's a good time. Routes if it isn't.
Build
/speakgreeting
"Hi, this is the screening team calling about your application for the {role_title} role. Is now a good time?"
/collectname
"May I know your name?"
/conditional_collectavailability
If not {candidate_name}: "Am I speaking with {candidate_name}, their spouse, or someone else?"
Transcript
Agent
"Hi, this is the screening team calling about your application for the Staff Engineer role. Is now a good time?"
Candidate
"Sure, I've got a few minutes."
Agent
"Great — just to confirm, am I speaking with John?"
Candidate
"Yes, that's me."
silent
Identity confirmed · right person on the line
→ orchestrator picks next sub-agent
Plus a global listener for communication skill, scoring across the entire call.
The primitives

Nine primitives. Compose them. Ship reliable agents.

Voice agents in Feliciti are built like Notion documents — slash commands compose into blocks, blocks compose into sub-agents, sub-agents compose into the full call flow.

Nine primitives are all you need — one runs before the call connects, the rest run during.

  • /pre-call

    Read state before speaking.

    Match the customer, fetch their record, load context — all before the first hello.

  • /speak

    Speak a turn.

    One bounded utterance. Variables interpolate, tone is set per sub-agent.

  • /collect

    Ask and capture an answer.

    A scripted question that records a typed value back into the call state.

  • /conditional_collect

    Branch on a prior value.

    Asks only if a condition holds. The branch is explicit, not a prompt heuristic.

  • /set

    Write to a system of record.

    Commit a value to the DMS, ATS, or TMS. Triggers fire on side-effects.

  • /end

    Close the call.

    Wrap up cleanly with a final line and end the session.

  • /transfer

    Hand off to a human.

    Warm-transfer to the right queue or advisor when escalation is needed.

  • /prompt

    Free-form generation.

    When a step needs a small LLM call — kept narrow, kept testable.

  • /condition

    Route between sub-agents.

    The orchestrator's decision point — composition, not a chain of prompts.

composition

Stack the primitives into a sub-agent.

A sub-agent is a named, reusable unit — a linear sequence of these primitives. Tested in isolation against its own scenarios. Composed with other sub-agents to form the full call flow.

Compared to

What composition gives you that general-purpose platforms don't.

ElevenLabs, Vapi, and Bland are excellent general-purpose voice platforms — they have workflows, branching, and tool-calling. The difference is what you assemble yourself versus what comes built for the work.

General-purpose voice platforms

ElevenLabs, Vapi, Bland

  • Workflows layer on top of a base agent. Composition is a feature you configure, not the unit you build from.
  • Integrations are yours to wire and maintain — the ATS connection, the auth, the retries.
  • Test coverage is on you. There's no per-step test suite that comes with the agent.
Composable sub-agents

Feliciti

  • The sub-agent is the unit. You compose from small, named, reusable pieces — edits are local, downstream effects explicit.
  • In-house iPaaS: the ATS, calendar, and telephony integrations are built and maintained for you, not left as an exercise.
  • One-click test-suite generation. Screen for seniority? It writes that suite. Probe real-time experience? That one too.
Why we built this

We hired our backend engineer through the workflow above.

Earlier this year we needed a senior backend engineer.

We sourced tens of candidates through a technical recruiting marketplace.

Strong on paper. But we still needed to screen each one.

So we composed a screening agent the way we describe above.

An orchestrator picked the right sub-agents for the role:

  • verify_identity to confirm we were talking to the right person.
  • ask_seniority_pedigree to probe their deepest project.
  • ask_realtime_systems because we needed voice agent experience specifically.
  • ask_mutual_fit & ask_why_us to qualify intent.
  • kind_wrap to close the call.

The orchestrator skipped sub-agents that weren’t relevant per candidate.

As a founder, 20 intro calls × 30 mins is a full day lost per week.

That day could go into R&D, GTM, or anywhere that compounds.

Two candidates are hired and shipping in production today.

The rest got kind, structured wrap-ups in under 8 minutes.

If we’d shipped this as one giant prompt to a monolithic LLM platform, we’d still be tuning it.

6
sub-agents composed
20+
candidates screened
2
hired into production
Send us your use case

Want this for your calls?

Tell us the call you want to automate — recruiting or otherwise. We'll send back a working prototype within 48 hours, wired to your actual use case. Same composition pattern you just read about.

A founder reads every one. No sales calls unless you ask.