Deploying AI in hiring isn't about picking a tool. It's about designing a system.

Most organizations that fail with AI in hiring didn't fail because the tools were bad. They failed because they bought tools without designing how those tools would work together, where they'd hand off to each other, when they'd escalate to a human, and how the whole system would improve over time. The tools did what they were built to do. The system around them was never built at all.

Agent orchestration is the specific design work that makes AI in hiring actually produce outcomes. It's also the skill the next generation of TA leaders will be evaluated on — because once every company has access to roughly similar tools, the differentiator becomes how those tools are deployed and coordinated.

This lesson walks through the four design decisions that determine whether your orchestration layer works.

Design Decision 1: Which Agents?

The first question isn't "Which tool should we buy?" It's "Which parts of our hiring process should be handled by agents at all?"

Not every stage is equally amenable to agent automation. Agents work well where the task is bounded, the inputs are structured, and the decision logic is either clear or learnable from examples. That describes most of pre-screening, scheduling, initial outreach, candidate Q&A, and post-interview debrief compilation. It describes some of interviewing. It doesn't describe hiring manager calibration, offer negotiation, or final decision-making — those remain firmly in human territory.

The practical question: which of the following agents make sense for your volume, roles, and process?

- Screening agent — evaluates incoming applications against role requirements, produces ranked shortlists with rationale
- Sourcing agent — identifies passive candidates, drafts outreach, handles initial responses
- Scheduling agent — coordinates interview panels, handles reschedules, sends prep materials
- Interview agent — generates structured question sets, rubrics, and debrief templates; in some deployments, conducts first-round structured interviews
- Candidate experience agent — handles candidate status questions, application updates, process transparency

The answer isn't usually "all of them" It's usually a subset tied to where your biggest bottlenecks are. A company with 5,000 applications per month and a small recruiting team needs screening and scheduling first. A company with 200 applications per month and a mature recruiting team might need the sourcing and interview agents more. Start with the bottlenecks, not the full stack.

Design Decision 2: Which Handoffs?

Each agent produces an output. Each output gets passed somewhere — to another agent, to a human, or to the candidate. The handoff points are where orchestration lives or dies.

Three handoff patterns worth designing deliberately:

Agent → agent — The screening agent flags a candidate as promising. The sourcing agent (or outreach module) receives that signal and initiates contact. The scheduling agent picks up when the candidate replies. These handoffs work cleanly when each agent has a well-defined output format and the next agent knows how to consume it. They break when different tools produce different formats, timing is mismatched, or the underlying data isn't shared cleanly.

Agent → human — The screening agent produces a shortlist. A recruiter reviews it. The recruiter adds candidates, removes some, and approves the list. Then the outreach agent proceeds. These handoffs are where most human oversight happens, and they need to be designed with the human's time in mind. A handoff that requires the recruiter to context-switch into a separate tool, re-read everything the agent has already processed, and make decisions without clear rationale is a failed handoff. A handoff that presents the recruiter with a structured shortlist, explicit reasoning per candidate, and clear "approve / edit / reject" actions is a successful one.

Agent → candidate — The sourcing agent sends outreach. The candidate replies. The conversation continues — sometimes with the agent, sometimes escalated to a recruiter. These handoffs are where employer brand gets built or broken. Candidates can tell when they're talking to an agent, and that's often fine if the interaction is useful and the agent knows when to escalate. The failure mode is an agent that pretends to be human, gets asked a question it can't handle well, and produces output that damages the candidate's view of the company.

Map your handoffs explicitly. For each one, ask: is the format clear? Is the timing right? Is the recipient positioned to act well on what they receive?

Design Decision 3: Which Exceptions?

Agents are good at the common case and often brittle at the exception. A core part of orchestration design is deciding, in advance, what the agent should do when it encounters a situation outside its normal operating envelope.

Exceptions that need explicit handling:

- Candidates who respond in unexpected ways — "Actually, I'm more interested in a different role at your company" isn't a response the screening-to-outreach pipeline was designed for. What happens?
- Ambiguous candidates — The screening agent isn't sure — the candidate has strong signals but also concerning ones. What threshold triggers human review?
- Sensitive situations — The candidate discloses a disability. The candidate asks about accommodations. The candidate mentions they were referred by an executive. Each of these requires human judgment. When does the system recognize it and escalate?
- Technical failures — An integration breaks. A message doesn't send. A resume doesn't parse. What's the recovery path, and who gets notified?

The rule of thumb: err toward escalation. An agent that escalates too eagerly produces extra work for a recruiter. An agent that escalates too reluctantly produces candidate-facing failures that damage the brand. The second is worse. Configure escalation thresholds conservatively, watch what gets escalated, and tune from there.

Design Decision 4: Which Feedback Loops?

An orchestration layer that doesn't learn from outcomes is an expensive set of disconnected tools. A layer that does learn — that feeds hire quality, retention, candidate experience signals back into how the agents operate — compounds over time.

Three feedback loops worth designing:

Hire quality → screening — Six months after each hire, the hiring manager rates performance. That data gets fed back to the screening agent so it can adjust which patterns it weights going forward. Candidates similar to high-performing hires should rank higher. Candidates similar to underperformers should get more scrutiny. This is the most important feedback loop and the one most organizations skip, because the data is annoying to collect. AI removes most of that annoyance.

Candidate feedback → outreach and experience — Response rates on outreach messages. Completion rates on application flows. NPS from candidates who went through the process. All of these should feed back into how the agents communicate and when they escalate. A 15% response rate on a sourcing campaign should trigger a review, not become the new normal.

Recruiter edits → system design — Every time a recruiter overrides the screening agent's recommendation, edits the outreach message, or changes the interview question set, that's a signal. Taken individually, edits are noise. Taken in aggregate, patterns emerge. The recruiters are consistently removing a certain kind of candidate from shortlists — why? The recruiters are consistently rewriting outreach messages in a specific way — what's wrong with the agent's default? These patterns inform what needs to be tuned.

The feedback loops are what turn orchestration from a static deployment into a continuously improving system. Without them, you ship once and slowly decay. With them, the system gets better every quarter.

The Underlying Principle

Agent orchestration isn't about maximizing automation. It's about designing a division of labor between agents and humans that plays to what each does well.

Agents do well at: bounded tasks at scale, pattern recognition across large batches, consistent application of rules, tireless attention to volume.

Humans do well at: judgment under ambiguity, relationships that require trust, decisions that require accountability, handling of exceptional cases.

The best orchestration designs put each side on what it does best. They don't try to automate the judgment. They don't leave humans doing triage. They route the work to whichever side is better at it, coordinate the handoffs, and learn from outcomes.

AgentR describes this philosophy as "Humans + Agents" — not AI-only, not human-only, but a deliberately designed division of labor where each side does what it's best at and the system is better than either alone. The phrase is the worldview, not just the tagline. Every design decision in the orchestration layer should pass the same test: is this playing to what agents do well, what humans do well, or neither?

If the answer is "neither," you've got work to do on the design.

Next: Lesson 21 — The AI Prompt Pack