Case Study · Agentic AI & Automation

ApplyPilot
Autonomous AI Agent

A six-stage pipeline that discovers roles, scores each one for genuine fit, generates a truthful tailored resume and cover letter, then uses an LLM-driven browser agent to complete real applications — built to answer one question: can an AI agent reliably operate software made for humans?

Python Playwright MCP Claude Code LLM Orchestration Web Scraping

// SIX-STAGE AUTONOMOUS PIPELINE

🔍
Discovery
raw jobs
📄
Enrichment
full JD
⚖️
Scoring
gate
✍️
Tailoring
docs
💬
Cover Letter
submit
🤖
Agent Apply

Role

AI / Automation Engineer

Type

Agentic Pipeline

Built On

ApplyPilot (AGPL-3.0)

Stack

Python · Playwright · MCP · Claude Code

01 — Overview

Why I Built This

I wanted to solve a problem that looked simple and was not: can an AI agent reliably operate software that was built for humans?

Job applications turned out to be an almost perfect test case. The workflow spans everything hard about applied AI — messy web scraping, unstructured text extraction, LLM judgment calls, cost control, safety guardrails, and finally an agent driving a live browser through interfaces it has never seen before. Four ATS vendors — Workday, Greenhouse, Lever, LinkedIn — each with dozens of employer-specific variants and no stable DOM to code against.

If I could make an agent handle that reliably, I would have learned something real about building agentic systems.

I built this on top of Pickle-Pixel/ApplyPilot (AGPL-3.0), an open-source project I used as the orchestration layer. I set it up, debugged it, and extended it — most of my work went into scraping coverage, the extraction cascade, and getting the autonomous apply stage to survive real-world ATS pages.

02 — Architecture

How It Works

Six stages, each feeding the next.

1Discovery — find everything

Aggregates roles from LinkedIn, Indeed, Glassdoor, ZipRecruiter and Google Jobs via python-jobspy, extended with custom scrapers for 48 Workday employer portals and 30+ direct company career sites.

Why the direct portals matter: aggregators miss roles or list them late. Going to the source widened coverage significantly — and it is the part that required real scraper engineering rather than an API call.

2Enrichment — three-tier cascade

Listings are truncated, so every full description is pulled through a deliberately tiered strategy:

Tier 1
Free
JSON-LD — schema.org structured data — clean and free
Tier 2
Free
CSS Selectors — hand-written patterns for known layouts
Tier 3
Paid
LLM Extraction — fallback for anything unrecognized

This is the design decision I am most pleased with. Routing every page through an LLM works perfectly and costs a fortune. Deterministic parsing is free but brittle. The cascade means the expensive, flexible path only runs on genuinely unrecognized pages — most resolve free at tier 1 or 2. Same result, a fraction of the cost.

3Scoring — the selectivity gate

An LLM rates every discovered role 1–10 against my actual experience and preferences. Only strong matches continue. Everything else is discarded.

This gate is the most important component in the system, and it is a deliberate constraint rather than a limitation. An automation pipeline without it is a spam cannon — useless to the employer and useless to me, since a bad-fit application wastes everyone’s time and gets filtered anyway. The system is built to apply to fewer jobs, more carefully. Quality is enforced architecturally, not by good intentions.

4Tailoring — anti-hallucination guarantee

For each role that clears the gate, the LLM rewrites my resume — reordering experience so relevant work leads, and aligning vocabulary with the posting.

The hard constraint: it cannot invent anything. Companies, dates, metrics and education are treated as immutable verified facts and pass through untouched. The model’s write access is limited to emphasis, ordering, and phrasing of things that are already true.

This was not a nice-to-have — it is the whole ballgame. A resume generator that hallucinates a skill does not just produce a bad document; it produces a document that fails a human being in an interview room and burns their credibility. Constraining the model’s authority to the subset of the problem where it cannot cause harm is, to me, the central discipline of building with LLMs.

5Cover Letter — grounded, not templated

A genuine letter per role, grounded in the specific job and company — not a template with the company name substituted in.

6Autonomous Execution — the agent

The part I learned the most from. Claude Code is connected to a Playwright browser-automation server over the Model Context Protocol (MCP). MCP is what turns a language model into an actor: it gives the model a structured interface to perceive the live page and take real actions on it.

For each application the agent opens the page, identifies which ATS it is dealing with, then completes personal details and work history, uploads the tailored resume and cover letter, and answers screening questions — across Workday, Greenhouse, Lever, and the LinkedIn/Indeed native flows.

Why an agent instead of a script: you cannot hard-code selectors for a long tail of forms you have never seen. Scripted automation breaks the moment an employer customizes their Workday tenant. A model that reads the page and reasons about it is the only approach that generalizes to the unknown — and getting that to work reliably against real, inconsistent DOMs was the core engineering challenge of the project.

03 — Engineering

Decisions Worth Defending

Cost as an architectural concern. The extraction cascade exists because “just use the LLM” is a design smell. Knowing when not to call the model is as important as the prompt.
Guardrails over capability. The tailoring stage is deliberately less powerful than it could be. Restricting what the model may touch is what makes its output trustworthy.
Selectivity over throughput. The scoring gate throws most of the pipeline’s own work away on purpose. A system that could apply to everything and chooses not to is the better system.
Standing on open source, honestly. The orchestration layer is ApplyPilot (AGPL-3.0). Knowing what to build versus what to adopt and extend is an engineering decision in itself.

04 — Reflection

What I’d Improve Next

Expand evaluation — measure submission success rate per ATS and catch silent failures automatically
Add a human review checkpoint before submission for high-priority roles
Cache and reuse extraction patterns the LLM discovers, so tier 3 promotes itself to tier 2 over time
Structured observability across the pipeline — per-stage cost, latency and drop-off tracing

Get in touch

Vinay-Kumar-Resume.pdf