How AI Eases the Tedious Part of My Job Search

Checking LinkedIn, Naukri and a list of company career sites by hand, every day, ate hours. Now AI eases that tedious work for me. On a scheduled daily 07:00 run, the specialist agents in my AI job search pipeline fetch, rank and track, and what reaches me is a short list to review.

Here's what each agent takes on for me, the four lessons that shaped the team, and the one job they leave to me: applying.

The tedious part: hours of checking job boards by hand

The three sources aren't the same kind of work. LinkedIn and Naukri are job boards you search, while company career sites are a list you visit one by one, and that list keeps needing new companies added. Doing all of it by hand, every day, took hours.

I wanted the grind gone, not my judgement. So I treated the search like a data pipeline (a scheduled run, metrics, a cost log and audits) and handed the repetitive part to AI agents. I also keep a separate page on my job-search assistant project.

Meet the six agents behind my AI job search

I call the system job-scout. One coordinating skill, a set of instructions for the AI, starts six agents, each helping with one chore:

• scout-lead fetches every source for me: career sites, LinkedIn and Naukri.
• scout-discovery keeps my list of companies growing.
• scout-ranker scores the jobs and fills the day's short list.
• scout-status reads replies in my inbox and updates each application.
• scout-tailor drafts a resume and cover letter for a job I pick, on demand.
• scout-audit checks my resume against rejected, ghosted and target jobs, on demand.

Splitting the work this way was my first lesson: each agent takes one chore off my hands. Each gets its own instructions and only the tools it needs, which limits what it can touch. Agents can't start other agents, so the skill starts every one, and each reports back when it's done.

Each morning the hand-offs go like this. A setup check stops everything if something is wrong, then the skill sends scout-lead out first.

When scout-lead hands back, discovery, ranking and status start together, because none of them depends on the others. Then costs are finalized and the run is closed as ok, partial or failed. If one agent fails, the rest carry on and the run is marked partial.

flowchart TB
A(["07:00 scheduled run"])
B{"Setup check passes?"}
C["Stop the run"]
D["scout-lead fetches"]
E["Discovery, ranker, status together"]
F["Costs finalized"]
G{"Every agent succeeded?"}
H["Run closed ok"]
I["Run marked partial"]
A e1@--> B
B e2@-->|"yes"| D
B -->|"no"| C
D e3@-->|"lead returns"| E
E e4@--> F
F e5@--> G
G e6@-->|"yes"| H
G -->|"no"| I
e1@{ animate: true }
e2@{ animate: true }
e3@{ animate: true }
e4@{ animate: true }
e5@{ animate: true }
e6@{ animate: true }
%% walkthrough "A normal morning": A > B > D > E > F > G > H
%% walkthrough "One agent fails, the rest carry on": A > B > D > E > F > G > I
%% walkthrough "Setup finds a problem": A > B > C

scout-lead fetches career sites, LinkedIn and Naukri at the same time, checks which came back, and re-runs a missing or failed one once. It won't retry when an access token is missing or the paid Apify credit it fetches with has run out, because those need me.

The results land on an owner-only dashboard on my portfolio, where I read them. The tailored resumes and working files stay on my PC.

One rule follows from that: no dashboard, no run, so the skill never spends Apify money with nowhere to store the results.

Up to 20 jobs a day, split across four tracks

The second lesson was the quota, and scout-ranker holds it for me. It keeps up to 20 new jobs a day, split evenly across four tracks: Full Stack, Frontend, Backend and Software Engineer.

In my judgement, a fixed daily quota split across tracks beat a raw firehose.

scout-ranker scores shortlisted jobs against my profile, and scripts handle duplicates and fill each free slot with the best job. If slots are still empty because candidates were duplicates or scored under the minimum, scout-ranker goes again until no refill is needed.

Keeping up with replies from Gmail

The third lesson came from a chore scout-status takes on for me: keeping up with replies. It reads them and updates each application, which only works if a status can't go backward.

