The Math No Recruiter Can Win by Hand

The stopwatch you're already losing to

You post a role, and the inbox fills before lunch. In 2025 the average corporate role pulls 257 applications, up from 207 the year before. Eighty per cent of them get rejected at the first screen. Somewhere in the other twenty per cent is the person who gets placed, and the only thing standing between you and them is a human being reading CVs against the clock.

We know how long that human gets per CV, because someone measured it. 7.4 seconds. That's the average a recruiter spends on a resume before deciding yes-pile or no-pile. Not because recruiters are lazy. Because the maths doesn't allow more. Two hundred and fifty-seven CVs at any honest reading speed is a day you don't have, for one role, and you're running six.

So you triage by stopwatch, and you know it. The good candidate with the badly formatted CV gets missed. The keyword-stuffer floats to the top. And the genuinely repetitive work (reading, reformatting, ranking) quietly eats the hours you're supposed to spend on the phone, building relationships and closing placements.

You don't have a talent problem. You have an arithmetic problem.

Where the hours actually go

Add it up across a week and it gets ugly fast. The average recruiter loses around 12 hours a week to administrative work: reading, screening, reformatting, chasing, logging. The best-run desks claw back closer to 20. Four of those hours, on their own, go to one task almost no client ever sees: reformatting candidate CVs into the agency's template before they're sent out. Ten to forty-five minutes, per CV, by hand.

Now price it, and the number stings. At a $50/hour fully-loaded cost, twelve reclaimed hours a week is roughly $31,200 a year, per recruiter. Across a thirty-person agency that's about $936,000 a year in recovered capacity. Not in some transformation fantasy, but in hours your team already has and currently spends on work a machine should be doing. YS frames the same number another way: 1.5 extra selling days, every week, per desk.

That's the prize: more placements, same team, no new tools. It's real, it's measurable, and (this is the part most vendors won't tell you) the software that captures it is the easy bit.

Three jobs, one assistant

The work breaks down into three small, specific tools. Not a platform. Not a transformation. Three cogs, each one earning its keep before the next gets added.

1. Resume screening against a job. Score one CV against one role's real requirements, and show its reasoning, so you can see why it said yes or no. Triage, not the decision.
2. CV formatting and redacting. Turn a candidate's messy CV into your branded template, and strip the personal details that shouldn't reach a client yet. The four-hour-a-week job, handed off.
3. Resume shortlisting. Take the whole stack for a role and hand back a ranked shortlist, with the reasoning attached.

In one published demo, a screening agent cleared 45 CVs in about 52 seconds: twenty shortlisted, fifteen rejected, ten flagged for a human to look at twice. The same work that costs your team a morning, done before the kettle boils. You decide who moves forward. The tool just clears the path.

And here's the honest framing we'll hold all the way through: the agent does the tireless 90%; a human owns the moment of consequence. Automate the work. Don't automate the accountability.

Why building it is the easy part

If building these three tools were the whole story, it would be a short story. You can stand up a working version of all three in a weekend with real C#, real Semantic Kernel, and real connections to Bullhorn and JobAdder. It works on your laptop by Friday.

Then Monday comes, and the API you connected to changes a field. The model you built on gets deprecated. A candidate hides white-on-white text in their CV to game your screener. 41% of job seekers have tried exactly that. A CV with a date of birth on it goes to a client, and now you have a GDPR problem with a fine attached. The tool that ran beautifully in the demo starts making quiet mistakes that nobody notices until a client does.

That's not a hypothetical. It's the rule, not the exception: 95% of enterprise AI pilots deliver no measurable impact, and the reason is almost never the technology. It's that nobody owns the thing once it's built. It rots. The numbers bear it out: projects built with a delivery partner succeed about 67% of the time; the ones built and maintained in-house, around 33%.

Building it is a weekend. Running it is the job.

So there are two halves to this. One is how these agents are built, with enough code that you understand exactly what's under the hood and never have to take a vendor's word for it. The other, harder half is the work that keeps them running: the security, the monitoring, the exception handling, the maintenance that never ends. That is the decision that actually matters: not can this be built, but who should be the one keeping it alive.

Start with the basics: what an AI agent actually is, and the one feature that separates a real one from a chatbot in a trench coat.