Designing AI Agents to Help Recruiters Hire Faster

Why this started

We had automation. Recruiters still had to do the work.

Recruiters spend a lot of time on the operational side of hiring.

Screening candidates, asking initial questions, following up, scheduling interviews, and keeping things moving across multiple open roles.

A recruiter's day, before agents

1. 
   01

   A recruiter starts their day with a long list of open roles to fill.

2. 
   02

   They jump between multiple tools: job boards, spreadsheets, ATS, and emails to find and track candidates.

3. 
   03

   It's hard to keep track: candidates get lost, statuses are unclear, and follow-ups are missed.

4. 
   04

   They spend too much time on manual work: screening profiles, writing follow-ups, and scheduling interviews.

5. 
   05

   Important candidate information is scattered across tools, making it hard to get a complete picture.

6. 
   06

   They have to manually decide the next steps for each candidate, again and again.

7. 
   07

   By the end of the day, they're exhausted, having spent hours on tasks that could be automated.

A lot of this work follows the same patterns. And yet, even when automation was available, recruiters still had to configure it themselves.

At Sense, our workflow builder asked recruiters to map fields, set triggers, define rules, and configure every little detail before an automation could go live.

One hiring campaign could take around 2.4 hours to set up. That was the part I wanted to rethink.

The idea wasn't to give recruiters another AI tool to manage. It was to let agents handle more of the repetitive work around hiring, while keeping recruiters in control of how that work got done.

First, I wanted to understand why the existing experience wasn't working.

We spent a week in a cross-functional war room looking at the recruiting experience from different angles.

We looked at how recruiters approached their work, where candidates faced friction, and what made existing automation difficult to adopt. A few things stood out.

Recruiters think about outcomes, not workflows.

They want to screen candidates, move faster, and make sure they don't miss good people. They don't wake up wanting to configure triggers and conditional logic.

Much of the setup was repetitive.

Around 80% of workflow rules overlapped, and 71% of workflows reused nearly identical rules. We were asking recruiters to spend time recreating logic that often looked very similar from one campaign to the next.

People were dropping off before they got value.

64% of workflows were abandoned. Field mapping and trigger selection were major points of friction.

My first attempt was to make workflows easier to configure.

My initial thinking was that recruiters weren't adopting automation because they didn't understand what it was doing. So, what if we made everything more transparent?

Version 1

I designed the first version around three things:

• Expose the available controls.
• Make the agent logic transparent.
• Let recruiters customize the behavior.

The assumption was simple: more visibility and control would make recruiters more comfortable using AI.

I pushed an early prototype through Lovable to test the idea quickly instead of spending too much time perfecting a direction we hadn't validated.

But the prototype made me question my own assumption.

We were making the system easier to inspect, but not necessarily easier to use.

Recruiters still had to make too many decisions before they could get anything done. The AI was beginning to feel like another system they had to manage.

I had solved for precision when the bigger problem was getting started.

So I asked a different question.

Instead of making the workflow builder better, I wanted to remove the need to use one in the first place.

A recruiter could describe the task they wanted to automate, and an AI agent would handle the setup.

For example, instead of configuring every step of a candidate prescreening workflow, a recruiter could start with the outcome they wanted and let the agent help put the process together.

Version 2

I called this the second design bet: momentum over precision.

We removed the traditional workflow-building experience and moved toward an agent-led setup. It was a much simpler way to get started.

But we had gone too far in the other direction.

Without enough visibility into how the agent worked, recruiters had new questions:

• What is the agent actually doing?
• Can I change something later?
• What happens when it makes a mistake?

We had reduced setup effort, but we had also made the experience feel like a black box. That was the trade-off I needed to solve next.

The third version was about finding the balance.

I didn't want to bring back the complexity of the original workflow builder. But completely hiding the process wasn't the answer either.

Version 3

The third version focused on making the agent's behavior understandable without exposing every configuration detail. I worked toward three changes.

1. Replace complex logic trees with a simple sequence.

Rather than asking recruiters to understand workflow logic, we presented the agent as a series of understandable steps.

2. Make the agent's process visible.

We organized the experience into clear stages: Greeting → Data → Schedule → Close

Recruiters could understand how the agent would approach the task without having to build every step themselves.

3. Keep control where it matters.

We identified a few important points where recruiters could review or intervene, instead of making them configure everything upfront or leaving them with no way to influence the result.

This was the version we took into a limited pilot.

Getting it in front of users

There were legitimate concerns about this direction.

Product stakeholders were concerned about losing enterprise control. Engineering raised questions about black-box behavior, and Sales was concerned about how larger customers would respond to an AI system making decisions about their recruiting processes.

I pushed for reducing the setup effort without permanently removing control.

We started with internal HR and two enterprise customers to keep the pilot contained and learn from actual usage before rolling it out more broadly.

The product subsequently went live for all corporate users.

For me, the important part wasn't just that setup became faster. It was that we had found a way to move more of the repetitive work into the agent without making the experience completely opaque.

A recruiter's day, with agents

1. 
   08

   With AI agents, the repetitive work is handled automatically: screening, scheduling, follow-ups, and updates.

2. 
   09

   Now recruiters can focus on what really matters: building relationships and hiring the right people, faster.

What I'd look at next

Getting an agent up and running is only the first step.

The next question is whether recruiters continue to trust it once it starts doing useful work.

I'd want to understand how often recruiters override an agent, edit its behavior, pause it, or roll back its actions. I'd also look at how quickly it helps build an interview-ready pipeline.

These would help us understand whether we had genuinely made recruiting easier, rather than simply making the initial setup faster.

My biggest takeaway

When I started this project, I thought the challenge was to make AI automation easier to configure.

After working through three versions, I realized that the bigger opportunity was to change how people interacted with automation altogether.

The first version exposed too much. The second hid too much. The third tried to give recruiters the outcome they wanted, without taking away their ability to understand and influence what happened.

That balance is especially important in recruiting. There is a lot of repetitive work that an agent can take on, but recruiters still need to make judgments, build relationships, and handle situations that aren't straightforward.