A status script reads my inbox since its last check and keeps only emails that could be about an application: the sender, subject or body names a company I applied to, or the sender is an applicant tracking system. scout-status classifies each one as received, assessment, interview, rejected or offer, and drops anything unrelated. It may never send or reply to email.

Statuses have a rank, from applied up to interview. Rejected and offer are terminal, meaning the application ends there, and the skill never moves a status out of one. Otherwise a status only moves forward, so a late "we received your application" email can't undo an interview invite.

flowchart TB
A(["Email arrives"])
B{"About an application?"}
C["Dropped"]
D["scout-status classifies"]
E{"Current status terminal?"}
F["Keep current status"]
G{"Terminal or higher rank?"}
H["Advance to new status"]
A e1@--> B
B e2@-->|"yes"| D
B -->|"no"| C
D e3@--> E
E e4@-->|"no"| G
E -->|"yes"| F
G e5@-->|"yes"| H
G -->|"no"| F
e1@{ animate: true }
e2@{ animate: true }
e3@{ animate: true }
e4@{ animate: true }
e5@{ animate: true }
%% walkthrough "Interview invite after 'received'": A > B > D > E > G > H
%% walkthrough "Late 'we received your application' after an interview": A > B > D > E > G > F
%% walkthrough "An email about something else": A > B > C

If scout-status ever gets one wrong, I can set the status myself, and later updates advance from there.

Tailoring a resume without inventing facts

The fourth lesson is about tailoring, which scout-tailor drafts for me on demand, under the strictest rule in the project. It may reorder, shorten, rephrase and emphasize, but it may never add an employer, title, date, skill, metric, project or certification, and never change a number.

Anything the job asks for that my resume doesn't show goes into a gaps file instead. Before rendering, the agent checks every claim against my base resume.

The resume must fit one page, so if it runs long, it drops the least relevant bullets and renders once more. The PDFs stay on my PC, and the dashboard stores only where they are.

scout-audit closes the loop for me. It reads my rejected, ghosted and target jobs alongside the resume and cover letter, follows a rubric, and saves a diagnosis: top changes, skill gaps, and notes on each document. It doesn't rewrite anything, and with no rejected, ghosted or target jobs yet, it reports no signal and stops.

A record of what every agent did

Handing chores to agents is easier to trust when every run leaves a record.

Every run logs what each agent did: how long it took, its tool calls and the tokens (units of AI usage) it spent, plus a cost for those tokens, priced at API rates. For each source, it records how many items it fetched, how many were new and any outside cost.

Each entry also keeps the agent's task, errors and final reply, with anything that looks like a key, token or password redacted.

Where the skill stops and I take over

The skill's own rules matter more than any agent:

The skill prepares; Harsh applies.

It never applies, submits forms or sends email. It never reads my .env file; scripts read secrets themselves. It never invents facts about me.

And it reports failures honestly, never calling a partial run complete. I've written separately about why agents need hard limits, and these rules are that idea applied to my own tooling.

I'm not the only one drawing this line. There are good open-source projects in this space: career-ops scores jobs and never submits for you ("You press Submit."), and ai-job-search syncs Gmail with status changes you approve.

From my reading of their main pages, neither describes per-agent cost logging, a fixed daily quota or a daily scheduled run, which is where job-scout differs.

So AI takes on the fetching, ranking, status tracking and drafting. What reaches me each morning is a short list, plus the part that should be mine: reading it, choosing where to apply and pressing submit.

Takeaways

• Treat the job search like a pipeline, and let AI run it. A scheduled daily run, metrics, a cost log and audits turn hours of daily checking into a short list I review.
• Give each agent one job. Six narrow agents, each helping with one chore, all started by one skill. For the bigger picture, see what agentic AI changes about everyday work.
• Cap the output. Up to 20 jobs a day, split evenly across four tracks, instead of a raw firehose.
• Let status only move forward. A late email can't undo progress, and the human can always correct it.
• Never let the model invent facts. The tailor rewords the real resume and writes down the gaps instead of filling them.
• Automate the grind, not the decisions. AI fetches, ranks, tracks and drafts. I choose, and I apply.