How I Built an AI Agent That Runs My Inbox Automatically HireAI ## The Problem I was spending 3+ hours every day just managing emails. Reading. Sorting. Replying. Following up. As a founder building HireAI, I couldn't afford that. So I built an AI age

Muhammad Tahir Hasni — Sun, 29 Mar 2026 11:34:30 +0000

AI Hiring Agent: Using Notion as a Live AI Control Tower

Muhammad Tahir Hasni — Sun, 29 Mar 2026 03:29:38 +0000

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 Pending status 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.py seeds 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

DEV Community: Muhammad Tahir Hasni