Every recruiter I've spoken to says the same thing: "We're drowning in applications." Hundreds of resumes pour in for a single role. Most get skimmed for 6 seconds. Great candidates slip through the cracks. The process is slow, biased, and fundamentally broken.
So I built an AI agent that fixes it — and I gave it a brain powered by Groq and a command center powered by Notion.
What I Built
AI Hiring Agent is an autonomous recruitment system that turns a Notion database into a live AI control tower for hiring. No dashboards to build. No new tools to learn. Your team already lives in Notion — now your AI does too.
Here's the core idea: you drop a candidate into a Notion table with their name, skills, experience, and the role they applied for. That's it. The agent picks them up automatically, sends their profile to a large language model (LLaMA 3.3 70B via Groq), and within seconds writes back a fit score (0–100), five tailored interview questions, and a hire/reject recommendation with reasoning — all directly into the same Notion row. The candidate's status flips from Pending to Reviewed without a single human click.
This isn't a chatbot. It's not a form processor. It's a persistent, polling agent that watches your hiring pipeline 24/7 and acts the moment new candidates appear. Think of it as a senior recruiter who never sleeps, never has an off day, and evaluates every single applicant with the same rigorous criteria.
The Problem It Solves
Traditional hiring is broken in three specific ways:
1. Volume kills quality. A single job posting on LinkedIn can generate 200–500 applications. Recruiters physically cannot give each one the attention it deserves. The result? Pattern-matching on brand names and keyword scanning — not actual evaluation.
2. Inconsistency is the norm. The first resume reviewed on Monday morning gets a different level of scrutiny than the 80th one reviewed on Friday afternoon. Human fatigue introduces invisible bias that no training session can fully eliminate.
3. Speed matters and teams are slow. Top candidates have a shelf life of about 10 days before they accept another offer. Most companies take 3–6 weeks to move from application to first interview. The best people are gone before you even open their resume.
The AI Hiring Agent attacks all three problems simultaneously. Every candidate gets the same depth of analysis. Evaluations happen in seconds, not days. And because the agent runs continuously, there's zero lag between a candidate appearing and being evaluated.
Demo
Watch the full walkthrough — from candidate insertion to AI-powered evaluation, all happening live inside Notion.
How Notion MCP Is the Core
This is the part I want to emphasize: Notion isn't just the database here. It's the entire control plane.
In most AI projects, you'd build a separate frontend, wire up a REST API, design a dashboard, and bolt on a database. That's weeks of work before you even get to the AI logic. With Notion as the Model Context Protocol (MCP) layer, I collapsed all of that into a single surface.
Notion serves as:
- The input layer — recruiters add candidates directly where they already work
-
The processing trigger — the
Pendingstatus acts as a job queue - The output layer — scores, questions, and recommendations appear in the same row
- The audit trail — every evaluation is timestamped and visible to the entire team
- The human override — managers can review AI decisions and change statuses manually
The agent doesn't own the data. Notion does. The agent doesn't own the workflow. Your team does. The AI is a participant in a human-controlled system, not a black box making decisions in isolation. That's the power of using Notion as a control tower — full transparency, zero context switching.
Architecture
┌─────────────────┐ poll every 60s ┌───────────────────┐
│ Notion DB │ ◄─────────────────── │ AI Hiring Agent │
│ (Candidates) │ ──────────────────► │ (Python) │
└─────────────────┘ read Pending / └─────────┬─────────┘
write Score, │
Questions, │ analyze
Recommendation, │ candidate
Status ▼
┌─────────────────┐
│ Groq API │
│ (LLaMA 3.3 70B) │
└─────────────────┘
No queues. No middleware. No infrastructure to maintain. Just a Python script, two APIs, and a Notion database doing the heavy lifting.
How It Works — Step by Step
Step 1: Candidate Entry
A recruiter (or the included sample_candidates.py script) adds a new row to the Notion database with the candidate's name, skills, years of experience, and target role. Status is set to Pending.
Step 2: Agent Polls
The agent queries the Notion API every 60 seconds, filtering for all rows where Status = Pending. If none are found, it sleeps and checks again.
Step 3: LLM Analysis
Each pending candidate's profile is packaged into a structured prompt and sent to Groq's API running LLaMA 3.3 70B. The model is instructed to return strict JSON with a score, reasoning, five interview questions, and a hire/reject recommendation.
Step 4: Results Written Back
The agent parses the LLM response and writes the score, interview questions, and recommendation directly into the candidate's Notion row via the Notion API.
Step 5: Status Update
The candidate's status is flipped from Pending to Reviewed. The agent moves on to the next candidate. The recruiter sees results the next time they glance at the table.
Tech Stack
| Technology | Role |
|---|---|
| Python 3.12 | Core agent runtime |
| Notion API | Database operations — read candidates, write evaluations |
| Groq API | LLM inference (LLaMA 3.3 70B Versatile) |
| python-dotenv | Secure environment variable management |
| requests | HTTP client for Notion API communication |
Key Features
- Autonomous polling — runs 24/7, picks up new candidates automatically
- Structured AI evaluation — score, reasoning, interview questions, and recommendation in strict JSON
- Direct Notion integration — no external dashboards, no context switching
- Transparent scoring — every decision includes written justification
- Role-aware analysis — the LLM evaluates candidates relative to the specific role they applied for
- Batch processing — handles multiple pending candidates per cycle
- Graceful error handling — API failures don't crash the agent; it logs and retries
-
Sample data included —
sample_candidates.pyseeds 5 realistic test profiles
GitHub Repository
The full source code is open and ready to run:
GitHub: muhammadtahirhasni/ai-hiring-agent-notion
Clone it, add your API keys, and you'll have a working AI recruiter in under 5 minutes.
What's Next
This is a v1, and I'm already mapping the roadmap:
- Slack/Discord notifications — alert hiring managers the moment a high-scoring candidate is evaluated
- Resume parsing — accept PDF uploads, extract structured data automatically, and feed it into the pipeline
- Multi-model evaluation — run candidates through multiple LLMs and aggregate scores for higher confidence
- Interview scheduling — auto-send calendar invites to candidates who score above a threshold
- Notion kanban workflow — move candidates through stages (Screened → Interview → Offer → Hired) with AI assistance at each step
- Custom scoring rubrics — let teams define role-specific evaluation criteria that the LLM uses as grading guidelines
The future of hiring isn't about replacing recruiters. It's about giving them superpowers. Notion becomes the cockpit. AI becomes the co-pilot. Every candidate gets a fair, thorough, instant evaluation.
That's what I built. That's what Notion MCP makes possible.
Built by Muhammad Tahir Hasni — Agentic AI Developer & Founder of HireAI
Top comments (1)
Nice bro, good luck too