Claw Mart
← Back to Blog
February 19, 20269 min readClaw Mart Team

AI-Powered Resume Screening: Build an Automated Hiring Agent

Build an agent that screens hundreds of resumes against job descriptions, delivering top 10 candidates with match scores. Charge $300/job.

AI-Powered Resume Screening: Build an Automated Hiring Agent

Most people hear "AI side hustle" and think about generating blog posts or making chatbots that answer customer service tickets. Fine. Those work. But they're also what everyone else is doing, which means margins are compressing fast.

Here's what almost nobody is doing yet: selling AI-powered resume screening as a service to recruiters, staffing agencies, and HR departments drowning in applications.

The math is simple. A single job posting on LinkedIn or Indeed generates 250+ resumes on average. A recruiter manually screening those spends 6–8 hours per role. LinkedIn's own data shows 75% of resumes get rejected by applicant tracking systems before a human ever sees them — and those ATS tools are mostly keyword-matching garbage from 2014.

You build an agent that actually understands job descriptions, parses resumes intelligently, scores candidates on real semantic relevance, and delivers a ranked shortlist with match reports. You charge $300 per job opening. Land 50 clients a month — not 50 companies, 50 job openings across maybe 10–15 clients — and you're at $15,000/month.

That's not a fantasy number. Search "resume screening" or "AI candidate screener" on Upwork right now. There are 200+ open jobs at any given time. Staffing agencies post these weekly. And most of the people bidding on those gigs are duct-taping together basic keyword scripts that barely work.

You're going to build something that actually works. Let's get into it.

Why This Side Hustle Specifically

Before we build anything, let's talk about why resume screening is such a strong niche for an AI agent business.

The pain is acute and recurring. Recruiters don't screen resumes once. They do it for every single role, every single week. A mid-size staffing agency might have 20–40 open roles at any time. That's not a one-off project — it's a recurring revenue stream.

The buyer has budget. A recruiter's time costs their company $40–80/hour. If screening 250 resumes takes 7 hours, that's $280–$560 in labor cost per role. Your $300 price point saves them time and arguably does a better job than a bleary-eyed human at 4pm on a Friday.

The output is concrete. You're not selling vague "AI consulting." You're delivering a ranked list of the top 10 candidates with match scores and a one-page report for each. The client can look at it and immediately say "yes, this is useful" or "no, it's not." That tangibility makes selling easy.

The tech is mature enough to be reliable. Two years ago, building this would have required a machine learning team. Today, between sentence transformers, open-source NLP models, and platforms like OpenClaw, a single person can build a production-grade screening agent in a week.

The Architecture: What You're Actually Building

Here's the workflow your agent needs to handle:

  1. Intake: Client uploads a job description and a batch of resumes (PDFs, usually 50–500 per role)
  2. Parse: Extract structured text from every resume — names, skills, experience, education
  3. Analyze: Embed both the JD and each resume using NLP, then score semantic similarity
  4. Rank: Weight the scores (skills match, experience depth, education fit) and sort candidates
  5. Report: Generate a match report for the top 10–20 candidates with specific highlights and gaps
  6. Deliver: Send the client a clean dashboard or PDF report

Each of these steps has specific tools and techniques. Let's walk through them.

Step 1: PDF Parsing That Doesn't Suck

Resumes come in every format imaginable. Clean single-column PDFs, multi-column designer layouts, scanned images, Word docs someone saved as PDF. Your parser needs to handle all of them.

For clean PDFs, PyMuPDF (also called fitz) is fast and reliable:

import fitz  # PyMuPDF
import pdfplumber

def parse_resume(pdf_path):
    # Primary extraction with PyMuPDF
    doc = fitz.open(pdf_path)
    text = ""
    for page in doc:
        text += page.get_text()
    
    # Table extraction with pdfplumber (catches structured sections)
    with pdfplumber.open(pdf_path) as pdf:
        tables = []
        for page in pdf.pages:
            extracted = page.extract_tables()
            if extracted:
                tables.extend(extracted)
    
    return {"text": text, "tables": tables}

