This project contains the core implementation for an Multi Ai Interview Coach Agent, a multi-agent system designed to help learners practice technical interviews in a realistic, adaptive, and fully automated environment. The system is built using a modular architecture inspired by the Google Agent Development Kit (ADK) and simulates an interactive interview experience through coordinated agents working together.

The platform enables users to prepare for interviews in domains such as Java, Python, and Data Structures & Algorithms (DSA). It provides timed questions, intelligent answer evaluation, automated scoring, personalized feedback, and long-term performance tracking.

• Difficulty-based questions (Easy → Medium → Hard)
• Real-time countdown timer (20 → 0)
• Auto-submit when timer ends
• Smart scoring (Java, Python, DSA)
• Multi-Agent architecture (Orchestrator, Interviewer, Evaluator, Memory)
• Session summary + Weakness analysis
• SQLite-based long-term memory
• Clean and responsive Streamlit UI

In today’s highly competitive job market, students and job seekers are expected not only to possess technical knowledge but also to demonstrate the ability to clearly and confidently articulate their understanding during technical interviews. While many learners rely on traditional preparation methods—such as reading textbooks, watching online tutorials, solving static question banks, or practicing alone—these approaches often fall short. They fail to recreate the dynamic, unpredictable, and performance-driven environment of a real interview.

Most learners struggle with the following challenges:

Furthermore, many candidates experience anxiety, lack of confidence, and uncertainty because they do not get enough exposure to interview-style questioning before the actual interview. Traditional tutorials or question banks do not adapt to the learner’s behavior and cannot provide interactive follow-up questions, clarification requests, or personalized improvement suggestions.

The absence of an interactive, AI-driven interview simulation system creates a major gap in effective interview preparation. Without a realistic tool that asks questions, evaluates responses, measures performance, and provides structured feedback, learners often feel unprepared, lack confidence, and struggle to identify their strengths and weaknesses.

To bridge this gap, the proposed solution is an intelligent, adaptive, and accessible Multi-Agent AI Interview Coach. This system is designed to:

• Simulate real interview dynamics using timed questions
• Automatically adjust question difficulty based on user performance
• Evaluate answers using AI-driven scoring mechanisms
• Provide personalized feedback and improvement suggestions
• Track long-term user progress and highlight weak areas
• Offer a realistic practice environment anytime, anywhere

This project delivers a fully automated interview simulation experience through coordinated agents (Orchestrator, Interviewer, Evaluator, and Memory Agent). Together, they replicate the behavior of a trained technical interviewer, enabling learners to practice effectively, gain confidence, and become interview-ready.

The Multi-AI Interview Coach uses a modular multi-agent architecture where each agent performs a dedicated role. The Streamlit UI interacts with the user by showing questions, running the 20-second timer, collecting answers, and displaying feedback. The Orchestrator Agent controls the entire interview flow, including question transitions and auto-submission on timeout.

The Interviewer Agent selects questions by difficulty, while the Evaluator Agent scores answers using keyword matching or optional LLM evaluation. The Memory Agent records performance data and stores it in SQLite Storage, enabling long-term tracking of user weaknesses. Finally, the Session Summary and Summary UI present a clear breakdown of scores, feedback, and improvement areas.

🐍 Python 3.9+

• Core language used to build all agents and backend logic.

🌐 Streamlit

• Used to create the interactive user interface with questions, timer, and feedback display.

🗂 SQLite

• Lightweight database for saving sessions, answers, and long-term performance.

🤖 Multi-Agent Architecture

• Interviewer, Evaluator, Memory, and Orchestrator agents work together to simulate real interviews.

🔮 Gemini API (Optional)

• Provides advanced AI-based scoring and feedback when enabled.

📘 JSON Question Bank

• Stores all questions (Java/Python/DSA) in easy-to-edit JSON format.

The project is organized as follows:

