AI Agent for HR: Resume Screening & Candidate Communication Automation

How an AI Agent Accelerates Resume Screening and Improves Candidate Experience

The HR department received 600 resumes in a week after posting a senior developer vacancy. Recruiters work 12 hours a day, but the queue doesn't shrink, and the best candidates get offers from competitors before you can respond. Sound familiar? We built an AI agent that processes a hundred resumes per hour with 89% accuracy, automatically writes personalized rejections and invitations, and schedules interviews via calendar. All without gender or age discrimination—anti-bias filtering is built in by default.

The agent solves three key problems: manual screening (slow and subjective), mass responses (writing each rejection manually is a recruiter's nightmare), and hiring analytics (who dropped out at which stage, which skills are most frequently missing). Below is the technical implementation and a real case from our practice.

HR Agent Components

from pydantic import BaseModel
from typing import Optional, Literal
from openai import OpenAI
import json

client = OpenAI()

class CandidateScreeningResult(BaseModel):
    candidate_id: str
    overall_score: int           # 0-100
    hard_skills_match: int       # % match of hard skills
    experience_match: int        # % match of experience
    red_flags: list[str]         # Stop-factors
    green_flags: list[str]       # Strengths
    recommendation: Literal["strong_yes", "yes", "maybe", "no"]
    next_step: str
    personalized_rejection_reason: Optional[str]

def screen_resume(
    resume_text: str,
    job_description: str,
    required_skills: list[str],
    nice_to_have: list[str],
) -> CandidateScreeningResult:
    """Screen resume against job requirements"""

    response = client.beta.chat.completions.parse(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": """You are an experienced recruiter. Objectively assess the candidate's fit for the vacancy.
DO NOT make assumptions—if experience is not explicitly stated, consider it absent.
Be honest in evaluating stop-factors."""
        }, {
            "role": "user",
            "content": f"""Job description:
{job_description}

Required skills: {required_skills}
Nice-to-have skills: {nice_to_have}

Candidate resume:
{resume_text}"""
        }],
        response_format=CandidateScreeningResult,
        temperature=0,
    )

    return response.choices[0].message.parsed

How We Achieve 90%+ Accuracy?

The magic is not in the model but in the prompt and post-processing. The system prompt above prohibits inferring skills—critical for honest screening. Additionally, we run the result through an anti-bias filter and log every call for an audit trail.

Compare: a human reviews 100 resumes in 4.5 hours, the agent does it in 18 minutes. Concordance rate of 89% means the agent agrees with the recruiter in 9 out of 10 cases. Better than a human? No, but 15 times faster. According to LinkedIn Talent Solutions, the average time-to-hire in IT is 35 days.

Order an audit of your hiring funnel—we will select the agent architecture for your stack.

Automated Responses to Candidates

def generate_candidate_response(
    candidate_name: str,
    decision: str,
    position: str,
    feedback: str = None,
) -> str:
    """Personalized response to candidate"""

    templates = {
        "invite_interview": f"""Dear {candidate_name},

Thank you for your interest in the {position} position. We found your experience interesting and would like to invite you for an interview.

Available slots: [CALENDAR_LINK]

The interview will take about 45 minutes. Format: video call.

Best regards,
Recruitment Team""",

        "rejection": None,  # Generate personalized
    }

    if decision == "rejection" and feedback:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{
                "role": "system",
                "content": "Write a polite rejection to the candidate. Tone: respectful, without clichés like 'you are not a fit'. Specify a concrete reason (without humiliating wording)."
            }, {
                "role": "user",
                "content": f"Candidate: {candidate_name}, Position: {position}, Reason: {feedback}"
            }],
        )
        return response.choices[0].message.content

    return templates.get(decision, "")

Batch Screening Pipeline

import asyncio
from typing import List

async def batch_screen_resumes(
    resumes: List[dict],
    job_description: str,
    required_skills: List[str],
    concurrency: int = 10,
) -> List[dict]:
    """Parallel screening of multiple resumes"""

    semaphore = asyncio.Semaphore(concurrency)

    async def screen_single(resume: dict) -> dict:
        async with semaphore:
            result = await asyncio.to_thread(
                screen_resume,
                resume["text"],
                job_description,
                required_skills,
                [],
            )
            return {
                "candidate_id": resume["id"],
                "name": resume["name"],
                "email": resume["email"],
                "screening": result,
            }

    results = await asyncio.gather(*[screen_single(r) for r in resumes])

    # Sort by score
    return sorted(results, key=lambda x: -x["screening"].overall_score)

Practical Case: Hiring 80 Call Center Operators

Task: Hire 80 call center operators in 3 months. Incoming flow: 600+ resumes per week. One recruiter.

Screening Criteria: customer service experience (required), good written communication (required), CRM knowledge (nice-to-have), willingness to work night shifts (required).

Agent Pipeline:

1. Parse incoming resumes from job boards (hh.ru/Avito API)
2. Screen via LLM (50 resumes in 8 minutes vs 4 hours manually)
3. Top 30% → invitation for phone screening
4. Rejections → personalized response automatically
5. After screening → schedule individual interview (Calendly integration)

Results:

• Time to screen 100 resumes: 4.5h (manual) → 18min (agent)
• Concordance rate (agent vs recruiter): 89% (verified on 200 jointly assessed resumes)
• False rejection rate (qualified rejected): 4.1%
• Time-to-hire: 42 days → 28 days
• Recruiter focus: shifted to interviews and onboarding

The client saved $8,000 per month on a second recruiter's salary, the agent took over 70% of the workload. Implementation costs were recouped in two months through reduced time-to-hire.

Legal limitation: the final hiring decision is made by a human. The agent provides a recommendation; the recruiter confirms.

Why Implement an AI Agent?

Get a consultation on implementation—we'll show how the agent fits into your current workflow.

What's Included in AI Agent Development?

Anti-bias Filtering

ANTI_BIAS_PROMPT_ADDENDUM = """IMPORTANT: When evaluating:
- DO NOT consider name, gender, age (if indicated), nationality
- Evaluate only professional competencies and experience
- Do not make assumptions based on personal data
- Apply the same criteria to all candidates"""

Timeline

• HR screening agent: 2–3 weeks
• Integration with job board API (hh.ru, etc.): 1–2 weeks
• Automated responses + calendar: 1 week
• Calibration with recruiter: 1–2 weeks
• Total: 5–8 weeks

Order an audit of your hiring funnel—we'll select the agent architecture for your stack. We'll evaluate your project in 2 days. Contact us by email or Telegram to get a cost and timeline estimate.

Based on technology: LLM OpenAI GPT-4o, LangChain, ChromaDB.