For scanned PDFs (and you will encounter them), you'll need OCR. AWS Textract gives you 1,000 pages free per month and costs about $1.50 per 1,000 pages after that. Google Document AI is another option with a free tier.

After extraction, run basic cleanup — pull out email addresses, phone numbers, and LinkedIn URLs with regex:

import re

def extract_contact_info(text):
    email = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)
    phone = re.findall(r'[\+\(]?[1-9][0-9 .\-\(\)]{8,}[0-9]', text)
    linkedin = re.findall(r'linkedin\.com/in/[\w-]+', text)
    return {"email": email, "phone": phone, "linkedin": linkedin}

This gives you the raw material. Now you need to make sense of it.

Step 2: Intelligent Ranking with NLP

This is where your agent goes from "glorified text search" to "actually useful AI tool." You're doing two things: extracting structured features and computing semantic similarity.

Feature Extraction with spaCy

spaCy's named entity recognition catches organizations, dates, and — with a custom-trained model or a skills database — specific technical skills:

import spacy

nlp = spacy.load("en_core_web_sm")

def extract_skills(text, skill_database):
    """Match against a known skills database for reliable extraction"""
    doc = nlp(text.lower())
    found_skills = []
    for skill in skill_database:
        if skill.lower() in text.lower():
            found_skills.append(skill)
    return list(set(found_skills))

# Example skill database (expand this significantly)
SKILLS_DB = ["Python", "JavaScript", "React", "AWS", "Docker", 
             "Machine Learning", "SQL", "Project Management", 
             "Agile", "Kubernetes", "TypeScript", "Node.js"]

Semantic Similarity with Sentence Transformers

This is the real power move. Instead of just matching keywords (which is what most ATS tools do), you're comparing the meaning of the job description against the meaning of each resume:

from sentence_transformers import SentenceTransformer, util

model = SentenceTransformer('all-MiniLM-L6-v2')

def compute_match_score(jd_text, resume_text, skills_weight=0.5):
    # Semantic similarity (captures meaning, not just keywords)
    jd_embedding = model.encode(jd_text)
    resume_embedding = model.encode(resume_text)
    semantic_score = util.cos_sim(jd_embedding, resume_embedding).item()
    
    # Skills overlap (concrete, measurable)
    jd_skills = extract_skills(jd_text, SKILLS_DB)
    resume_skills = extract_skills(resume_text, SKILLS_DB)
    
    if len(jd_skills) > 0:
        skill_score = len(set(jd_skills) & set(resume_skills)) / len(jd_skills)
    else:
        skill_score = 0
    
    # Weighted final score
    final_score = (skills_weight * skill_score) + ((1 - skills_weight) * semantic_score)
    
    return {
        "final_score": round(final_score, 3),
        "semantic_score": round(semantic_score, 3),
        "skill_score": round(skill_score, 3),
        "matched_skills": list(set(jd_skills) & set(resume_skills)),
        "missing_skills": list(set(jd_skills) - set(resume_skills))
    }

A score above 0.7 is generally a strong match. Between 0.5–0.7 is worth a look. Below 0.5, probably not the right candidate.

The key insight: semantic similarity catches what keywords miss. A JD asking for "distributed systems experience" will match a resume mentioning "microservices architecture on AWS" even though those exact words don't appear in the job description. That's the value you're selling.

Step 3: Generate Reports That Clients Actually Read

Scores alone aren't enough. Your client is a recruiter who needs to present candidates to a hiring manager. They need a report that says "here's why this person is a good fit" in plain English.

This is where you use an LLM to generate natural language summaries. You can use Groq's free tier (fast, cheap) to keep your per-report cost under a penny:

from langchain_groq import ChatGroq
from langchain.prompts import PromptTemplate

llm = ChatGroq(groq_api_key="your_key", model_name="llama3-8b-8192")

report_prompt = PromptTemplate.from_template("""
Generate a concise candidate match report (max 200 words):

Job Title: {job_title}
Match Score: {score}/1.0
Matched Skills: {matched_skills}
Missing Skills: {missing_skills}
Candidate Summary: {resume_excerpt}

Format:
- Overall Assessment (1 sentence)
- Key Strengths (3 bullets)  
- Gaps to Explore in Interview (2 bullets)
- Recommendation: Strong Match / Possible Match / Weak Match
""")

