HR verification agent
We design, build and deploy an AI agent that runs a candidate's certificates, references and stated employment history through parallel checks at once, flags every mismatch with evidence, and hands your HR team a hire-ready verification summary — while the hiring decision stays with a human.
At a glance
A bad hire in Malaysia costs months of salary and rehiring — this catches the doctored cert or padded tenure before the offer, and clears clean candidates in minutes instead of days.
Vision/OCR on cert scans and reference emails, several parallel checks reconciled, and PDPA-grade handling of IC and candidate data — but no money movement and no regulator on the critical path.
What changes when it works
Time per application
Manual vetting today
~2–4 hours (spread over days)
With the agent
~10–15 min review
Time saved
≈ 2–3 hours of recruiter time saved per candidate, and days of calendar time collapsed to same-day. At 80 hires a month that's roughly 160–240 hours — about one full-time recruiter freed to close. And one prevented bad hire (often 3–6 months of salary) pays for the whole build many times over.
Indicative; actual time depends on the number of certificates and referees and how quickly referees respond.
Our agentic development process
Every use case follows the same seven stages — from framing the problem to production.
Our process, built on Anthropic's agent guidance and the Agent GPA eval framework: Building Effective Agents · Agent GPA
Stage 1 · Frame
The business problem
A Malaysian employer or recruitment agency vets each candidate as a stack: a CV, scanned SPM/diploma/degree certificates, a few referee contacts, and a stated employment history. Most of a recruiter's day goes to the mechanical, waiting-heavy part — reading each certificate, chasing referees by phone and email, and eyeballing whether the stated dates and titles actually line up with the CV — not to judging fit. It is slow and it stalls: references sit unanswered for days while a good candidate takes another offer. And because it is manual, the diligence quietly varies — a rushed req gets a lighter check than a slow week, and a doctored certificate or a padded tenure slips through.
Stage 2 · Map
The manual workflow today
- 01Open the candidate pack — CV, certificate scans, referee list
- 02Read each certificate by eye and note the institution, qualification and dates
- 03Email and phone each referee, then wait days for a reply
- 04Cross-check stated titles, dates and salary against the CV and references
- 05Chase the gaps — a missing cert, an overlapping job, an unreachable referee
- 06Only then form a view and move to an offer
Where it breaks: The bottleneck is verification — reading documents and waiting on references — done serially, one item at a time. It's the slow, repetitive part that stalls for days and quietly varies in thoroughness between recruiters.
Stage 3 · Design
The agentic workflow
We redesign vetting as a parallelization (sectioning) workflow: instead of checking one thing at a time, the agent fans the candidate pack out into independent checks — certificates, references, and stated history — that run at once, then reconciles the results into one evidenced summary. Independent checks in parallel is exactly what collapses days into minutes.
The certificate, reference and history checks run in parallel, not one after another — the parallelization (sectioning) pattern.
Watch a case flow through the agent — it does the reading and matching; a human still makes the decision.
See it in action
In the candidate pack
What the agent flags
- Degree certificate reads and validates — institution, qualification and year present
- Referee reply received and matched to the stated employer
- Stated title "Senior Analyst" cross-checked against the referee's "Analyst"
- Stated dates cross-checked against the referee's confirmed dates
Every flag cites the exact document or referee reply · your recruiter makes the hire call · ~RM 0.50–1.00 per candidate.
Step by step
- 1
Split the pack into independent checks
The agent takes the candidate pack — CV, certificate scans, referee contacts, stated history — and fans it out into independent verification tracks that don't depend on each other, so they can run at the same time rather than in a queue.
- 2
Verify the certificates
It reads each certificate — including phone photos and scans — using vision to extract the institution, qualification, and dates, checks them for internal consistency and against the CV's claims, and flags anything that looks altered or doesn't match.
- 3
Send and read reference responses
It sends structured reference requests to each referee and reads the replies as they arrive, extracting the confirmed title, dates and (where given) reason for leaving — so a recruiter isn't manually chasing and transcribing phone calls.
- 4
Reconcile the stated history
It builds a timeline from the CV and checks it for gaps, overlapping employment and dates that contradict the certificates or the reference replies — the padded-tenure and unexplained-gap checks a rushed manual review misses.
- 5
Merge into one summary
It merges the parallel results into a single one-page summary: which checks passed, and the two or three items to look at — each with the certificate, referee reply or CV line it came from.
- 6
Hand to a human
The hiring manager reviews the flagged items and makes the hire decision. Nothing is auto-rejected — the agent surfaces evidence, a human decides.
Stage 4 · Build
How we build it with Claude
It's wired straight into your ATS or recruitment inbox through connected tools, so certificate scans and referee replies flow in without manual exports. Because the checks run in parallel and each writes its evidence as it goes, the summary your recruiter reads is fully sourced — every flag traces back to the exact certificate, referee reply or CV line it came from — and the agent never rejects a candidate on its own.
Integrations
- Your ATS / recruitment system
- Recruitment inbox or document store (certificate scans)
- Email / reference-request channel for referees
- Optional: an education or credential verification lookup
Under the hood
- Pattern: a parallelization (sectioning) workflow on the Claude Agent SDK — the certificate, reference and history checks are dispatched as concurrent sub-tasks and fanned back in, each tool exposed via an in-process MCP server.
- Context: each parallel branch gets only the slice it needs (a cert branch sees the cert + the CV claim it's testing, not the whole pack) — a context-engineering choice that keeps each check focused, cheaper, and injection-isolated.
- Tools: separated read vs write — read-only cert/OCR extractors, a CV/history parser and a timeline reconciler on one side; a single gated, idempotent reference-request sender on the other (a retry can't email a referee twice).
- Guardrails & least-privilege: schema-locked JSON output, no write access to the ATS/HR system of record, it never auto-rejects a candidate, and low-confidence certs or unmatched references route to the recruiter's queue.
- Untrusted input & PDPA: certificate text and referee replies are treated as untrusted (prompt-injection resistant — a doctored PDF or a hostile reference email can't steer the outcome); IC numbers, salary and candidate PII are handled PDPA-aligned with data-residency in scope.
- Recovery & escalation: a non-responding referee, an unreadable scan or a conflicting result is retried then escalated to a human — every branch ends at a person, never a silent pass or a silent reject.
- Observability & audit: every parallel check, tool call and the merged result is logged and traceable, so any verification summary — and the recruiter's final call against it — can be reconstructed if a rejected candidate challenges it.
- Eval harness: a golden set of historical candidate packs — including known doctored certs, padded tenures and unexplained gaps — with deterministic checks plus LLM-as-judge on the fuzzy calls, regression-tested on every change before it touches live candidates.
Stage 5 · Architect
Single model or multi-agent?
The checks are independent but each is a bounded, well-defined task sharing the same candidate context, so one well-instrumented model running parallel branches is the right call — reliable, cheaper, and easy to audit — rather than a full multi-agent design.
Fanning out into parallel branches is not the same as a ≈15×-token multi-agent system; we reserve that for genuinely open-ended, breadth-first research, not a fixed set of verification checks.
Which model does what
Read & validate certificates (incl. scans & photos)
Reliable vision and structured extraction on real-world certificate scans and phone photos.
Reconcile history & reason across the checks
The workhorse — strong reasoning to line dates, titles and references up and catch the subtle mismatches.
Classify & extract reference replies
Cheapest and fastest for pulling confirmed title/dates out of a straightforward referee email.
Adjudicate borderline / contested cases
Invoked only when a check is genuinely ambiguous — a small fraction of candidates.
What it costs — an estimate
AI usage — per candidate
certificate reads + reference parsing + reconciliation + summary, at Claude Sonnet/Haiku token rates
~RM 0.50–1.00
AI usage — at 100 candidates/month
roughly half with the Batch API for non-urgent overnight verification runs
~RM 50–100 / month
Build (one-off)
a focused single-pipeline agent is a few weeks of engineering; we quote fixed after a short discovery
scoped per integration
Ongoing
small next to the recruiter time it frees and one prevented bad hire
monitoring + support
Indicative only, shown in Ringgit at roughly RM 4.70 to the USD; per-token rates follow Anthropic's published pricing (confirm current figures). Actual AI usage depends on the number of certificates and referees and case complexity.
Stage 6 · Evaluate
How we measure success
- Deterministic checks first — certificate fields present, dates line up, referee replied
- Self-verification — the agent re-checks each flag against its source before surfacing it
- Business KPIs — recruiter time per candidate, time-to-clear, consistency, and doctored/padded cases caught
We score the agent with the Agent GPA framework — Goal, Plan, Action, a current standard for agent reliability — on top of the human baseline. (reference)
Setting the baseline
First we measure the current manual vetting on a sample — recruiter time per candidate, how long a full verification takes end to end, how consistently two recruiters reach the same conclusion, and how many issues slip through. That human baseline is what every agent metric is measured against, so the lift is provable rather than assumed.
What we test — Goal · Plan · Action
Agreement with a senior recruiter
Its summary, flags and recommended checks match an expert's on held-out candidate packs
Required checks executed
Every mandated check — each certificate, each referee, the full timeline — is run, nothing skipped
Effective parallelism
Independent checks actually run concurrently, collapsing calendar time, without dropping any
Certificate field extraction accuracy
Did it read each certificate — institution, qualification, dates — correctly?
Discrepancy recall (catch rate)
Of the real mismatches in the golden set — doctored certs, padded tenure, gaps — how many it flags
False-flag rate
How often it flags something that isn't actually a problem
No hallucinated findings
Every flag in the summary traces to a certificate, referee reply or CV line
The go-live gate
The agent does not touch a live candidate until it beats the human baseline and clears these GPA targets on a golden set of historical packs — including known doctored certificates and padded histories. Every change is regression-tested against the same set before it ships.
Stage 7 · Deliver
How we'd deliver it
We start with a proof-of-concept on your real historical candidate packs — including the ones with doctored certs and padded tenures you already caught — and prove reliability before it touches live candidates. A focused single-pipeline rollout is a matter of weeks.
Free consultation
Is your HR team verifying candidates by hand?
Tell us your hiring volume and what you check today, and we'll tell you honestly whether an HR verification agent is worth building — and what it would take.
Related use cases
Frequently asked questions
- Does the agent reject candidates?
- No. It reads, verifies and flags; a human hiring manager makes the hire or no-hire decision. Human-in-the-loop is essential — the agent surfaces evidence, it never auto-rejects a candidate.
- How is candidate data kept compliant with PDPA?
- With a full audit trail so any verification can be reconstructed, and built around PDPA requirements for where candidate data — IC numbers, certificates, salary — is processed, stored and accessed. Treat this as a starting point for your compliance team, not legal advice.
- Can it actually catch a doctored certificate?
- It catches internal inconsistencies and mismatches against the CV and references, and flags certs that look altered. For authoritative confirmation we can wire in an education or credential verification lookup — but the final judgement always sits with your recruiter.
- How long does it take to deploy?
- A proof-of-concept for one focused hiring pipeline is usually a matter of weeks; a full rollout takes longer, mostly because of integration and getting recruiters comfortable, not the AI.
Examples are based on real, anonymised engagements; details are generalised. Anchor Sprint is a member of the Anthropic Claude Partner Network — a deployment and rollout partner, not a reseller. This is general information, not legal or compliance advice.