ai-interview-coach/ — Main directory for the Multi-Agent Interview Coach system.
src/ — Core source code.
logs/
• ai_interview.log
storage/
• interview_sessions.db — SQLite database for session history.
• sqlite_store.py — Database handling logic.
tools/
• question_bank.json — Full question bank (Java, Python, DSA).
• scoring_utils.py — Keyword scoring logic.
a2a_bus.py — A2A-inspired internal communication bus.
ai_interview.db — Optional backup DB.
app.py — Streamlit UI (main application interface).
orchestrator_agent.py — Orchestrator Agent controlling the entire interview flow.
interviewer_agent.py — Interviewer Agent choosing questions by domain & difficulty.
evaluator_agent.py — Evaluates user answers (keyword or AI-based).
memory_agent.py — Tracks sessions, weaknesses, and summaries.
llm_adapters.py — Optional Gemini integration.
utils.py — Logging helpers and utilities.
main.py — Optional alternate entry file.
stt_agent.py — Deprecated speech-to-text handler (voice removed).
README.md — Full documentation for running and understanding the project.
requirements.txt — Python dependency list.

cd ai-interview-coach

python -m venv venv

.\venv\Scripts\Activate

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass

pip install -r requirements.txt

python.exe -m pip install --upgrade pip

pip install streamlit-autorefresh

cd src

streamlit run app.py

• Orchestrator Agent — Controls session flow & difficulty progression
• Interviewer Agent — Selects questions intelligently
• Evaluator Agent — Scores answers (Mock or Gemini API)
• Memory Agent — Tracks user performance & weaknesses

• 20-second countdown timer
• Auto-submit when timer reaches zero
• Auto-refresh for smooth countdown

• Java
• Python
• Data Structures & Algorithms (DSA)

• Keyword-based scoring
• Domain-aware feedback
• Suggestions for improvement

• Streamlit-based clean interface
• Responsive and minimal layout
• Clear question display
• Auto-refresh countdown timer

• User selects name + domain
• System asks an Easy question
• Timer starts → user answers or timeout triggers auto-submit
• Evaluation shown (score + feedback + suggestions)
• Medium → Hard questions proceed
• Final summary generated

The multi_agent_interview_coach follows this workflow:

1. Start Session: The user enters their name and selects a domain (Java, Python, or DSA). The Orchestrator Agent initializes a new interview session.

2. Select Question: The Orchestrator requests a question from the Interviewer Agent, which retrieves a non-repeated question from the JSON question bank based on the current difficulty level (Easy → Medium → Hard).

3. Show Question & Timer: Streamlit displays the selected question and starts a 20-second countdown timer. The user must answer before the timer expires.

4. Auto-Submit: If the timer reaches zero, the Orchestrator auto-submits the current answer and moves to evaluation.

5. Evaluate Answer: The submitted answer is evaluated by the Evaluator Agent using keyword-based scoring (with optional Gemini-powered scoring). The agent returns a score, feedback, and improvement suggestions.

6. Save Performance: The Memory Agent stores the answer, score, and weaknesses in the SQLite database using the sqlite_store module.

7. Next Difficulty: After each question, the Orchestrator progresses to the next difficulty level and repeats the cycle until all stages are completed.

8. Generate Summary: The Memory Agent compiles a complete performance summary, including average score, weak areas, and feedback. The Streamlit UI displays this summary to the user.

This project delivers a practical and accessible solution for students and job seekers who struggle with traditional interview preparation. By combining multi-agent intelligence, adaptive questioning, real-time evaluation, and personalized feedback, the system provides an experience that closely mirrors real technical interviews. Its lightweight design, intuitive UI, and structured learning flow help users build confidence, identify weaknesses, and improve consistently. Overall, the Multi-Agent Interview Coach provides meaningful value by making high-quality interview practice available anytime, without needing a human mentor or an expensive coaching platform.

The Multi-Agent Interview Coach demonstrates how intelligent agent-based systems can transform the way students prepare for technical interviews. By integrating orchestrated agents for questioning, evaluation, and memory, along with a responsive Streamlit interface and adaptive difficulty progression, the system offers an experience that feels structured, realistic, and personalized. Users not only practice under time pressure but also receive actionable feedback and insight into their weak areas, enabling continuous improvement. Overall, this project proves that a well-designed multi-agent architecture can deliver a powerful, accessible, and highly effective interview preparation tool—bridging the gap between traditional study methods and real-world interview demands.

Anukalp Pandey

GitHub: @anukalp2804
Kaggle: My Profile
LinkedIn: My Profile