I Open-Sourced JobHunter: An AI Agent for Job Applications With Human Approval Built In

Ala BEN KHALIFA — Sat, 11 Jul 2026 19:08:00 +0000

GitHub: https://github.com/alabenkhlifa/JobHunter

I started building JobHunter because I had a simple problem.

Searching for jobs is repetitive, noisy, and easy to turn into a bad automation project.

Most job automation ideas quickly become some version of this:

“Scrape jobs, generate resumes, apply everywhere.”

At first, that sounds useful. But when I looked closer, it felt wrong.

A job application is not just a form submission. It includes private data, legal answers, salary expectations, visa status, truthful career history, recruiter conversations, and sometimes terms or privacy notices.

If an agent guesses any of that, the automation is not helping anymore. It is creating risk.

So I built JobHunter with a different rule:

The agent can prepare the work, but it must stop at trust boundaries.

JobHunter is an open-source, approval-gated job-search assistant for Python.

It collects jobs
Scores them
Sends Telegram review cards
Learns from Interested/Skip feedback
Prepares truthful application packages
Inspects application pages through Chromium CDP
Tracks application state in SQLite and Google Sheets
Watches a dedicated Gmail inbox for recruiter or ATS replies

But the important part is what it refuses to do.

It does not blindly mass-apply.
It does not invent resume facts.
It does not answer salary, visa, legal, or work-authorization questions without confirmation.
It does not bypass CAPTCHA or anti-bot checks.
It does not click final submit unless the user explicitly approves.

That constraint changed the architecture.

The scraper is not the product. The safety model is the product.

JobHunter currently focuses on roles like (it is configurable, so you can choose your focus area):

Software Architect
Cloud Architect
Tech Lead
Senior Backend Engineer
Platform Architect
Solutions Architect

It collects opportunities from supported sources (right now LinkedIn and FoundIt), stores them locally in SQLite, deduplicates them, filters noisy results, and scores jobs based on stack, seniority, location, and description signals.

Then it sends a small number of Telegram cards instead of flooding the user.

Example of a Telegram job offer message.

Each card has clear actions: Interested, Skip, Details, and skip reasons like wrong stack, too junior, too senior, or low quality.

That feedback is stored as traceable data and reused to adjust future ranking.

This is intentionally simple. I did not want a black-box recommender that says “trust me bro.” I wanted a system where the user’s decisions leave a trail.

If I keep skipping frontend-heavy roles, the future ranking should demote similar jobs.

If I keep selecting backend architecture roles, the system should boost similar ones.

The useful part is not “AI decides my career.”

The useful part is “my repeated decisions make the assistant less noisy.”

The resume generation flow follows the same idea.

JobHunter uses a local data/master-profile.json file as the source of truth. That file is ignored by Git. The open-source repository only includes an example schema.

When generating a tailored resume or cover letter, the agent can reorder skills, emphasize relevant experience, and rewrite the summary.

But it cannot invent companies, titles, dates, education, certifications, or skills.

This matters because resume tailoring is a dangerous area for AI agents. It is very easy for a model to make a profile sound stronger by adding small false details.

One invented certification or one fake responsibility can create a real problem.

So the project treats the profile like a factual database.

Tailoring means emphasis, not fabrication.

The browser application flow is also approval-gated.

JobHunter can connect to Chromium through CDP and inspect the current LinkedIn or ATS page.

It extracts visible inputs, buttons, links, required fields, and page text.

It detects blockers like CAPTCHA, phone verification, identity verification, privacy notices, salary questions, visa sponsorship, work authorization, background checks, and final certification text.

If it sees a sensitive question, it records the blocker and stops.

If a file upload is requested, it requires an explicit approval flag.

If final submit is requested, it requires an explicit approval flag.

This is not just a UX preference. It is an engineering boundary.

The agent can help with mechanical work, but the human stays responsible for legal consent, personal declarations, and final submission.

I also added a tracker flow because job search automation is useless if you lose the state.

JobHunter records application stages locally, then can sync a human-readable tracker to Google Sheets.

The tracker can include status, company, title, application URL, resume link, cover letter link, evidence screenshot link, notes, and next action.

Google Sheet to keep track of the job applications

There is also a Gmail watcher for a dedicated jobs mailbox.

It checks recruiter and ATS replies, filters noise like newsletters and Google Sheet share emails, marks inspected messages as read, and reports relevant replies.

This creates a loop:

Collect jobs.
Review only the best candidates.
Mark Interested or Skip.
Generate truthful documents.
Inspect the application page.
Stop at sensitive gates.
Track status.
Watch for replies.
Improve future recommendations from feedback.

That loop is the real project.

What I learned while building this is that “agentic automation” needs more stopping rules than action rules.

Most demos focus on what the agent can do.

I think production-useful agents also need clear answers to:

Where should the agent stop?
Which facts are allowed to be reused?
Which answers must be confirmed again?
Which files must never be committed?
Which actions require approval?
Which states should be recorded for audit?

Without those boundaries, the assistant becomes fast but unsafe.

With those boundaries, it becomes slower in the right places.

That is the tradeoff I wanted.

JobHunter is not trying to replace the person applying.

It is trying to remove the repeated work around the person: scraping, deduplication, ranking, packaging, tracking, and reply monitoring.

The human still owns the truth.

The human still approves the submission.

The human still decides whether the job is worth it.

I open-sourced it because I think this pattern is useful beyond job search.

Many agent workflows have the same shape:

Do the boring work automatically.
Record state.
Reuse confirmed facts.
Stop at sensitive decisions.
Ask for approval before irreversible actions.

That is a better agent pattern than “just automate everything.”

Also one important thing to know, this project should be setup with Hermes Agent, for best results use Raspberry Pi to host it and a decent LLM.

Personally I use

Raspberry Pi 5 with 8 Gb of RAM
Hermes with GPT-5.5 as LLM brain

The project also supports multiple profiles if you want to bless your friend that is looking for a new job with you, you can setup their profile and add a Hermes Gateway so they can receive job offers and apply automatically.
Another alternative would be to setup 2 NTFY channels, one for receiving the offers and the other for replying with the offer ID so Hermes can generate the resume, cover letter and apply for them.
Please Star this repo if you like the article, it took me huge effort to implement it and refine, it is still being refined everyday with every job offer I receive.

Please Star this repo if you like the article, it took me huge effort to implement it and refine, it is still being refined everyday with every job offer I receive.