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

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

Job Hunter

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.

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 repo 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.

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.

Google Sheet to keep track of the job applications

This creates a loop:

1. Collect jobs.
2. Review only the best candidates.
3. Mark Interested or Skip.
4. Generate truthful documents.
5. Inspect the application page.
6. Stop at sensitive gates.
7. Track status.
8. Watch for replies.
9. 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.

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

If you have any questions like how to setup LinkedIn on the Raspberry Pi for automatically applying for jobs or adding a secondary profile, feel free to reply to this post. I will do my best to assist you.