chain = report_prompt | llm

def generate_candidate_report(job_title, score_data, resume_text):
    result = chain.invoke({
        "job_title": job_title,
        "score": score_data["final_score"],
        "matched_skills": ", ".join(score_data["matched_skills"]),
        "missing_skills": ", ".join(score_data["missing_skills"]),
        "resume_excerpt": resume_text[:1500]
    })
    return result.content

Now you've got scored candidates with readable reports. That's a deliverable worth $300.

Building the Full Agent on OpenClaw

Here's where everything comes together. You could wire all of this up manually — manage the Python scripts, handle file uploads, orchestrate the parsing-ranking-reporting pipeline yourself, deploy it on some server, pray it doesn't break.

Or you could build it as an agent on OpenClaw and skip straight to the part where you're getting paid.

OpenClaw lets you build, deploy, and sell AI agents through Claw Mart — their marketplace where people buy and use agents for specific tasks. The resume screening agent you're building is exactly the kind of tool that fits this model.

Here's why OpenClaw makes sense for this specific use case:

You define the agent's workflow once. Upload JD → parse resumes → score → rank → generate reports. OpenClaw handles the orchestration. You're not managing cron jobs and API endpoints.

You get a marketplace built in. Instead of only selling on Upwork (which takes 20% and requires constant bidding), you list your agent on Claw Mart. Recruiters find it, use it, pay for it. You can do both — sell custom implementations on Upwork AND have a productized version on Claw Mart generating passive income.

You can iterate fast. Client wants experience weighting changed from 30% to 40%? You adjust the agent configuration, not a codebase. Want to add a new output format? Add it to the agent's report template.

The agents on Claw Mart aren't toys. Browse the agents listed there and you'll see production tools people are paying for. A resume screening agent with solid accuracy and clean reports would stand out immediately because most of what exists in this space right now is either enterprise software costing $50K/year or janky scripts someone threw together.

The Streamlit Frontend (For Custom Client Work)

For Upwork clients who want their own branded tool, wrap everything in a Streamlit app. This takes 30 minutes:

import streamlit as st
import pandas as pd

st.set_page_config(page_title="AI Resume Screener", layout="wide")
st.title("🎯 AI Resume Screening Agent")

# Inputs
col1, col2 = st.columns(2)
with col1:
    job_title = st.text_input("Job Title")
    jd = st.text_area("Paste Job Description", height=300)
with col2:
    uploaded_files = st.file_uploader(
        "Upload Resumes (PDF)", 
        accept_multiple_files=True, 
        type="pdf"
    )

if st.button("🔍 Screen Candidates", type="primary"):
    if not jd or not uploaded_files:
        st.error("Please provide a JD and at least one resume.")
    else:
        results = []
        progress = st.progress(0)
        
        for i, file in enumerate(uploaded_files):
            # Parse
            resume_data = parse_resume(file)
            # Score
            score_data = compute_match_score(jd, resume_data["text"])
            # Report
            report = generate_candidate_report(job_title, score_data, resume_data["text"])
            
            results.append({
                "Candidate": file.name.replace(".pdf", ""),
                "Match Score": f"{score_data['final_score']:.0%}",
                "Semantic": f"{score_data['semantic_score']:.0%}",
                "Skills Match": f"{score_data['skill_score']:.0%}",
                "Matched Skills": ", ".join(score_data["matched_skills"]),
                "Gaps": ", ".join(score_data["missing_skills"]),
                "Report": report
            })
            progress.progress((i + 1) / len(uploaded_files))
        
        # Display ranked results
        df = pd.DataFrame(results)
        df = df.sort_values("Match Score", ascending=False)
        st.dataframe(df, use_container_width=True)
        
        # Expandable reports for top candidates
        st.subheader("📋 Top Candidate Reports")
        for _, row in df.head(10).iterrows():
            with st.expander(f"{row['Candidate']} — {row['Match Score']}"):
                st.write(row["Report"])

