JobHunter: Why Human Approval Beats Blind Automation

JobHunter stops automation at trust boundaries by requiring explicit human approval before any application submission. This open-source job bot proves that ethical job search workflow tools must prioritize safety models over blind mass-application scripts. The following sections detail how approval-gated agents prevent legal risks, the specific data flow architecture using Chromium CDP, and methods for continuous operation on hardware like the Raspberry Pi.

The core philosophy, published on the DEV Community, rejects the industry standard to "scrape jobs, generate resumes, apply everywhere" because applications contain sensitive private data and legal answers. Instead of guessing visa status or salary expectations, the system collects job listing entries from sources like LinkedIn and FoundIt to score them locally. It then pushes review cards to Telegram, allowing users to mark items as Interested or Skip without the bot ever bypassing CAPTCHA checks or clicking final submit buttons alone.

Readers will learn how the system tracks state in SQLite and Google Sheets while monitoring a dedicated Gmail inbox for ATS replies. We examine the Python based logic that inspects application pages and ensures the agent never invents resume facts. This approach transforms the job search workflow from a risky autonomous process into a supervised, traceable operation where the user retains full control over their career history and personal information.

The Role of Approval-Gated Agents in Ethical Job Search

JobHunter as an Approval-Gated Python Assistant

JobHunter operates as an open-source assistant that drafts application materials then pauses at specific trust boundaries. This design separates the tool from blind scrapers by demanding human validation before any final submission. The system gathers opportunities, scores them against user preferences, and delivers review cards via Telegram for explicit Interested or Skip feedback.

Defining a trust boundary stops the agent from fabricating resume details or answering legal questions regarding visa status and salary expectations without confirmation. Refusing to bypass CAPTCHA checks or click final submit buttons keeps all legal declarations and personal attestations under direct human control. Such constraints create a necessary friction point where the user validates truthfulness before the system proceeds. Speed often tempts builders to remove these gates, yet doing so introduces significant liability regarding data accuracy. The safety model becomes the primary product feature rather than the scraping mechanism itself. An agent allowed to invent career history or bypass verification steps transforms from an assistant into a liability generator. Resulting workflows prioritize auditable, truthful applications over high-volume, low-fidelity mass submissions.

Operational Workflow: From Telegram Cards to SQLite Tracking

Preventing resume fabrication requires halting automation at trust boundaries until explicit human approval arrives. The system functions as an approval-gated loop where the agent prepares materials but never executes final submissions autonomously. Users receive structured Telegram cards containing job summaries and must select Interested or Skip to proceed. This feedback mechanism trains the scoring algorithm while ensuring no application advances without direct authorization.

State management relies on SQLite for local deduplication and tracking, creating a persistent record of every interaction. The workflow avoids inventing career facts by restricting the agent to reordering verified data from a local master profile. If the browser automation detects sensitive fields like visa status or salary expectations, the process pauses for manual input.

Slower application velocity compared to mass-apply scripts represents the operational cost of this safety model. However, this constraint eliminates the risk of legal liability associated with AI-hallucinated credentials. The agent's value proposition shifts from speed to auditability, as every state change is recorded in the local database. Such an approach keeps trust boundaries intact while still using automation for repetitive data entry tasks. The system effectively separates mechanical labor from legal consent, requiring users to validate only the critical decision points.

Preventing AI Hallucination in Sensitive Legal and Visa Data

JobHunter prevents resume fabrication by refusing to invent facts for visa status or salary expectations without confirmation. Most automation projects incorrectly attempt to scrape jobs and apply everywhere, a method that risks generating false legal answers or distorting truthful career history. The system mitigates this by treating the user's profile as a factual database rather than a creative writing prompt. When the agent encounters sensitive fields regarding work authorization or private data, it halts execution rather than guessing. This approach ensures that tailored resumes emphasize the experience through reordering, not fabrication of companies or dates.

Necessary friction arises when the open-source assistant prepares the work but stops at trust boundaries. Users receive Telegram review cards and must explicitly mark items as Interested or Skip before any progression occurs. This design choice acknowledges that while AI can simplify mechanical tasks, it cannot assume liability for personal declarations. The consequence is a safer workflow where the human remains responsible for legal consent and final submission. Effective automation requires more stopping rules than action rules to function ethically in production environments.

Inside JobHunter Architecture and Data Flow

Hermes Agent Role in Job Scoring and Deduplication

