We Built an Agent That Flags Fake Internships #kryx

ryxonix — Fri, 22 May 2026 17:24:04 +0000

Every placement season, students receive internship offers that look legitimate on the surface but fall apart the moment you inspect them closely.

Some ask for “training fees.”
Some guarantee placements before interviews even happen.
Some companies barely exist online.
Others hide behind generic Gmail accounts and flashy marketing.

The worst part is that many students can’t easily distinguish between a real opportunity and a well-designed scam.

So my teammates and I built a system that tries to score internship legitimacy before students commit time or money.

We call it ShieldIntern.

The Core Idea

We wanted a system that behaves less like a chatbot and more like an auditor.

Instead of simply asking an LLM whether an internship is “fake,” we structured the analysis around four specific evaluation pillars:

Financial transparency
Digital footprint
Recruitment authenticity
Marketing credibility

The system takes internship ads, screenshots, emails, company descriptions, and URLs as input. It then analyzes the content and generates a legitimacy score between 0 and 100.

But the important part wasn’t generating a score.

The difficult part was making the scoring explainable.

The Rule That Changed Everything

One design decision became the foundation of the entire system:

If a company asks students to pay upfront fees, the legitimacy score is automatically capped below 30.

That single rule solved multiple problems at once.

Without it, the LLM occasionally produced high scores for suspicious internships simply because the company had a polished website or strong marketing language.

In reality, legitimate internships rarely require students to pay to work.

So instead of relying purely on probabilistic reasoning, we introduced deterministic penalties for critical red flags.

That hybrid approach produced much more reliable outputs.

How The System Works

The frontend was built using React, Vite, and Tailwind CSS.

Students can:

Upload screenshots
Paste internship descriptions
Add company details
Submit emails or URLs

The backend uses Express.js and Multer for request handling and file uploads.

The analysis pipeline sends structured prompts to Groq running LLaMA 3 70B.

Instead of asking broad questions, the prompt forces the model to evaluate internships through individual categories.

For example:

Does the company use a corporate domain?
Is the recruitment process realistic?
Does the offer use urgency tactics?
Are responsibilities clearly defined?
Is there evidence of a real digital footprint?

Each category contributes to the final score independently.

That structure made the outputs significantly more consistent.

One Unexpected Problem

The first versions of the system were too optimistic.

The model often interpreted professional-looking language as credibility.

That became a serious issue because scam internships are usually designed to appear highly professional.

We had to redesign the scoring logic so that suspicious financial behavior outweighed surface-level presentation quality.

This became one of the biggest lessons we learned while building the project:

LLMs are good at pattern recognition, but trust systems still need hard constraints.

Why Explainability Matters

One thing we intentionally avoided was producing only a final verdict.

A simple “fake” or “real” label isn’t very useful to students.

Instead, the system returns:

positive indicators
red flags
category breakdowns
actionable recommendations

That way, students understand why an internship appears suspicious.

In practice, explainability matters more than raw scoring accuracy because users need confidence in the reasoning process.

Building the Frontend

We wanted the interface to feel less like an academic tool and more like a modern product.

So we added:

drag-and-drop uploads
animated score gauges
color-coded verdicts
responsive layouts
dark mode support

The goal was to make the analysis feel immediate and intuitive.

Tech Stack

Frontend:

React 18
Vite
Tailwind CSS
Axios

Backend:

Node.js
Express.js
Multer

AI Layer:

Groq API
LLaMA 3 70B

What We Learned

Building this project changed the way we think about AI-assisted trust systems.

A few lessons stood out:

Pure LLM reasoning is not enough for fraud detection.
Critical rules still need deterministic enforcement.
Explainability matters more than confidence scores.
Users trust systems that show reasoning transparently.
Scam detection is largely behavioral analysis.
Many fake internships reveal themselves through recruitment patterns rather than obvious technical signals.
Small prompt structure changes drastically affect consistency.
Breaking scoring into categories improved output quality significantly.

Final Thoughts

Internship scams are becoming increasingly sophisticated, especially in online hiring spaces.

We don’t think AI alone can solve that problem.

But we do think systems that combine structured rules with language models can help students make safer decisions faster.

That was the goal behind ShieldIntern.

GitHub Repository:
https://github.com/ryxonix/HackWithBangalore

DEV Community: ryxonix