GraphPrep: Multi-Agent AI Interview Preparation System

An advanced interview preparation system that analyzes candidate resumes using ML to generate custom technical prep runs.

Comment

Inspiration

As technical job seekers, we noticed a critical flaw in how candidates prepare for interviews. Most preparation tools are static and generic—they teach you how to solve standardized coding puzzles but completely ignore the specific details of your own resume. When candidates get to real-world technical screens, interviewers probe their actual claims and project architectures.

Furthermore, many resumes fail automated screening or hiring manager reviews due to "high-risk" claims—vague, unquantified assertions like "responsible for improving database performance" without concrete metrics. We were inspired to build an intelligent, candidate-first interview preparation system that acts as an elite technical hiring committee: identifying hidden vulnerabilities on a candidate's resume, scoring their real-world readiness using calibrated machine learning models, and preparing them with hyper-tailored practice interviews.

What it does

GraphPrep is an advanced AI-powered interview preparation system designed specifically to prepare candidates for high-level technical screens.

  • Dual-Section Sidebar Profile: The candidate uploads their resume (PDF/TXT), inputs their target role, experience, tech stack, and self-declared weaknesses.
  • Real-Time Agent Orchestration: An animated multi-agent dashboard sequences through a 7-stage cognitive pipeline, visualising the decisions of the AI agent nodes in real time.
  • ML Credibility Analysis: It classifies every resume claim using calibrated ML models, flagging claims as High, Medium, or Low risk based on their specificity, metrics density, and language.
  • Hybrid Readiness Scoring: It computes a dynamic mathematical readiness score (from 0 to 100) mapping the candidate to a level (Beginner, Intermediate, Expert) based on their tech stack alignment and risk penalties.
  • Tailored Practice Questions: Generates several customized questions grouped into Warmup, Core, and Challenge phases. Each question features the targeted resume claim, interviewer reasoning, and a checklist of key points the candidate should cover in their answer.
  • Adaptive AI Coaching: Delivers targeted insights split into Strengths, Weaknesses, and Practice Tips, accompanied by collapsible drawers with external learning resources powered by search.

How we built it

We engineered GraphPrep using a modern, decoupled, asynchronous microservices architecture:

1. Multi-Agent Orchestration (LangGraph)

Instead of relying on single LLM prompt calls, we modeled the cognitive flow as a cyclical state machine using LangGraph. A shared state is passed through six specialized nodes:

Resume Analyst ➔ Question Strategist ➔ Difficulty Planner ➔ Question Generator ➔ Validator ➔ Coach

We built a strict quality assurance feedback loop: the Validator checks all drafted questions against formatting rules (e.g. conversational tone, no compound questions). If a question fails, it is dynamically routed back to the Generator with contextual feedback for a rewrite.

2. Machine Learning & Calibrated Scoring

Ensemble Claim Classifier: We compiled a synthetic training dataset of over 1,000 resume statements labeled by risk. We trained an ensemble model combining Logistic Regression and Random Forest Classifiers, wrapping them in CalibratedClassifierCV to output highly accurate probability scores.

Mathematical Scorer: The system evaluates technical readiness mathematically using a hybrid scoring algorithm.

$$ S_{readiness} = w_1 \cdot C_{relevance} + w_2 \cdot E_{match} - \sum (P_{risk}) $$

Where (C_{relevance}) represents semantic cosine similarity to the job description, (E_{match}) represents years of experience alignment, and (P_{risk}) is a penalty derived from the calibrated probabilities of high-risk claims on the resume.

3. Asynchronous Backend & Unified Static Hosting (FastAPI)

The backend is built with FastAPI using asynchronous controllers to handle file extractions (utilizing pdfplumber and regex parsers) and multi-agent loops in parallel without I/O blocking.

We removed all production CORS overhead by configuring FastAPI to host the compiled React production client directly, serving the complete application from root.

4. Glassmorphic User Interface (React + Vite + Vanilla CSS)

The frontend is an ultra-premium, dark-themed dashboard styled using Vanilla CSS variables.

It implements fluid UI/UX elements:

  • interactive file drop-zone
  • pulsing progress circles tracking active agent loops
  • expandable checklists
  • resource side-drawers

Challenges we ran into

Agent Loop Convergence

In early implementations, LLM-based generators and validators would sometimes enter infinite back-and-forth loops. We solved this by implementing strict iteration caps (max 3 validation cycles) and engineering highly precise prompting templates to guide the refinement loop.

Context Latency

Running 6 agents sequentially introduces significant processing latency. To improve usability, we built the Agent Progress Tracker in React. It sequences through active agent steps with pulsing neon loader rings to visually manage candidate expectations during backend latency.

Lack of training data

Not having enough data to accurately train ml models been a big issue. There's only so much we can do with synthetic data. We managed to train and get good results for claim risk classifier. But didn't get much time to optimise our readiness scorer. Luckily our NLP pipeline came in clutch as we used rule based scoring for it instead.

Accomplishments that we're proud of

  • Engineering a Unified Architecture: We successfully built a state-of-the-art React web application that runs alongside the FastAPI backend with a single startup command.
  • Cyclical Logic with LangGraph: Creating a functional, auto-correcting feedback loop between our Generator and Validator agents that drastically improved question quality.
  • Custom Machine Learning Integrations: Integrating genuine calibrated ML models to calculate claim risks rather than relying solely on generative text.
  • Uncompromising Design Aesthetics: Crafting a sleek, dark glassmorphic dashboard that feels highly premium and looks amazing on any display.

What we learned

  • Multi-Agent Partitioning: Partitioning complex cognitive tasks into distinct single-focus agents (e.g. separates strategic planning from question generation) yields dramatically better results than a single monolithic prompt.
  • Calibrated Classification Matters: Simply identifying keywords is not enough. Applying calibrated classifier probabilities to calculate candidate readiness penalties prevents scoring hallucinations and yields realistic outputs.
  • Production Packaging: Designing your project for clean setup (like our 2-minute unified command sheet) is just as important as the code itself.

What's next for GraphPrep: Multi-Agent AI Interview Preparation System

Our roadmap for GraphPrep includes:

Voice-to-Text Practice Sessions (Mock Interview)

Integrating real-time speech recording in the practice tab, allowing candidates to record their verbal answers and receive instant AI analysis on their tone, keywords, and pacing.

Mock Coding Sandbox

Embedding a light, secure code-editor sandbox directly in the "Challenge Questions" accordion so candidates can compile and test coding solutions right inside the dashboard.

Real-Time Resume Editor

Adding an inline document editor that highlights "high-risk" sentences on the fly and offers dynamic rewrites to improve their screener pass rates.

Built With

Share this project:

Updates