Raw data ingestion from LinkedIn and FoundIt frequently produces redundant entries for identical openings. The Hermes Agent eliminates these duplicate listings by parsing stack, seniority, and location signals within local SQLite storage. Deduplicating records before presentation prevents notification fatigue. Scoring logic prioritizes specific architectural roles to filter noise, surfacing only high-relevance candidates for human review.

User interaction drives the refinement loop through explicit Telegram actions: Interested, Skip, or Details. Selecting Skip because a role has the "wrong stack" or is "too junior" triggers Hermes to record this traceable feedback. Subsequent scoring models adjust based on these inputs. Frontend-heavy roles get systematically demoted if the user consistently targets backend architecture positions. This open-source job bot architecture keeps the human as the final decision node. Black-box recommenders often fabricate career preferences, whereas this method maintains data integrity while reducing search volume. Manual initial calibration represents the primary constraint; users must provide sufficient Skip data to train the local ranking engine effectively.

Chromium CDP Execution for CAPTCHA and Blocker Detection

Connecting to Chromium via CDP allows the browser agent to inspect page DOM elements for specific blockers like CAPTCHA or visa queries. This execution layer extracts visible inputs, buttons, and required fields from LinkedIn or ATS pages before any interaction occurs. Detection of a sensitive question regarding salary, work authorization, or identity verification causes the system to record the blocker and halt immediately. File uploads and final submissions strictly require an explicit approval flag to proceed. Human responsibility for legal consent remains intact.

Operators fixing CAPTCHA detection issues must recognize that the agent avoids bypassing anti-bot checks by design, preferring to pause for human intervention. This approval-gated workflow prevents the agent from inventing facts or guessing on private data fields. Full automation speed conflicts with the safety of stopping at trust boundaries; JobHunter prioritizes the latter to prevent resume fabrication. The agent prepares mechanical work but refuses to click final submit without direct confirmation. Such a constraint ensures that traceable data remains accurate and legally sound. Evaluators of similar architectures can find further analysis on safe agent deployment patterns on the AI Agents News platform. Application stages get recorded locally, creating an audit trail of every stopped action.

Engineering Boundaries Preventing Resume Fabrication Risks

Resume generation restricts the agent to reordering skills and rewriting summaries without inventing companies, titles, or dates. This engineering boundary enforces a strict separation where tailoring means emphasis, not fabrication. Hallucinating credentials could trigger legal liabilities, so the system prevents such outcomes. Blind automation bots often mass-apply using synthesized data, yet this system treats the local profile as a factual database where the human remains responsible for personal declarations.

AI hallucination creates operational risks extending beyond rejected applications to potential fraud claims if an agent invents a certification or misstates a tenure period. Halting at trust boundaries ensures mechanical assistance never overrides factual accuracy in career history. The resulting design yields a slower but defensible application process where every claim maps to verifiable human experience. Effective orchestration requires limiting function calling to modification of existing fields rather than creation of new entities. This approach mitigates the danger of an agent confidently asserting false skills during the job application automation flow. Truthfulness takes precedence over volume, ensuring generated documents remain legally sound.

Deploying JobHunter on Raspberry Pi for Continuous Operation

Raspberry Pi 5 and Hermes Agent Hardware Requirements

Sustaining persistent browser sessions demands hardware that does not choke under load. The Raspberry Pi 5 acts as the primary compute unit, specifically the variant equipped with 8 Gb of RAM to handle concurrent Chromium CDP processes and local SQLite transactions efficiently. This memory threshold is non-negotiable for stability. The Hermes agent operates atop this infrastructure, using GPT-5.5 as the central logic engine for scoring and document tailoring. Running continuous job application automation on local silicon introduces friction between agent autonomy and resource contention. The 8 Gb limit dictates that local deployments require strict thermal management. Cloud environments avoid egress costs but physical units suffer if CPU temperature spikes. Sustained loads from the ai job assistant degrade performance on passive cooling setups without active monitoring.

Configuring Dual NTFY Channels for Automated Offer Reply

Isolate discovery from execution by establishing two distinct NTFY topics. This separation ensures the Hermes Agent acts only upon explicit, ID-specific triggers rather than raw feed data. The first channel streams scored opportunities from LinkedIn scraping directly to the user for review. Commands flow through the second channel. Such a dual-channel approach supports multiple user profiles, allowing a single Raspberry Pi 5 instance to manage distinct workflows for different users or friends securely. Each profile maps to its own pair of topics, preventing cross-contamination of application states. Network dependency creates a constraint here. If the Hermes host loses connection to the NTFY broker, the handshake between user approval and agent action stops until reconnection occurs. Builders must verify the broker URL is stable and accessible from the edge device to maintain the integrity of the approval loop.

