Case studies on hiring, not slide decks.
Field essays for teams who build.

SituationA sourcing loop that keeps finding the same people

Most funnels are a Boolean search in a trench coat. Write the job description, pull the keywords, run the query, get back a list of people who used the right nouns. Volume was never the problem; signal is. Two candidates can match the same terms and deliver completely different outcomes in the same role.

ApproachScore compatibility instead of running a query

The Compatibility Index rates each candidate–role pair on three independent axes: hard-skill match (skill telemetry against the job's scouting profile), motivation alignment (a candidate motivation survey against the company's culture dimensions), and workstyle fit (remote philosophy, decision pace, operating rhythm). Each axis is scored on its own, and the composite drives the ranking.

• 40 structured skills scored per candidate across 7 competency categories
• 70+ organisation-DNA signals pulled from the Scouting Profile
• Motivation and workstyle scored independently, then combined
• A full match breakdown per applicant, not a single black-box number

ExecutionThe shortlist is the product

Recruiters open a ranked list with the evidence attached: DNA alignment, hard-skill percentage, and which dimensions actually drove the match. The interesting names are the outliers — high motivation, low keyword overlap — the people a traditional search would have buried on page nine.

OutcomeFewer interviews, better calls

Teams running the Compatibility Index report shorter time-to-shortlist, lower early attrition, and candidates who say the role matched the pitch. The reason sits upstream: when both the job and the candidate are structured, the comparison is real instead of guessed.

SituationScreening is the most repetitive work in hiring — and the first thing that gets rushed

The first three conversations with a candidate are largely the same every time: confirm the basics, probe the core skills, then see how the person actually works with others. At volume that is dozens of near-identical calls a week. They get rushed, skipped, or handed to whoever is free, and that inconsistency is exactly where strong candidates fall through and weak ones slip past.

ApproachConfigure the pipeline once; the agent runs it every time

Job posters set up the three-stage interview pipeline per role: what the pre-screen confirms, which competencies the technical round probes, and what the collaboration assessment looks for. The agent then runs that exact pipeline for every applicant — same questions, same rubric, same fairness — and scores each stage against the role you defined.

• Pre-screening: confirms must-haves, availability, and motivation before anyone spends a minute
• Technical interview: probes the role's core competencies against the 40-skill rubric
• Collaboration assessment: shows how the candidate reasons, communicates, and handles ambiguity
• Fully configurable per role — you set the questions, the weights, and the pass bar
• Candidates interview on their own schedule; no calendar tetris for your team

ExecutionYour team meets the shortlist, not the slush pile

Every applicant goes through the same three rounds and arrives with a structured result: stage-by-stage scores, the evidence behind them, and a clear pass or hold against the bar you set. Recruiters open a ranked, pre-evaluated list instead of a hundred unscreened CVs. The repetitive screening that used to cap how many people you could fairly consider stops being the bottleneck.

OutcomeMore qualified candidates seen, fewer hours spent seeing them

Because the agent never runs out of hours, you can screen every applicant properly rather than the first twenty who applied. Teams put their time into final-round judgment and candidate experience — the parts that genuinely need a human — while the consistent, structured screening runs underneath at any volume.

SituationRecruiting agents with nothing structured to query

Today's AI sourcing tools scrape public profiles, parse free text, and hallucinate fit. The agent isn't the weak link; the signal source is. Unstructured HTML was never a talent API. Point an agent at a structured Mirage profile instead and it gets 40 scored skills, a motivation profile, a workstyle map, and a Compatibility Index value. A different class of input entirely.

ApproachConsent-gated MCP endpoints as the protocol boundary

Mirage exposes structured profile data as a remote MCP server. Every tool call is scoped by explicit consent: candidates control what agents can see, and organisations control which connectors can query their job and company data. The agent sees only what a human has permitted, and the audit log proves it.

• search_candidates — structured filters, consent-gated results
• get_candidate_profile — redacted by scope, no raw résumé or contact data
• search_companies — active organisations with published Scouting DNA
• find_job_matches — ranked candidates from the live Compatibility Index
• OAuth bearer auth — every call authenticated and audited

