AI HR + Recruiting Stack

What's in this pack

This is the stack a recruiter or HR lead would actually wire up to handle a hiring round end-to-end — not a 50-vendor demo day. Every pick here does one job in the funnel a real opening goes through: find the candidates, parse the resumes, screen them against the JD, prep the interview, capture the call, draft the offer, onboard the new hire. And one tool that sits across every step: the bias-audit pass that runs before a human gets a recommendation.

The stack is agent-driven on purpose. The recruiter spends the morning wiring it up; from then on the agents do the grunt work — boolean searches, resume reformatting, screening summaries, transcript notes — and the recruiter only steps in where judgment is required (the call itself, the negotiation, the close). Critically: no auto-reject. Every screening step produces a ranked list with reasons, never a hidden filter that drops a candidate before a human sees them.

Install in this order

1. Tavily Search — the search engine your sourcing agent calls. Pull "senior React engineers who blogged about Server Components in 2026," "compensation benchmarks for staff PM in Berlin," or "why Acme just laid off their growth team." Free tier covers 1,000 queries/month — enough for a small team.
2. Apify MCP Server — 8,000+ pre-built scrapers (LinkedIn-style profiles, job boards, GitHub, Stack Overflow Careers) exposed as MCP tools. Use this once Tavily's text snippets aren't enough and you need structured candidate rows you can dedupe and rank.
3. Jina Reader — https://r.jina.ai/<url> returns clean markdown of any page. The unglamorous workhorse: paste a candidate's personal site, a competitor's careers page, or a 40-page benefits PDF, get back text the LLM can actually reason over.
4. Reactive Resume — open-source resume builder that doubles as a parser. Candidates submit raw resumes; you export them through Reactive into a consistent JSON Resume schema before any LLM screen. Same fields every time = comparable screening signals.
5. Docling — IBM-grade document parser for PDFs, DOCX, scanned resumes. Handles the messy real-world cases Reactive can't (1990s scanned CVs, two-column EU formats, image-only PDFs). Output is structured markdown your screening agent can chew on.
6. Phoenix Evals — LLM-as-judge library with built-in templates. This is where the actual screening happens: define your scorecard (years of relevant experience, domain match, communication clarity), Phoenix runs the same prompt against every candidate, returns numeric rubric scores with rationale. Auditable, reproducible.
7. Anarlog — open-source local AI meeting notes. Records and transcribes screening calls on the recruiter's machine — candidate audio never leaves the laptop. Output is a summary + action items you can drop into the ATS without uploading to a third-party SaaS.
8. Faster Whisper — 4x faster than OpenAI Whisper, runs locally. The transcription engine Anarlog and your batch interview pipeline use under the hood. Switch to this when you have 20 phone screens a week and need turnaround in minutes, not hours.
9. Prompt Perfect — system prompt engineering templates. Use it to keep your offer-letter prompt, your rejection prompt, your reference-check prompt under version control. "Generic friendly tone, no comp numbers, mention next step" should produce the same letter on Monday as on Friday.
10. Claude Code Agent: AI Ethics Advisor — the gate. Before any shortlist goes to a hiring manager, the Ethics Advisor reviews the screening rubric and the resulting ranking for protected-class proxies (zip code, school name, graduation year, photo). Flags get sent back to the recruiter, never auto-applied. This is the only step that's allowed to block a downstream action.

How they fit together

            ┌─ Tavily ─── Apify MCP ───┐
            │ (search)   (scrape)       │   SOURCE
            └─────────┬─────────────────┘
                      ▼
              Jina Reader (URL → text)
                      │
                      ▼
         Reactive Resume ── Docling           SCREEN
         (JSON schema)    (messy PDFs)
                      │
                      ▼
              Phoenix Evals
           (LLM rubric, scored)
                      │
                      ▼ ────────────────────────┐
              AI Ethics Advisor                 │
             (bias audit, gate)                 │
                      │                         │
                      ▼                         │
         Anarlog + Faster Whisper       INTERVIEW
        (record + transcribe call)              │
                      │                         │
                      ▼                         │
              Prompt Perfect                OFFER
         (offer letter, rejection,        + ONBOARD
          reference check templates)

The non-obvious join is Phoenix Evals → Ethics Advisor: Phoenix gives you a defensible, repeatable scorecard; the Ethics Advisor inspects that scorecard for proxy variables before the ranking is shown to anyone. Without the gate, an LLM-as-judge pipeline can silently re-encode every bias in the training data. With it, you have a paper trail.

Tradeoffs you'll hit

• Reactive Resume vs Docling — Reactive is opt-in (candidate uses the builder); Docling is mandatory (you parse whatever comes in). Run both: Reactive for clean schema when the candidate cooperates, Docling for the 40% of inbound that arrives as a scanned PDF from 2014.
• Anarlog (local) vs cloud meeting bots — Anarlog keeps the audio on the recruiter's laptop. Cloud bots (Fireflies, Otter) are faster to set up but log candidate audio in a US-based vendor that may or may not be GDPR-cleared for your region. For EU candidates specifically, default to local.
• Phoenix Evals vs hand-graded screens — Phoenix is reproducible and fast; a recruiter reading every resume is irreplaceable for the top-of-funnel signal a rubric can't capture. The right mix is Phoenix for the first pass (cut 200 → 30), human for the second (30 → 8).
• Auto-applying Ethics Advisor flags — don't. The Ethics Advisor is a reviewer, not an enforcer. Auto-rejecting candidates because the model flagged a proxy is exactly the failure mode you're trying to avoid. Flags go to the recruiter; the recruiter decides.

Common pitfalls

• Letting the screening rubric live in someone's head — Phoenix wants a written rubric. If you can't articulate "3 points for direct domain experience, 2 for adjacent, 1 for transferable, 0 for unrelated," the screen isn't reproducible and the bias audit can't catch anything. Write the rubric before you wire up the agent.
• Sending candidate PII through a third-party LLM — the SaaS Claude/OpenAI endpoints log prompts. For resume content that includes name, email, address, school, default to a local model (Ollama + a 12B Llama variant) for the screening step, and only send the rubric score upstream. Reserve cloud calls for the offer letter, not the screen.
• ATS "AI integration" claims — most ATS vendors are reselling GPT calls with a UI. The point of this pack is that you own the prompt, the rubric, and the audit trail — not that you outsource them to a vendor's locked surface. Use the ATS's MCP / webhook layer; skip the bundled "AI screening."
• No human-in-the-loop on rejections — even with a perfect rubric, automate-then-send rejection emails is the single fastest way to a discrimination complaint. Every rejection touches a human reviewer before it leaves the building.
• Forgetting to delete candidate data on schedule — most jurisdictions cap how long you can hold an applicant's data. Wire a cron into your pipeline that purges resumes + transcripts at the retention cliff. Don't rely on "we'll do it manually."