What this thing actually is
Most résumés don't get read.
We read all of them.
Intelletto sits inside the ATS you already run. It reads every résumé that lands there — not the top third — scores each one against the job you actually posted, and tells you why, with the line from the document sitting right next to the claim. Your hiring manager can check it. So can a regulator. So can the candidate.
This page is long on purpose
Read as much of it as you need.
There are three different people who open this page, and they want three different things from it. Pick your route — nobody is grading you on finishing.
Two minutes
Does it work, and what changes?
Four numbers, three products, and how it gets installed. Stop after the rollout path and you will have the whole argument.
Ten minutes
How does it reach a number?
Twelve stages, five gates, nine buckets, five modifiers. Written for the person who has to explain this to a hiring manager.
Due diligence
Would this survive a challenge?
Provenance chain, versioning, bias auditing, and the limits we will put in writing. Written for legal, risk, and anyone doing technical diligence.
Measurable lift · current quarter
The four numbers you already get asked about.
These are the ones that come up in your quarterly review, so they are the ones we lead with. Bars are drawn to scale — longer bar, bigger shift. Everything below this line is the explanation of how they moved.
So what does it actually do
Three things. One underlying engine.
Three products, one pipeline, one audit trail. Most teams turn on the first one, live with it for a quarter, then add the others. None of them asks you to move off anything you already own.
Read everything
Turn 200 messy PDFs into 200 comparable profiles.
Every résumé gets read, pulled apart, matched to the words your company uses for skills, and stored as a profile you can sort, compare and search. The trail runs all the way back to the bytes of the original PDF.
Score what matters
Scores that mean something specific.
Nine things scored against each role, weighted for how senior it is. Then we follow the people you actually hired and check what the score said against how they did at 30, 90 and 180 days. The rubric tightens after every group, not once a quarter when someone remembers.
Show your work
Decisions you can defend.
Every recommendation arrives with a reason, a confidence score, and the passages it rests on. Every sealed scorecard produces a 14-page audit report — read it inline, or hand the signed bundle to a regulator and let them re-run the check on their own machine.
✦ The one rule we don't bend
Three things it does. One thing it will never do.
It never rejects anyone. There is no reject state in the data model, no reject button in the interface, and no configuration flag that adds one. We are not going to build it and you cannot buy it as a custom feature.
Every candidate comes out of the pipeline in one of three bands, and a person decides what happens next. The software's job is to make sure a human being sees the people worth seeing, and knows why. Closing a door stays a decision a person makes, and owns, with their name on the override.
This is not a marketing position. It is the reason the audit trail in the second half of this page is worth anything at all — an unreviewable automated rejection is precisely the thing regulators are moving against, and it is the thing we removed rather than logged.
How it plugs in
We plug in. Nothing else changes.
Two halves of the same promise. Nobody gets a new system to log into, and nothing runs on its own until your team has watched it long enough to believe it.
The sidecar model
We talk to your ATS through APIs. That's the whole integration story.
The change-management slide is one line long: a new feed appeared inside the tool your team already uses. No new login. No new dashboard. No "has everyone been trained yet" meeting three weeks before go-live. Intelletto reads from and writes back to the systems below.
The rollout path
Shadow → Gated → Automate. You decide how fast.
Shadow.
Intelletto runs alongside your team and produces scores nobody acts on. At the end you put its calls next to your recruiters’ calls and compare. This is the "is this thing any good?" phase, and it should be.
Gated.
Recommendations show up in the recruiter's view, but every one needs a human approve / edit / decline. Every override gets logged and feeds the model.
Automate.
Only on the requisitions you say so, only above the confidence threshold you set. Pull the threshold back any time. There is no one-way door.
Under the hood
How a résumé turns into a number you can defend.
Twelve stages, five gates, nine buckets, five modifiers, four modes. It is a lot of machinery, and all of it exists to answer one question well enough that it holds up when somebody pushes back: why this person, and not that one? Everything from here down is the answer to that, taken apart.
stages
gates
buckets
modifiers
modes
The twelve stages
Twelve stages. Five quality gates. Same path, every time.
The first four stages answer the boring questions: what is this document, whose is it, have we seen it before, and what does the page actually say. The middle stages do the AI work. The last two produce the things a recruiter opens on a Tuesday morning.
Register & track
A file lands. We assign a tracking ID, hash the bytes, link it to a job code if there is one, and remember exactly when and where it arrived.
Have we seen this person?
Byte-level match catches the obvious. Email + name + phone catches the "same person, slightly different PDF" case. If it's a dupe, the run ends here.
04
Actually read the document
Google Document AI handles the OCR and layout. We strip the headers, footers, watermarks, page numbers — anything that isn't the content the candidate wrote.
Gate A · LosslessPull out the structure
Gemini pulls out skills, roles, achievements, certifications, languages and leadership signals, and files them into a fixed shape — not free text we have to guess at later. Every single claim is tied to the passage that supports it. No passage, no claim.
Gate B · SchemaSpeak the same language
"K8s", "Kubernetes" and "container orchestration" all collapse to the same node in your taxonomy. Certifications expand into the skill basket they imply.
Gate C · EvidenceLook around the web
LinkedIn, personal site, GitHub. We actually fetch the pages — we don’t claim to and then guess — and check the claims against them. Anything new we find carries the address it came from, permanently.
09
Freeze the inputs before scoring
All five gates run, every verdict written down. If the candidate gets through, we freeze everything that is about to feed the scorer and hash it. Re-score the same person next year and you get the same number — or you find out precisely what changed.
Gate D · Dedup Gate E · Artefacts11
Score against the actual JD
The nine buckets get weighted for how senior the role is. Five modifiers then move the base score up or down for evidence quality, proven results, and two kinds of risk. The full scorecard — every bucket, every modifier, every passage — is kept forever and never written over.
Hand the recruiter something they can use
A ranked shortlist. A scorecard per person showing what matched and what didn’t. Risk flags. A quality checklist. An audit packet a regulator can read start to finish. All of it lands inside the tool the recruiter already has open.
Five quality gates
Five questions we ask before a score is allowed to happen.
A score built on broken inputs is worse than no score at all, because a number is a thing people trust. So before the scorer is allowed to run, every candidate passes five gates. Two stop the run dead. Two raise a flag the recruiter sees. One attaches a quality summary. However it lands, the verdict goes in the audit packet.
Did the OCR actually read every page? Did anything drop silently?
Flag it. A human re-reads. The pipeline continues.
WARNDid the AI return the exact JSON shape we asked for?
Hard stop. A malformed extraction is not allowed to become a score.
BLOCKDoes every claim trace back to a passage in the source document?
Show the low-evidence claims to the recruiter. They decide.
WARNHave we already processed this person in your pool?
End the run as a duplicate. The original record stays untouched.
BLOCKURL quality, bounding boxes, normalisation hits, work history present?
Attach a quality summary. The score stays visible.
PASSWhere the AI actually fires
AI isn't a feature here. It's running in about two dozen places.
Most platforms bolt AI onto one step — usually résumé parsing — and call the job done. We use it right across the hiring loop. Every call has to come back in a fixed shape, and every claim it makes has to point at a passage. That is the difference between something you can score with and text the model made up.
Source & search
Find the right people, faster. Type what you actually want and the search figures out the intent.
Understand the candidate
Read every claim, then go check it. Normalise the skills, fetch the websites they listed, read the shape of the career.
Define the role
The job description gets the same treatment. "Ninja Engineer III" resolves to a real occupation, and a certification brings the skills it implies along with it.
Score the fit
A rubric that knows what job it is scoring. Weights shift with seniority, and a three-pass check catches experience that has been reworded rather than earned.
Engage & interview
Messages a candidate would actually open. Briefs that surface the gap-and-strength shape before the call.
Police its own bias
A separate auditor reviews everything the platform generated, across four bias dimensions. Never blocks. Always logged.
How we score
Nine buckets. Four seniority profiles.
A graduate engineer and a COO cannot share a rubric. What gets a junior onto a shortlist is not what gets a chief operating officer onto one, so we stopped pretending otherwise. The same nine buckets exist for every role — the weights just flip as the job gets bigger. "Can you do the work?" becomes "can you scale it?" becomes "can you own the function?" becomes "can you stand behind it in a board meeting?"
Nine scoring buckets · emphasis at Junior/Mid
Weights flip as seniority rises
A candidate with AWS Solutions Architect Pro probably knows what EKS is — even if their CV never says it.
The job ad asks for "EKS" in those exact three letters, and a naive scorer records a zero. We link recognised certifications back to the skills they imply, through the published occupation taxonomy. Hold the credential, carry the skills — counted at a strength that reflects how recent it is and how tightly it maps. Nobody should lose out for writing a tight CV instead of an exhaustive one.
Modifiers · applied after the base score
The bits the base score can't see on its own.
The base score answers one question: how well do this person’s skills line up with what the job asks for? Real question, but not the only one. Five modifiers then push the number up or down. Each one is itemised on the scorecard, so a recruiter can see exactly which one moved the score, by how many points, and on what grounds. No black box, no "the model felt strongly about this."
🎯How clean the match was
Exact matches to your skill list push the score up. A pile of "probably the same thing" guesses pulls it back down, because it should.
🔗How much we could actually verify
What share of the job’s requirements have a real passage behind them? Over half earns a bump. Under half gets pulled down to be honest about it.
📈Did they show any results
"Cut infrastructure cost 32%." "Grew ARR $14M." "Took the team from 6 to 40." Numbers on a CV are cheap to write and surprisingly rare — which is what makes them worth something.
🛡️Is this likely to stick
Seven factors — average tenure, gaps, continuity, momentum. Not there to punish anyone for a short stint. There to flag when the overall shape says this one probably won’t last, so a human can go and check.
🔄How big a jump is this
Seven factors again — distance from their last role, whether the seniority lines up, how recent the skills are, and whether they are crossing into a function they have never worked in.
We police our own AI
Every word the AI writes gets read by a different AI.
Worth being precise about the scope. The auditor reads only what Intelletto itself wrote — job descriptions, outreach drafts, score rationale. Not the candidate’s résumé. Not the hiring manager’s notes. It finds loaded language, says so, and offers a rewrite. A person always decides what happens next. It never blocks anyone’s work, and every finding is logged whether you act on it or not.
Gendered language
"Rockstar", "ninja", "aggressive", excessive "nurturing" — these quietly tilt the applicant pool. The auditor suggests neutral phrasing.
genderAge signals
"Digital native", "young and energetic", "recent grad". The shortcut is age. The auditor names it and asks what the underlying skill actually was.
ageRace, ethnicity & origin
"Native speaker", "no accent", geography shorthand that's really about where someone's from. Often unintentional. It proposes a fluency requirement instead.
originDisability & family
Physical-ability presumptions ("must be able to…" when the role doesn't require it) and family-status filters that don't predict performance.
disability / familyFour modes, one pipeline
Pick the path that matches how you actually hire.
Same twelve stages, four different routes through them. You pick the route per role, per source, or per team, and you can run all four in the same week without asking anyone.
Read, normalise, gate — don't score yet.
Use when you're building a pool of pre-qualified people for roles you haven't opened yet.
Take a pool candidate and score them against a JD that just opened.
Use when a req opens, you already have great candidates in the pool, and you want answers in minutes.
The whole thing: read, score, shortlist, in one pass.
Use when it's standard inbound for a live req. The most common path.
High-volume ingest, plus a clean Intelletto-format résumé per person.
Use when you're migrating from another ATS, importing an agency dump, or absorbing a historical pool.
The modes are only the start. Skill list bucket weights auto-score thresholds knockout rules who can see what culture-fit pillars — all of it is yours to set, and it is set per customer, not once for everybody. We are not trying to sell you a hiring philosophy. You already have one. This runs it.
Why you can trust the number
Five reasons every score holds up when someone asks "why?"
The person being scored, the manager doing the hiring, and the regulator reviewing the process all end up asking the same thing: where did this number come from? Software that cannot answer that has no business making recommendations about anybody’s career. Here is how we answer it.
01 · Provenance — every score traces back to the bytes
02 · Evidence per claim
No score without a source passage.
Every bucket exposes its matched and missing skills, with the exact line from the document next to each one. If we can't cite what we're crediting, we don't credit it — that's what the evidence gate is for.
03 · Versioning, not overwrites
Re-scoring never destroys history.
Edit the taxonomy, tweak the JD, adjust a weight — none of it overwrites yesterday's score. It creates a new scorecard_version alongside the old one. The original score, snapshot and rubric all stay intact.
04 · Configurable, not magic
Every weight is yours; every change is logged.
Bucket weights, modifier ranges, gate thresholds, and what counts as "the same skill" all belong to you. Every change writes a record, so anyone reviewing this later can reconstruct exactly what the rubric looked like on the day the decision was made — not what it looks like today.
05 · One-click Audit Report
A 14-page report and a signed bundle, on demand.
Every sealed scorecard ships with a cover sheet and verdict, bucket-by-bucket evidence, the full SHA256 chain from PDF to score, the pipeline stage outcomes, and the rescore history. Recruiters open it inline.
Auditors download the signed bundle and run our open-source verifier — on their own machine, against the immutable input snapshot — and get back a single line. Not "trust our signature": re-run the scoring yourself and see you get the same number. That's the bar.
The honest part
Where this doesn't help you.
Everything above this line is us making a case. Here is the other side of it, because you will find this out in month three anyway and it goes better if you hear it now.
It cannot read what isn't written down
If someone did the best work of their career and never put it on the page, we will not find it. Evidence-based scoring is only as good as the evidence. This is a real ceiling, and it is the reason a human still runs the interview.
The first quarter is the expensive one
Outcome intelligence needs your hires to reach 30, 90 and 180 days before it can tell you anything about your roles specifically. Shadow mode gives you a comparison inside a month. Genuine tightening of the rubric takes two or three cohorts.
Bad job descriptions make bad scores
We score against the job you actually posted. If the JD is a wishlist someone copied from a competitor, the scoring will faithfully reproduce that wishlist. We will flag the loaded language. We cannot fix the thinking behind it.
It won't settle an argument between two humans
When a hiring manager and a recruiter disagree about a finalist, the scorecard gives them better evidence to argue with. It does not pick. That judgement stays where it belongs, and honestly it should.
Governance is baked in
Not an afterthought. Not a checklist someone fills in after launch.
Security, privacy, fairness, reliability. Four words every enterprise software page prints in the footer and nobody reads. Here is what each of them actually means in this product.
Security
Encryption in transit and at rest. Role-based access with scoped tokens. Least-privilege defaults at every pipeline stage — no service has more read or write power than it needs for its specific job.
Privacy
Built for GDPR, PDPA and the regimes that look like them. What you can read depends on why you are looking — access is tied to purpose, not just to job title. Every extraction and every decision lands in an audit trail you can export yourself.
Fairness
Fairness monitors run continuously, not on request. Every artefact is signed. Every scoring run is reproducible. A bias report — the kind a regulator asks for — is exportable in one click.
Reliability
Speed targets set per stage and measured, not hoped for. Automatic retries on the calls that flake. The pipeline degrades gently rather than falling over when a downstream service is having a moment. And one-click rollback at every stage, because sometimes you just need yesterday’s pipeline back.
Start with evidence, not a deck
Give us a role you already filled. We'll show you what we'd have found.
Pick a requisition that closed six months ago, hand over the batch, and we will run it through everything on this page — including the applications nobody had time to open. Then compare our shortlist against who you actually hired. If it doesn't tell you something you didn't already know, we will say so and you will have lost a week.