ExecutionConnect an agent to real structured data

Platform and RevOps teams point AI scouting agents at real structured data instead of scraped HTML. Early connectors shaped the tool schema, consent model, and scope boundaries. The matching and profile data underneath are live — and so is the MCP transport that exposes them, behind OAuth and a full audit trail.

OutcomeThe talent layer for the agentic era

Profiles as MCP servers move Mirage from a hiring platform toward an infrastructure layer — the source AI recruiting agents query instead of scraping. Once agents read structured, consent-gated profiles, sourcing turns into discovery: they find people who fit rather than people who described themselves with the right words.

SituationA CV is a marketing document, not an evaluation

Candidates tune CVs for keyword density and recruiter attention. Recruiters scan for word presence, not proof. Neither side learns much about fit. What you get is a process that reliably surfaces people who describe themselves well, which is not the same as people who can do the work.

ApproachSelf-assessed scores, calibrated to the market

Skill telemetry collects self-assessments across 40 skills in 7 competency categories: Technical, Leadership, Communication, Analytical, Creative, Domain, and Interpersonal. Each score is plotted on a radar chart against the market's expected level for the candidate's target role. Out comes a competency score, a market percentile, and an honest read on strengths and growth areas.

• 40 skills across 7 competency categories
• Radar chart: your score against market expectation
• One competency score and level, from Developing to Master
• Top strengths and growth areas surfaced automatically
• Market Value card: your percentile for the target role

ExecutionFrom self-assessment to sourcing filter

On the hiring side, recruiters filter by skill score, competency level, and specific gaps rather than keyword frequency. On the candidate side, people see exactly where they rank and which gaps map to mentors who can help close them. The same structured data feeds the Compatibility Index, so skills aren't merely visible; they're scored against the role.

OutcomeEvidence replaces description

When the candidate and the role are both described in structured skill data, matching becomes a comparison instead of a guess. Shortlists built this way surface people a keyword search would miss, and quietly drop the ones who write well but score below the bar on the skills the role actually needs.

SituationA certificate is a dead end; a profile should be alive

Most learning platforms hand you a PDF and stop. The gap that sent you there is closed, but nothing downstream knows it. Your profile still shows the old you, the next interview re-asks what you already proved, and any system reading your data is reading a snapshot that went stale the day it was written. Learning that doesn't travel is learning you have to keep re-proving.

ApproachOne confirmed skill level, shared by Academy and interview

Mirage keeps a single source of truth for what you can actually do. When the Academy confirms a skill, it doesn't write to its own private record — it updates the same confirmed skill level the interview pipeline reads. There's no second copy to drift out of sync. The level you proved by learning is the exact level the next interview sees, with an advance-only guard so a hard-won gain can't be silently downgraded.

• Confirmed skill levels live in one shared store — Academy writes it, interviews read it
• Proof is verified, not self-claimed: your evidence is matched to the rubric before a level moves
• A learning summary is re-embedded after every milestone, so retrieval always sees the latest you
• Advance-only guard: a level you earned can't quietly slip backwards
• No second record to fall out of date — the profile and the proof are the same object

ExecutionFinish a module, and the loop closes on its own

Complete a module and three things happen without you lifting a finger. Your evidence is routed to the rubric and the confirmed skill level is updated. A fresh learning summary — "completed N courses across these skills, most recent first" — is regenerated and re-embedded, replacing the previous one rather than stacking on top of it. From that moment your next interview can retrieve what you just learned. The growth isn't announced; it's already in the signal.

OutcomeLive DNA the next system always reads correctly

Because the proof updates the profile in place and the summary is replaced on every milestone, your talent DNA is never a snapshot — it's the current you. That's what keeps the platform's structured profiles relevant now that they're open to AI agents: profiles are consent-gated MCP endpoints, so an agent querying yours reads skills that were re-confirmed this week, not last year. The freshness isn't a sync job someone has to remember to run; it's built into how learning is recorded.