I Built a 9-Agent AI Pipeline That Optimizes Resumes in 60 Seconds

Six months ago, I was helping a friend fix her resume. She'd applied to 47 positions — zero callbacks. Her resume was good: clean layout, strong experience, quantified achievements. So what was going wrong?

The answer was brutal: her resume never reached a human. An Applicant Tracking System (ATS) was scoring it below the threshold and tossing it into a digital void. I rewrote it with ATS optimization in mind, and within two weeks she had three interviews.

That experience sent me down a rabbit hole. I started studying how ATS parsers work, how recruiters filter candidates, and how Natural Language Processing could bridge the gap. The result is SIRA — a pipeline of 9 specialized AI agents that analyzes, scores, and optimizes a resume in about 60 seconds.

Here's the technical breakdown of how it works.

The Problem: ATS Is a Black Box

Most job seekers don't realize that ~75% of resumes are rejected before a human ever reads them. ATS platforms like Workday, Greenhouse, and Lever use keyword matching, section detection, and scoring algorithms to rank applicants.

The rules aren't published. Every ATS behaves differently. And the feedback loop is non-existent — you just never hear back.

As developers, we can do better.

Architecture Overview: Why 9 Agents?

I considered building a monolithic prompt — dump the resume and job description into GPT and ask for improvements. But monolithic prompts produce generic output. They hallucinate metrics, they miss structural issues, and they can't reason about multiple optimization dimensions simultaneously.

Instead, SIRA uses a multi-agent pipeline where each agent has a single, well-defined responsibility. Think of it like microservices, but for reasoning.

Here's the agent lineup:

Agent 1: Document Parser

Extracts raw text and structural metadata from PDF/DOCX uploads. Handles multi-column layouts, tables, headers, and edge cases like image-based PDFs (via OCR fallback). Outputs a normalized JSON representation of the resume.

Agent 2: Section Classifier

Identifies and labels resume sections: Contact Info, Summary, Experience, Education, Skills, Projects, Certifications, etc. This is trickier than it sounds — people use wildly inconsistent headers ("What I've Done" instead of "Experience").

Uses a fine-tuned classifier trained on ~10K resume section samples.

Agent 3: ATS Compatibility Analyzer

This is the core engine. It simulates how major ATS platforms parse the resume:

• Keyword extraction from the job description (TF-IDF + semantic embeddings)
• Keyword matching against resume content (exact match, synonym match, semantic similarity)
• Format compatibility scoring (does the layout break ATS parsers?)
• Section completeness check (missing required sections?)

Outputs a compatibility score from 0–100 and a detailed breakdown.

Agent 4: Keyword Gap Analyzer

Compares the job description's required/preferred qualifications against what's in the resume. Produces a gap report:

{
  "missing_hard_skills": ["Kubernetes", "Terraform"],
  "missing_soft_skills": ["cross-functional collaboration"],
  "weak_matches": ["Python (mentioned but not emphasized)"],
  "strong_matches": ["React", "TypeScript", "AWS"]
}

Agent 5: Impact Quantifier

Scans bullet points and flags vague language. "Improved system performance" becomes "Improved system response time by 40% by implementing Redis caching, reducing average API latency from 850ms to 510ms."

This agent uses few-shot prompting with industry-specific examples. It won't fabricate numbers — it suggests where metrics should go and provides templates.

Agent 6: Language & Tone Optimizer

Ensures consistent tense, active voice, professional tone, and eliminates filler words. Also handles localization — if you're applying in Germany, it adjusts for conventions there (photo, date format, personal details).

Agent 7: Structure Advisor

Recommends section reordering based on the target role. A senior engineer should lead with Experience; a fresh graduate should lead with Education or Projects. Also flags formatting issues that break ATS parsing (tables, columns, headers in text boxes, etc.).

Agent 8: Competitive Benchmarker

Compares the resume against aggregated patterns from successful resumes in the same role/industry. This isn't about copying — it's about understanding what hiring managers in your specific field expect to see.

Agent 9: Final Synthesizer

Takes all outputs from agents 3–8, resolves conflicts (e.g., Agent 5 wants to add bullet points, but Agent 7 says the resume is already too long), and produces:

1. An optimized resume (markdown + formatted PDF)
2. A detailed score report
3. A prioritized action list

The Orchestration Layer

The agents don't run sequentially in a waterfall. SIRA uses a directed acyclic graph (DAG) for orchestration:

Parser → Classifier → [ATS Analyzer, Keyword Gap, Impact Quantifier] → [Language Optimizer, Structure Advisor] → Benchmarker → Synthesizer

Agents 3, 4, and 5 run in parallel (they're independent given the parsed + classified input). Agents 6 and 7 also parallelize. This brings total processing time down to ~60 seconds instead of the 3–4 minutes a sequential pipeline would take.

Each agent communicates via structured JSON schemas. I use validation at every handoff point — if an agent produces malformed output, it gets one retry with the error message injected, then fails gracefully with partial results.

NLP Techniques Under the Hood

A few interesting technical details:

Semantic keyword matching: Exact keyword matching misses too much. "Machine Learning" and "ML" are the same thing. "Led a team of 5" and "people management" are conceptually related. I use sentence-transformers (all-MiniLM-L6-v2) to compute embeddings and cosine similarity, with a threshold tuned per-category.

Job description parsing: JDs are messy. Required vs. preferred qualifications aren't always clearly separated. I built a custom NER model to extract structured requirements from free-text job postings.

Resume scoring calibration: The 0–100 ATS score is calibrated against real-world data. I collected anonymized before/after data from beta users — resumes that got callbacks vs. those that didn't — and used it to weight the scoring components.

What I Learned

1. Multi-agent beats monolithic prompts for complex analytical tasks. Each agent can be independently tested, tuned, and improved.

2. ATS systems are surprisingly dumb. Most of them choke on two-column layouts, tables, and creative formatting. A clean single-column resume in a standard font outperforms a gorgeous designed one.

3. The keyword game is real, but nuance matters. Keyword stuffing gets caught by modern ATS. Contextual usage of keywords — mentioning them in achievement-oriented bullet points — is what actually scores well.

4. Feedback loops are everything. The biggest improvement to SIRA's quality came from collecting user feedback on whether optimized resumes actually led to more callbacks.

Try It

SIRA is live and free to use. You can:

• Try the web app: sira-resume.surge.sh — upload your resume, paste a job description, get your optimization report
• Use the Telegram bot: @sira_cv_bot — send your resume directly in chat for quick analysis

I built this because the job market is broken in ways that hurt qualified people. If you're a developer who's been ghosted after dozens of applications, the problem might not be your skills — it might be how your resume talks to machines.

What's Next

I'm working on:

• Batch optimization: Optimize one resume for multiple job descriptions at once
• Interview prep agent: Using the job description + your optimized resume to generate likely interview questions
• Chrome extension: One-click optimization from any job posting page

If you found this interesting, I'd love to hear your thoughts. Have you dealt with ATS hell? What's worked (or hasn't) for you?

If you want to geek out about multi-agent architectures or NLP for HR tech, find me in the comments or drop a message on the SIRA Telegram.