How do you match candidates by meaning instead of keywords, and make every AI hiring decision explainable?
Azati built an AI candidate-matching system that reads resumes and vacancies, matches them by meaning rather than keywords, and writes the reasoning behind every score. Four specialized LLM engines run as governed LangGraph state machines behind a stateless API. The result: 40% shorter time-to-hire, 25% better match accuracy, and an audit trail for every AI decision.
reduction in time-to-hire
improvement in candidate-role match accuracy
resumes processed automatically every day
A professional-services company with over 1,000 employees was losing weeks to manual resume screening. Recruiters compared hundreds of CVs against project requirements by hand, and identical skills described in different words slipped through keyword search. Azati developed an automated matching system that reduced time-to-hire by 40% and improved placement accuracy by 25%, letting teams staff projects faster and with fewer misses.
| Fact | Detail |
|---|---|
| What it is | An AI talent-matching product that turns raw CVs and vacancies into structured profiles, ranks candidates by semantic fit, and generates a written justification for every match. |
| AI core | Four specialized engines: Extraction, Embedding, Virtual Assessor, Vacancy Generator, each a governed multi-step LangGraph state machine, evaluated and improved independently. |
| Architecture | Stateless FastAPI entry point → Redis + Celery background processing plane → LLM engines → PostgreSQL + pgvector (HNSW) as a single system of record. |
| Explainability | Every score is stored together with the reasoning behind it, ready for analytics, audit, and tightening AI-hiring regulation such as the EU AI Act. |
| Model-agnostic | OpenAI, DeepSeek, or self-hosted models, swappable per deployment, no vendor lock-in. |
| Proven in daily use | Apart from several client deployments, the system also runs inside Azati's own internal operations platform, matching engineers to projects for a 300+ person company. |
Resumes arrived in every imaginable structure: different templates, languages, section orders, and levels of detail. The same qualification could be a bullet point, a paragraph, or a certification line. A rule-based parser could not normalize this variety, so the system needed an LLM-driven extraction layer that understands documents the way a recruiter does, and outputs one consistent, structured profile regardless of the source format.
Similar qualifications are often described in completely different terminology, so keyword search misses strong candidates. The system had to find people based on the context and nuance of a job description, built event-driven microservices should match designed Kafka-based distributed systems, while keeping accuracy and speed stable across a growing base of thousands of profiles.
A ranking without a rationale is impossible to trust, and increasingly impossible to use, as AI-in-hiring regulation tightens. The system had to record not just each score but the reasoning behind it, so a recruiter, an auditor, or a regulator can always answer why the system ranked a given candidate where it did.
Requests flow top to bottom: a stateless API takes every call, heavy AI work moves off the request path into a background processing plane, four specialized AI engines do the thinking, and a single system of record holds the results.
A thin, stateless FastAPI application authenticates the request (JWT) and routes it to the right workflow, streaming live progress back over WebSocket. Bulk imports sync automatically from Google Drive. Heavy AI jobs never block the request path: Redis queues with Celery workers run a priority lane for interactive work, a general lane for bulk processing, and a scheduler for recurring imports.
Each engine is a governed multi-step state machine built on LangGraph, not a single prompt, traced with LangSmith, and evaluated and improved independently:
PostgreSQL with pgvector is the single system of record: profiles, matches, scores, and the reasoning behind them, plus HNSW vector indexes for millisecond semantic search. Match history forms a complete audit trail. Redis handles queues, task status, and caching.
The AI layer is model-agnostic: OpenAI, DeepSeek, or self-hosted private models, swappable per deployment with no vendor lock-in. Deployments with strict data-residency requirements can run entirely on self-hosted models.
Four governed AI engines already do this work in production, matching by meaning, not keywords, and explaining every score. Let's talk about your hiring pipeline.
Fix my hiring pipelineAutomatically extracts and interprets candidate data from diverse resume formats, capturing skills, experience, education, and achievements, and normalizes varying structures and terminology into one consistent profile.
Stores profiles as vectors to enable fast, context-aware semantic search. The system understands the meaning behind candidate profiles and job requirements rather than matching keywords.
Recruiters fine-tune the weight of skills, experience, education, or certifications, so rankings reflect the real priorities of each role or project.
Evaluates each candidate's suitability skill by skill and generates a plain-language explanation of strengths, gaps, and contextual fit. Every score is stored with its rationale.
Drafts a complete vacancy description and screening questions from a few parameters, closing the loop: the same system that reads candidates also writes consistent, structured vacancies for them to be matched against.
A stateless API and a queue-based processing plane mean capacity grows by adding machines, no re-architecture on the growth path.
Four engines behind one orchestrator, each can be measured, improved, or moved to a different AI model without touching the rest of the system.
Every score and its reasoning is stored alongside the data it came from, ready for analytics, audit, and tightening AI-hiring regulation. Recruitment AI is classified as high-risk under the EU AI Act, which makes decision traceability a compliance requirement, not a nice-to-have.
Automated resume screening and semantic matching significantly accelerated early-stage candidate evaluation.
Context-aware search consistently delivered more relevant candidates aligned with project requirements.
The queue-based architecture handled high data volumes with stable performance.
Recruiters see why each candidate scored the way they did, which raises trust in the shortlist and speeds up decisions.
A single scoring methodology applied uniformly across all applicants reduces individual screener bias.
Faster, more accurate selection fills roles earlier and reduces project delays and resource gaps.
Four governed AI engines, a full audit trail, and model-agnostic infrastructure ready for regulation like the EU AI Act. Let's talk about your recruitment stack.
Book a scoped pilotKeyword screening finds exact word overlaps; semantic matching compares meaning. Azati's system converts resumes and vacancies into vector representations, so "built event-driven microservices" and "designed Kafka-based distributed systems" are recognized as the same competence, which is where the 25% accuracy improvement comes from.
Yes. The Virtual Assessor scores each candidate skill by skill and writes the reasoning behind the score. Every score and its rationale is stored in the system of record, forming a complete audit trail.
Yes. ATS and partner systems connect through the same secure REST API used by the recruiter workspace, and bulk CV import can sync automatically from shared storage such as Google Drive.
It is model-agnostic by design: OpenAI, DeepSeek, or self-hosted private models, swappable per deployment. Organizations with strict data-residency requirements can run it entirely on their own infrastructure.
Recruitment AI falls into the EU AI Act's high-risk category, which requires transparency and traceability. This system was designed for that: every automated score carries stored reasoning and full match history, giving compliance teams the documentation the regulation expects.
The core matching pipeline, extraction, embedding, semantic search, and assessment, was delivered as a working system processing real resumes within months, then extended iteratively. Timelines depend on data sources and integration scope; Azati typically starts with a scoped pilot on the client's own resume flow.
Enterprise task management platform frontend: task entities, computed fields, filtering, and epic/story dependency modeling, built on React, TypeScript, MobX, and Feature-Sliced Design.
Custom Redmine plugin: department reporting, automated time logging reminders, leave management, and branded theme built in Ruby on Rails for 350+ person software company.
5+ years of backend engineering on a global EdTech platform: 1M+ students, LMS integrations, zero-downtime at billion-record scale.
Custom Redmine plugin development and full-stack upgrade for a DevOps MSP, 30+ plugins adapted, Ruby 3 and Rails 7 migration, zero business disruption.
Mobile app with CNN model for automated steak marbling quality assessment.
Secure locally-hosted LLM alternative for confidential corporate communication.
Last updated
