A8gent
Audit Your ATS Before Connecting An Agent cover
ATS Data Readiness · Lesson 1 of 16

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 title42 of 50Mostly, some staleYes, with a staleness flag
Location48 of 50YesYes
Right to work19 of 50When presentNo, ask in screening instead
Salary expectation11 of 50Often outdatedNo, re-collect on every screen
Availability / notice24 of 50Decays fastOnly 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 agreedConnect a read-only agent now
Fields patchy but screening can re-collect themStart with inbound screening, defer ATS-reading agents
Stages mean different things to different recruitersFix stage definitions before any agent reads or writes stages
Heavy duplication across recordsRun a merge pass first, or the agent acts on stale copies
Notes are the only source of key factsDo 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.

  1. 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.
  2. 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.
  3. 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.
  4. 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 detailsYearsTrust it; verify only on contact failure
Qualifications, certificationsYears, but check expiry datesTrust the fact, always re-check the expiry
Current employer and titleMonthsUse as a hint, confirm in the first exchange
Location, willingness to commuteMonthsConfirm for any role outside their stated area
Salary expectationWeeksAlways re-collect; never quote a stored figure to a client
Availability and notice periodDays to weeksAlways re-collect; a stored value is a guess with a date on it
Actively looking?DaysNever 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 address50 / 5050 / 50Safe to key on. This is your join field
Mobile number46 / 5031 / 50Fifteen are stored in formats that vary. Normalise before any agent dials or texts
Current job title44 / 5019 / 50Free text, no shared vocabulary. Not screenable without a mapping
Right to work status12 / 5012 / 50Mostly absent. The agent must ask, never assume
Salary expectation38 / 506 / 50Present but stale - only six were updated in the last three months
Availability / notice29 / 503 / 50Effectively unusable. Re-collect every time, without exception
Last contact date50 / 5050 / 50System-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

  1. 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?

  2. 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?

  3. 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

180 min
  1. 1Pull 30 to 50 recent candidate records spread across several recruiters and role types, not one desk.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 6Search a handful of common names and email addresses and count the duplicates you find.
  7. 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.
  8. 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 zip

Check 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.

Free lesson notes

Get the notes pack for AI Agents for Recruiters & Staffing, plus every new module free by email.

No card, no spam, unsubscribe any time.