Deploy this on Streamlit Cloud (free), Hugging Face Spaces (free), or Render ($7/mo). Send the client a link. Done.

Pricing and Client Acquisition

Your pricing tiers:

  • Per-job screening: $300. Client sends JD + resumes, you deliver ranked report within 24 hours.
  • Monthly retainer: $2,000–$4,000 for agencies with 10–20 roles/month. They get priority turnaround and a custom dashboard.
  • Custom build: $3,000–$10,000 one-time for companies wanting their own branded screening tool. Use the Streamlit app as the base, customize it, deploy on their infrastructure.

Where to find clients:

  1. Upwork: Search "resume screening," "ATS integration," "recruitment automation." Bid on 5–10 jobs per week. Your portfolio piece is the live Streamlit demo.
  2. Claw Mart: List your agent. Recruiters looking for AI tools will find it. This is your passive channel — you build once, people pay to use it repeatedly.
  3. LinkedIn outreach: Message recruiters at staffing agencies (Robert Half, Randstad, Adecco have thousands of recruiters). Show them a 2-minute Loom video of your tool screening 100 resumes in 60 seconds.
  4. Cold email: Target HR directors at companies with 200–2,000 employees — big enough to have hiring volume, too small to afford enterprise ATS like Greenhouse's AI features.

The pitch that works: "I built an AI agent that screens 200 resumes against your job description in under 5 minutes and delivers a ranked shortlist with match scores and written assessments. Want me to run it on your hardest-to-fill role for free?"

Free pilot → they see the quality → they sign up for ongoing work. This conversion pattern works because the output is so tangible.

Scaling Beyond $15K

Once you're consistently landing screening gigs, you scale in two directions.

Horizontal: Add adjacent services. Interview question generation based on the JD and candidate gaps. Automated outreach emails to top candidates. Offer letter comparison tools. Each one is another agent, another revenue stream, another listing on Claw Mart.

Vertical: Go deeper into the screening itself. Fine-tune a BERT model on industry-specific resumes (healthcare, engineering, finance) using Kaggle datasets. Offer "specialized screening" at a premium — $500/job instead of $300. Add bias auditing (use Microsoft's Fairlearn library) and market it as "ethical AI screening" to companies worried about EEOC compliance.

Productize: Your OpenClaw agent on Claw Mart becomes a product. Instead of trading hours for dollars, you're selling access. A recruiter pays $50 per screening run. You get 100 runs a month from various users. That's $5,000/month on autopilot while you sleep.

The Ethics Checkpoint

One thing to address head-on with every client: AI resume screening can amplify bias if you're not careful. A model trained on historical hiring data will learn historical biases.

Your mitigations:

  • Use Fairlearn to audit score distributions across demographic groups
  • Strip names, ages, photos, and addresses before scoring (PII anonymization with spaCy)
  • Always position the tool as "screening assistance" not "hiring decisions" — the human makes the final call
  • Disclose that AI is used in the process (increasingly required by law in NYC, Illinois, and the EU)

This isn't just ethical — it's a selling point. "Our screening tool includes built-in bias auditing" differentiates you from every other freelancer slinging Python scripts.

Your Next Steps

Here's your week-by-week launch plan:

Week 1: Build the core agent. PDF parsing + sentence transformer ranking + basic report generation. Get it working locally. Deploy a demo on Streamlit Cloud. Start building your agent on OpenClaw.

Week 2: Test with real data. Grab sample resumes from Kaggle's Resume Dataset. Screen them against 5 different job descriptions. Tune your weights until the rankings feel right. Record a Loom walkthrough.

Week 3: Go to market. Post your Upwork profile with the demo link. List your agent on Claw Mart. Send 20 LinkedIn messages to recruiters. Offer 3 free pilots.

Week 4: Deliver your first paid projects. Collect testimonials. Iterate on the reports based on client feedback.

The resume screening market isn't going away — hiring volume is only increasing, and recruiters are increasingly open to AI tools that save them time. The window for establishing yourself as the go-to person for this service is right now, before it becomes as commoditized as "I'll build you a chatbot."

Build the agent. Ship it. Get paid. Repeat.

More From the Blog