Audit Your ATS Before Connecting An Agent
An agent syncing into a messy ATS just spreads the mess faster. Learn to audit fields, stages, tags, and notes in Bullhorn, Recruit CRM, or Greenhouse first.
Your ATS is the source, and the source is usually messy
Recruiting agents read and write to your applicant tracking system. Whether you run Bullhorn, Recruit CRM, or Greenhouse, the agent is only as good as the data already in there. If candidate records are half-empty, your pipeline stages mean different things to different recruiters, and your notes are a wall of shorthand, the agent will produce confident, wrong output at scale. A human recruiter working from a bad record makes one mistake. An agent working from a thousand bad records makes a thousand, all before lunch. So the first project is not an agent at all. It is a structured audit of the database the agent will live in.
The field audit: measure fill rates, not vibes
Pull a sample of 30 to 50 recent candidate records, spread across recruiters and roles so you are not sampling one tidy desk. For each field an agent might rely on, record how often it is actually populated and whether the value looks trustworthy. A worksheet like this is enough:
| Field | Fill rate in sample | Trustworthy? | Agent-usable today? |
|---|---|---|---|
| Current title | 42 of 50 | Mostly, some stale | Yes, with a staleness flag |
| Location | 48 of 50 | Yes | Yes |
| Right to work | 19 of 50 | When present | No, ask in screening instead |
| Salary expectation | 11 of 50 | Often outdated | No, re-collect on every screen |
| Availability / notice | 24 of 50 | Decays fast | Only if updated within 30 days |
The rule of thumb: an agent cannot qualify on a field that is empty or stale in most records. Anything below roughly 80 percent fill with trustworthy values either gets re-collected during screening or is off-limits as an input.
The stage audit: one meaning per stage
List every pipeline stage in your ATS, then ask two recruiters independently what each one means and when a candidate enters it. Where they disagree, you have found a problem the agent will inherit and amplify. If "Submitted" sometimes means sent to client and sometimes means shortlisted internally, any agent that reads or updates stages will corrupt your reporting. Write a one-line definition for each stage and get the desk to agree before any agent touches stage data.
Notes, tags, and duplicates
- Notes: read 20 real note fields and mark whether an outsider could understand them. An agent summarizing "spk cnd re: LDN role, WFH pref, £ tbc" will guess, and guesses about candidates are dangerous.
- Tags and categories: check whether skills, specialisms, and source tags follow a convention or are freeform chaos. "JS", "Javascript", and "java script" are three tags to an agent unless you normalize them.
- Duplicates: search a few common names and emails. If the same candidate exists three times, an agent may read the stale copy and act on it.
Write the readiness report
Condense the audit into one page the team can act on. A simple structure that works:
ATS READINESS REPORT - [date]
TRUST TODAY (agent may read):
- Location, current title (with staleness flag), CV attachments
DO NOT TRUST (agent must re-collect or ignore):
- Salary expectation, availability, right to work
STAGE DEFINITIONS AGREED: yes / no (attach the list)
CLEANUP BEFORE BUILD:
1. Merge duplicates flagged in sample (est. 4 hrs)
2. Normalize skill tags to standard list (est. 1 day)
3. Re-collect availability on active candidates via screening
FIRST SAFE WORKFLOW: inbound screening (reads little,
re-collects everything it needs, writes only new records)
Decision: connect now, or clean first?
| Situation | Decision |
|---|---|
| Core fields above 80 percent fill, stages agreed | Connect a read-only agent now |
| Fields patchy but screening can re-collect them | Start with inbound screening, defer ATS-reading agents |
| Stages mean different things to different recruiters | Fix stage definitions before any agent reads or writes stages |
| Heavy duplication across records | Run a merge pass first, or the agent acts on stale copies |
| Notes are the only source of key facts | Do not let the agent decide from notes; use them as hints only |
An illustrative scenario: what the audit catches
Picture an industrial staffing desk running this audit before building a screening agent. This scenario is illustrative, not a client report, but every trap in it is a common one worth looking for. The field audit looks fine at a glance: location and current title are filled on most records. The stage audit is where it gets interesting. The ATS has a stage called "Placed" and a stage called "Started", and half the desk uses them interchangeably. An agent computing "candidates placed this quarter" would produce two different numbers depending on which stage it counted, and the wrong one would go into a client QBR. The notes audit is worse: the single most important fact for a temp desk, whether a candidate has reliable transport to site, lives only inside freeform notes in several different phrasings. The fix list writes itself: define the two stages, promote transport-to-site to a real field, and have the screening agent collect it as a structured answer going forward. That is a few days of cleanup against the alternative of an agent confidently qualifying candidates who cannot get to the site, at a client where attendance is the entire reason the firm holds the contract.
The lesson generalizes: the audit rarely finds that your data is unusable. It finds the three or four specific traps that would have made the agent look stupid in front of a client, and it finds them for the cost of an afternoon. Do the audit, write the report, and make the report the first page of your agent project plan, because every scoping decision that follows - what the agent reads, what it re-collects, what it is forbidden to trust - traces back to it.
Running the audit without a data team
Fifty records sounds like a project. It is an afternoon if you sample properly and resist the urge to fix things while you count.
- Sample across desks and across time. Ten records each from five recruiters, and within each recruiter take some from this month and some from a year ago. The two dimensions catch different problems: recruiter variation shows you inconsistent practice, age shows you decay. A sample of fifty from one tidy desk tells you about that desk and nothing else.
- Count, do not judge. Open the record, tick the fields that are populated, note anything that looks stale, move on. Ninety seconds each. If you start merging duplicates as you find them you will do fifteen records and lose the afternoon.
- Record the age of each value, not just its presence. This is the step people skip and it is where the real answer lives. A field that is 90 percent filled with values last touched two years ago is worse than an empty field, because empty is honest and stale looks authoritative. Wherever the ATS shows a last-modified date, write it down.
- Separate "missing" from "wrong". Two different problems with two different fixes. Missing gets re-collected. Wrong needs someone to work out why it went wrong, because whatever produced it is still producing it.
The output is the table already in this lesson, plus one number per field: what fraction of populated values were touched in the last six months. That single column will change your build plan more than anything else in the audit.
How fast each field decays
"Is this data good?" is the wrong question. The right one is "how long does this stay true?", because that is what determines whether an agent may rely on a stored value or must ask again.
| Field | Stays true for | What an agent should do |
|---|---|---|
| Name, contact details | Years | Trust it; verify only on contact failure |
| Qualifications, certifications | Years, but check expiry dates | Trust the fact, always re-check the expiry |
| Current employer and title | Months | Use as a hint, confirm in the first exchange |
| Location, willingness to commute | Months | Confirm for any role outside their stated area |
| Salary expectation | Weeks | Always re-collect; never quote a stored figure to a client |
| Availability and notice period | Days to weeks | Always re-collect; a stored value is a guess with a date on it |
| Actively looking? | Days | Never store as a fact - it is the reason you are contacting them |
Read the bottom half and a design principle falls out: the fastest-decaying fields are exactly the ones that determine whether a candidate is submittable. Which is why an inbound screening agent is the right first build for almost every desk. It reads very little, re-collects everything perishable at the moment it matters, and writes fresh records - so it improves your data instead of trading on it.
Duplicates: find them before the agent does
Duplicate records are the failure that embarrasses you in front of a candidate rather than a client. The agent reads the copy from three years ago, addresses someone by an old employer, or contacts a candidate who is already out on placement through your own desk.
Find them in an hour without buying anything:
- Export and sort by email address. The fastest win. Exact email matches are unambiguous duplicates, and most ATS exports make this a two-minute spreadsheet job.
- Sort by mobile number, normalised. Strip spaces, country codes, and leading zeros first, or the same number in three formats will look like three people.
- Sort by surname plus postcode. Catches the ones where somebody has changed email address or the record was created from a CV with no contact details.
- Count, then decide. Under a few percent, and you can merge as you go. Materially higher, and it needs a merge pass before any agent reads the database - because the agent has no way of knowing which copy is the live one.
One rule when merging: keep the record with the most recent activity, not the one created first, and carry the notes and attachments across from both. And decide in advance what the agent should do if it encounters an apparent duplicate in future - flag for a human is the only safe answer, because automatic merging of candidate records is a decision with consequences no agent should be making unsupervised.
The permissions and privacy questions to settle now
An agent connected to an ATS gets access to personal data at scale, and the sensible time to think about that is before the connection exists rather than after somebody asks. Four things to settle, in writing, at audit stage:
- What can it read? Give the agent's account the narrowest access that does the job. Most ATS platforms have role-based permissions, and an agent that only needs open roles and inbound applicants should not be able to read every historical record in the system.
- What can it write, and what can it never write? The list of forbidden writes should be explicit and short: stages that feed client reporting, anything financial, and anything that would trigger an outbound message to a candidate without a human seeing it first.
- Is there a log of what it did? Every read and write attributable to the agent's account, retrievable later. This is what lets you answer "why did this candidate get contacted?" - a question that will eventually be asked.
- What are you allowed to do with candidate data? You already have obligations about how candidate data is used and how long it is kept, and connecting an agent does not change them. If a workflow would send personal data to a new third party - a model provider, a screening tool - that is a decision to make deliberately and record, in line with whatever your firm has already told candidates and clients. Worth a conversation with whoever owns compliance at your firm before, not after.
None of this is exotic and none of it takes long. It is the difference between a project that passes a client's supplier review and one that stalls in it for a month.
The audit, worked through with actual numbers
"Run a fifty-record audit" is the instruction. Here is what the finished thing looks like, because a filled-in worksheet teaches the method faster than the method does. The figures below are illustrative - the point is the shape of the conclusions, not the numbers themselves, which will be different and are frequently worse.
How to pick the fifty. Not the fifty most recent, and not one recruiter's records. Take twenty from the last month, twenty from six to twelve months ago, and ten from more than two years ago, spread across every consultant on the desk. The age spread is what exposes decay; the consultant spread is what exposes that one person's discipline is not the database's.
| Field the agent would use | Present | Present AND usable | What the gap means |
|---|---|---|---|
| Email address | 50 / 50 | 50 / 50 | Safe to key on. This is your join field |
| Mobile number | 46 / 50 | 31 / 50 | Fifteen are stored in formats that vary. Normalise before any agent dials or texts |
| Current job title | 44 / 50 | 19 / 50 | Free text, no shared vocabulary. Not screenable without a mapping |
| Right to work status | 12 / 50 | 12 / 50 | Mostly absent. The agent must ask, never assume |
| Salary expectation | 38 / 50 | 6 / 50 | Present but stale - only six were updated in the last three months |
| Availability / notice | 29 / 50 | 3 / 50 | Effectively unusable. Re-collect every time, without exception |
| Last contact date | 50 / 50 | 50 / 50 | System-maintained, so reliable. Use it to age everything else |
The column that does the work is the second one. "Present" is what a vendor demo measures and it is nearly meaningless - a field containing "ASAP" or "see notes" is present. Usable means an agent could act on it without a human interpreting it first, and the gap between the two columns is the entire finding. In this audit, three of the seven fields have a usable rate low enough that any workflow depending on them is a workflow that will produce confident nonsense.
Two derived numbers are worth calculating while you have the sheet open, because they are what you will actually quote to whoever approves the project:
- Complete-enough rate. How many of the fifty have every field a given workflow needs? Here, a workflow needing title, salary and availability together clears on 2 of 50. That number kills the workflow, and it is much better to know it in an afternoon than after a build.
- Decay-adjusted rate. Re-run the count using only records touched in the last ninety days. If the usable rate jumps sharply, your problem is age rather than discipline, and the fix is a re-engagement campaign rather than a data-entry policy.
The stage definition sheet, filled in
The other half of the audit is agreement about what stages mean, and this is where audits get uncomfortable, because the disagreement is usually real and long-standing. Do it as a live exercise: ask each consultant separately to write one line per stage, then put the versions side by side.
STAGE: "Submitted"
Consultant A: "I've sent the CV to the client."
Consultant B: "The client has confirmed they received it."
Consultant C: "I've sent it and logged it - sometimes next day."
AGREED DEFINITION (owner: desk lead, dated 12 Aug 2026)
Set when the CV has been sent to the named client contact AND
the submission is logged the same working day. Not before.
WHAT THE AGENT MAY DO: read this stage to avoid double-submitting
a candidate. It may NEVER set or clear it - that is a human action
because it feeds client reporting and our fee position.
STAGE: "Placed"
Everyone agreed on this one, because it triggers invoicing.
AGREED DEFINITION: signed contract received, start date confirmed.
WHAT THE AGENT MAY DO: read only. No writes, ever, under any
circumstance.
Notice the pattern that emerges and holds almost everywhere: stages tied to money are defined precisely and stages tied to effort are not. Everyone knows what "Placed" means because a fee depends on it. Nobody agrees on "Submitted" because nothing breaks when it is loose. An agent reading pipeline data has no way to detect that difference, so it treats the loose ones with the same confidence as the precise ones - which is exactly how a candidate gets submitted twice.
The last block of each definition is the one to insist on. Every stage gets an explicit read/write verdict for the agent, and the default is read-only. Anything that feeds client reporting or your fee position stays human, permanently, and that is not a temporary caution while trust is built - it is a design decision.
The readiness report: before and after
The audit's output is one page that somebody can act on. Most first drafts read like the top version, which is a finding rather than a decision.
BEFORE - a finding, not a decision
ATS Readiness
The data is quite messy. A lot of records are old and salary
information is often out of date. Stages are used inconsistently
between consultants. We should tidy this up before we do
anything with AI.
AFTER - the same audit, written so it can be approved
ATS READINESS - Perm desk, 12 Aug 2026
Sample: 50 records (20 recent, 20 mid, 10 aged), all 4 consultants
SAFE TO BUILD NOW
Inbound applicant screening. Reads job requirements only, asks
the candidate for everything perishable, writes a new note plus
a structured summary. Depends on no existing field except email.
Blocked by nothing on this list.
NOT SAFE YET, AND WHY
Anything that screens the existing database. Title is usable on
19/50 and availability on 3/50, so a search over stored data
would miss most qualified people and surface unavailable ones.
Anything that writes to pipeline stages. "Submitted" has three
live definitions; agreed wording exists as of today but has not
been applied to historical records.
CLEANUP LIST, IN ORDER
1. Normalise mobile numbers to E.164. ~2 hours, ops
2. De-duplicate on email (found 6 pairs). ~2 hours, ops
3. Apply agreed stage definitions going ongoing, desk lead
forward; do not backfill history.
4. Map the top 20 job titles to a controlled ~half a day, desk lead
list. Do not attempt all of them.
DECISION REQUESTED
Approve the inbound screening build now. Revisit database
screening after items 1-4, which is a four-week horizon, not
a prerequisite for starting.
The second version is approvable because it separates what is blocked from what is not. The most common failure of an ATS audit is that it concludes "the data is a mess", which reads as "do nothing", and the project quietly dies - even though the single best first build, inbound screening, depends on almost none of the messy data. Always name the workflow that is safe today, and name it first.
When not to connect an agent at all
- You are migrating ATS within six months. Every field mapping and every integration is throwaway work. Do the data cleanup - that migrates - and build after.
- The desk is one person with fifty candidates. There is no volume for an agent to earn against, and a good spreadsheet plus a calendar reminder beats it.
- Nobody owns the data. If no named person is responsible for what the database contains, an agent will make it worse faster than a human can, and there will be nobody to notice.
- The bottleneck is client-side. If your candidates sit waiting for client feedback for two weeks, speeding up screening changes nothing a client will notice. Measure where the time actually goes before automating the part that is already fast.
Common mistakes
- Treating messy notes as a trusted source of truth and letting the agent make decisions on them.
- Connecting an agent to a full pipeline before confirming stages mean the same thing to everyone.
- Assuming the ATS vendor's clean demo data resembles your real, lived-in database.
- Auditing one recruiter's tidy desk and generalizing to the whole database.
What you should be able to do now
- Run a 50-record field audit and compute fill rates for the fields an agent would use.
- Produce an agreed one-line definition for every pipeline stage.
- Name which fields an agent may trust today and which it must re-collect.
- Write a one-page readiness report with a cleanup list and a first safe workflow.
- Explain why an agent amplifies data problems instead of tolerating them.
- Classify every field by how fast it decays, and decide what the agent stores versus re-collects.
Where this goes next
This lesson and Define must-have screening criteria are the free part of the course. They are the two pieces of groundwork that decide whether a recruiting agent works or embarrasses you: the state of the data it reads, and the precision of the rules it screens against. Run the fifty-record audit this week before anything else - it is an afternoon, and it will change what you build first.
The paid lessons build the desk. The inbound screening agent end to end, including the structured questions that keep answers usable. Writing back to Bullhorn, Recruit CRM, or Greenhouse without corrupting your reporting. Candidate communication that sounds like your firm rather than a bot. Interview scheduling. Shortlist packs for clients. Then the harder subjects: keeping a human accountable for every rejection decision, auditing the agent's screening for consistency, and the handover so the desk owns the system rather than depending on whoever built it. Every lesson ships the templates and workflow files.
If you would rather this was built for you, that is project work we take on - see AI automation services, or start with the free automation audit, which includes a straight read on whether your ATS is ready. The speed to lead entry explains why response time dominates candidate conversion, and AI automation cost has the pricing picture.
Enter your email below and both free lessons arrive with the field audit worksheet, the readiness report template, and the stage definition sheet as editable files - the whole audit pack, ready to run on Monday.
Key takeaways
What to remember from this lesson
- A human working from a bad record makes one mistake. An agent working from a thousand bad records makes a thousand, all before lunch.
- An agent cannot qualify on a field that is empty or stale in most records. Below roughly 80 percent fill with trustworthy values, the field is either re-collected during screening or off-limits.
- Ask two recruiters independently what each pipeline stage means. Where they disagree is a problem the agent will inherit and amplify into client reporting.
- Never let the agent decide from freeform notes. Treat notes as hints, and promote anything genuinely load-bearing into a real structured field.
- Sample across recruiters and roles. Auditing one tidy desk and generalizing is how a readiness report ends up wrong.
Try it yourself
Score one ATS field for fill rate
The audit question is not 'do we have this field' but 'is it filled with something trustworthy in enough records'. Below is a fixture export of 10 candidate rows, blanks and all. Write the function that turns a field name into a fill rate and a verdict, using the 80 percent line from the lesson.
Check yourself
What an audit is actually looking for
A field is present on every record and is 95 percent filled, but two recruiters have been using it to mean different things. Is it safe for the agent to qualify on?
The information you need is genuinely in the record, but it lives in a recruiter's freeform note rather than a field. What is the right move?
You audited 40 records from your best-organised recruiter's desk and everything scored above 90 percent. What is the flaw?
Answer every question to mark.
Write it
Ask your recruiters to define one pipeline stage
The stage-definition exercise only works if each recruiter answers independently and concretely. Write the message you send them. This lab checks for the structural parts a good request has, not the writing quality.
1 of 6 checks passing
- Names a specific stage rather than asking about all of them at once
- Asks them to answer independently, before comparing notes
- Asks what must be TRUE for a candidate to be in the stage, not a vibe
- Gives a deadline or a time box
- Long enough to be unambiguous
- Short enough that a busy recruiter reads it
These checks look at structure only, not quality. A prompt can pass every one and still be a poor prompt, so read it back and ask whether you would understand it cold.
Exercise
Run the 50-record audit and write the readiness report
- 1Pull 30 to 50 recent candidate records spread across several recruiters and role types, not one desk.
- 2For each field an agent might rely on, count how many records have it populated and write the fill rate as a fraction, not an impression.
- 3Mark each field trustworthy or not, then mark it agent-usable today, usable with a staleness flag, or off-limits. Apply the 80 percent rule rather than arguing the field.
- 4List every pipeline stage and ask two recruiters independently, without each other present, what each stage means and when a candidate enters it. Record every disagreement.
- 5Read 20 real note fields and mark whether an outsider could understand them. Note any fact that exists ONLY in freeform notes - that is a field to create.
- 6Search a handful of common names and email addresses and count the duplicates you find.
- 7Condense all of it into the one-page readiness report: trust today, do not trust, stage definitions agreed yes or no, a cleanup list with time estimates, and a first safe workflow.
- 8Take the report to the decision table and write your verdict: connect a read-only agent now, start with inbound screening, fix stage definitions first, or run a merge pass first.
You are done when You have a one-page readiness report backed by counted fill rates from a multi-recruiter sample, a list of every stage where two recruiters gave different answers, a cleanup list with hour estimates, and a named first safe workflow chosen from the decision table.
Companion files
ATS audit worksheet and readiness report format
The field-audit grid, the connect-or-clean decision table, and the readiness report structure - so the three-hour audit is data entry rather than format design.
The free-preview pack includes the worksheet for this lesson for Audit Your ATS Before Connecting An Agent, plus the other free lessons of this course. No email needed.
Free preview pack - 5 KB zipCheck yourself
Answer before you reveal
Salary expectation is filled on 11 of 50 records. Can the agent screen on it?Show answer
No. It is far below the 80 percent threshold and the values that exist are often outdated. Re-collect it on every screen instead, as a structured answer.
Two recruiters give different answers for what 'Submitted' means. Why is this worse than a half-empty field?Show answer
Because it corrupts reporting silently. Any agent that reads or updates stages will produce a number that looks authoritative and is wrong, and that number goes into a client review before anyone questions it.
The most important fact on your desk lives only in freeform notes. What is the fix?Show answer
Promote it to a real field and have the screening agent collect it as a structured answer going forward. Notes stay hints - the agent must not make decisions from them.