Managing Continuous Refinement in Daily Job Offer Cycles

Operational stability relies on regular profile adjustments because the open-source job bot evolves with every user decision. The system is not static; the author notes the project is "still being refined everyday with every job offer I receive." Operators must monitor the Hermes Gateway for false positives where valid roles were incorrectly scored down. User feedback serves as training data for future ranking accuracy rather than discarded noise. A drawback exists between automation speed and the manual effort required to curate the master-profile.json source of truth. Neglecting review allows noise to accumulate, degrading the signal-to-noise ratio for subsequent searches. Failure to iterate results in an agent that misses emerging market trends. AI Agents News recommends treating the configuration file as a living document rather than a one-time setup script.

Integrating Communication Channels and Tracking Systems

A dedicated mailbox serves as the intake point for recruiter and ATS replies. The Gmail watcher scans this inbox, isolating messages that concern application status from general noise. Personal correspondence stays separate, keeping the job search data stream clean. This segregation prevents unrelated threads from confusing the feedback loop.

Local application states move to a remote Google Sheets tracker during synchronization. Columns track status, company, title, application URL, resume link, cover letter link, evidence screenshot link, notes, and next action. Operators audit progress through this human-readable record instead of querying the local SQLite database directly. Visibility remains intact even if the local deployment instance fails or restarts.

Configuration grants the agent access to a specific Gmail account to enable the watcher. Decisions marked Interested or Skip during the review phase determine which applications enter this tracking pipeline. Every spreadsheet entry corresponds to a human-verified opportunity rather than a scraped hallucination.

Implementing Telegram Alerts and Approval-Gated Tracking

Telegram review cards request human validation before any application proceeds. This mechanism replaces blind mass-application with a targeted feedback loop where the agent presents scored opportunities for explicit Interested or Skip classification. Functional capabilities include generating these review cards and persisting the resulting binary feedback to adjust future job ranking algorithms. Resume tailoring and document generation occur only after a user confirms the role aligns with their career constraints.

Stopping rules enforce limits at trust boundaries rather than attempting to bypass them autonomously. When the agent detects sensitive inputs such as visa status, salary expectations, or legal declarations on an application page, execution halts and waits for authorization. Fabricating resume facts or guessing answers to compliance questions falls outside the system design. The open-source job bot treats the user's profile as a factual database, allowing emphasis on the skills but prohibiting the invention of companies, dates, or certifications.

Clicking final submit buttons requires explicit user approval. Maximizing application volume creates tension with maintaining the integrity of the candidate's professional record. Fabricating a single certification to match a job description creates real problems that outweigh the efficiency gain. Strict configuration of these approval gates ensures the assistant remains a tool for preparation rather than an autonomous actor making legal declarations.

Validation Steps for Noise Filtering and Reply Inspection

Filtering out newsletters and automated Google Sheet share notifications allows the Gmail watcher to isolate recruiter correspondence. This process prevents the feedback loop from processing irrelevant bulk mail while ensuring critical application updates reach the user. Incoming messages get inspected, marked as read, and only the replies get reported to avoid overwhelming the operator.

A dedicated mailbox ensures personal correspondence does not contaminate the job search data stream. Without this segregation, the agent risks misclassifying personal threads as professional opportunities, corrupting the local state tracking. Operators must configure the system to stop at sensitive gates, such as CAPTCHA or identity verification, rather than attempting autonomous bypass. The operational loop collects jobs, reviews candidates, and tracks status, but relies on human input to mark entries as Interested or Skip. This binary feedback adjusts future ranking algorithms, creating a closed loop where the system learns from explicit user decisions. Documentation details how the agent records these stages locally before syncing to Google Sheets. Safety takes priority over speed, ensuring that resume tailoring occurs only after validation. For technical specifics on the underlying crew configurations, developers can reference the sequential process definitions. The agent prepares work but halts at trust boundaries, maintaining data integrity throughout the search.

References

• Devin 🚀 [Cloud] [GitHub] - Fully autonomous AI software
• OpenCode 2026: Setup Guide for the Top Open-Source AI
• SWE-bench Verified tests agents against real GitHub issues, and