Genuire: A Trust Engine for Detecting Fake Job Listings Using Open-Source AI Models

In an era where job scams are growing increasingly sophisticated, one developer built an open-source tool for a friend who fell victim to a recruitment trap. Genuire is a real-time AI/ML platform designed to identify fraudulent job listings and protect job seekers from phishing and identity theft. Before users submit any sensitive information, Genuire calculates a Trust Score from 0–100% using a "5-Pillar Trust Engine," helping applicants determine whether a job posting can be trusted.

Why We Need a "Recruitment Trust Engine"

Job scams have become increasingly difficult to detect. Fraudsters don't just fabricate company information — they build fake recruitment pages and use unofficial contact channels to lure applicants into submitting sensitive data like ID documents and bank details. The developer behind Genuire was motivated by a friend who fell victim to a highly sophisticated recruitment scam.

Unlike passive "report after the fact" approaches, Genuire's core philosophy is proactive interception: auditing job descriptions, URLs, company registration information, and recruiter contact channels before the applicant clicks apply or fills out a profile. This front-loaded screening moves the line of defense to the moment when users are most susceptible to manipulation.

Hybrid AI Architecture: Gemma Vision Model + scikit-learn Pipeline

Genuire's technical design is a classic hybrid AI architecture — not a system that relies solely on a large language model. It consists of two analysis pipelines.

Multimodal Visual Analysis

The platform integrates Google's open-weight vision model gemma-4-31b-it. When a user uploads a screenshot of a suspicious job posting, Gemma scans the image for visual and textual fraud signals — such as layout irregularities, counterfeit logos, and suspicious contact information. This multimodal capability means the tool isn't limited to processing plain text; it can handle the many real-world job postings that circulate as screenshots.

gemma-4-31b-it is an instruction-tuned (-it) multimodal variant from Google's Gemma family, with approximately 31 billion parameters. Unlike the closed-source Gemini API, the Gemma series is released as "open weights," allowing developers to download the model weights and run them locally or on private servers. This gives developers full control over data flow without sending user-uploaded screenshots to third-party cloud services — a critical feature for security tools. Job seekers' screenshots may contain private information like names and contact details, and open-weight models let developers self-host inference within compliant frameworks, minimizing data exposure risk.

Machine Learning Risk Assessment

Beyond multimodal analysis, Genuire also uses a high-performance scikit-learn machine learning pipeline: SGDClassifier for NLP text analysis, and RandomForestClassifier for processing tabular risk data (such as geographic threat ratios and character length features). These two model types complement each other, assessing job authenticity from both semantic and structured feature dimensions.

The entire application is tied together with a Flask backend, while the frontend is built with vanilla JavaScript and CSS. The core interaction is a dynamic 7-stage verification pipeline tracker that lets users visually follow the audit's progress.

SGDClassifier (Stochastic Gradient Descent Classifier) is an online learning algorithm in scikit-learn that updates weights sample by sample to handle large-scale text data. Combined with vectorization methods like TF-IDF, it can rapidly classify semantic patterns in job descriptions — for example, identifying typical fraud language like "no experience needed, high take-home pay" or "remote part-time, daily commission." RandomForestClassifier is an ensemble learning method that builds multiple decision trees and takes a majority vote to improve robustness, making it particularly well-suited for handling heterogeneous structured features — such as URL domain registration age, whether the recruiter's email domain matches the company website, or whether the salary range deviates from industry norms. In Genuire, the two models have distinct roles: SGDClassifier "reads" the language, while RandomForestClassifier "audits" the quantifiable risk figures, together forming a cross-validation of the same job posting.

The 5-Pillar Trust Engine and Transparent Verdicts

The soul of Genuire is the 5-Pillar Trust Engine — a multi-dimensional verification pipeline that blends machine learning with heuristic risk indicators. Rather than delivering a black-box "real" or "fake" verdict, it evaluates five separate dimensions and surfaces each pass or fail result to the user.

This transparent design is a value the developer deliberately emphasizes. She notes that closed APIs make it difficult to explain why a particular job listing was flagged or cleared. By using open-weight models and open-source libraries, developers can thoroughly audit model biases, fine-tune for threat-detection scenarios, and build a trust engine that users can actually understand. For job seekers, knowing which specific check failed is far more actionable than a cold numerical score.

Why Open Source Is Critical for Security Tools

The developer dedicates a section of her write-up to the significance of open source for security and anti-fraud tools. The credibility of a security product largely derives from its auditability. If the core decision logic is hidden behind a closed-source API, neither users nor developers can verify its fairness or identify false positives.

Using open-weight models like Gemma and open-source libraries like scikit-learn means the entire detection pipeline is inspectable and tunable. This ensures transparency in the decision logic and allows the community to collectively improve the model, continuously combating ever-evolving fraud tactics. For a product designed to "build trust," its own openness and interpretability are its most powerful endorsements.

In the anti-fraud domain, model "auditability" also addresses a practical asymmetry of error costs. If a legitimate job is flagged as fraudulent, an applicant may miss an opportunity; if a fraudulent job is cleared, the consequence could be stolen ID documents or a compromised bank account. If a closed-source API develops a systematic bias — say, a tendency to misclassify jobs from a particular region or industry — external developers have no way to detect or correct it. Open weights and open-source libraries, on the other hand, allow the community to continuously iterate by auditing training data distributions, adjusting classification thresholds, and adding adversarial samples for specific scenarios. This keeps the model's failure modes in the open — which is the core logic of security tools "earning trust through transparency."

AI Pair Programming in Practice

The development process behind Genuire is itself a noteworthy case study. The developer reveals that the entire project was built in deep collaboration with an AI coding assistant (Google Gemini / Antigravity). The AI agent played a role at multiple stages: helping design the 5-Pillar Trust Engine architecture, fine-tuning the scikit-learn models for improved accuracy, rapidly scaffolding the Flask backend prototype, and polishing the CSS for the dynamic frontend pipeline tracker.

The result demonstrates how AI collaboration allowed a team of two to wrap a complex ML backend into a polished, well-designed dashboard. This reflects the archetypal pattern of AI-assisted development today: the developer sets the direction and makes architectural decisions, while AI handles the heavy lifting of implementation and debugging.

Submitted as an entry for Week 1 of the Hacktoberfest Open Source AI Challenge, the project is deployed on Render with source code hosted on GitHub. While modest in scale, it offers a complete demonstration of how open-weight models, classical machine learning, and AI pair programming can be rapidly combined to build a security tool that solves a real-world problem.

Summary

Genuire's significance lies not in cutting-edge technology, but in how it assembles multimodal large models, traditional machine learning, and transparent design into a practical, interpretable anti-fraud solution. For developers interested in applied AI and open-source security tools, its architectural approach and the philosophy of an "explainable trust engine" are well worth studying.