A behavioral interview coaching tool that scores answers against a five-dimension STAR rubric, tracks progression across five attempts, and generates a downloadable PDF scoresheet per session.
Shashirekha Pajjuri, Shylaja Basetty, Sowmya Dindukurthi, Yifon Chen
- Problem
- Core Concept & Value
- Solution
- Screenshots
- Architecture
- Quick Start
- Project Structure
- Active Question
- Users / Progression Tracks
- Skills
- Storage
- Testing
- Limitations / Roadmap
- Environment
- License
Practicing behavioral interview answers is hard to do well on your own. Most people either rehearse the same answer until it sounds smooth without checking whether it actually has substance, or get one-off feedback from a friend or coach that doesn't carry over between practice sessions. There's rarely a consistent, structured way to see whether an answer actually follows the STAR format, whether it's specific enough, and whether you're improving across attempts rather than just repeating the same gaps.
STARtrack's central idea is a self-checking, rubric-driven feedback loop for behavioral interview practice: one LLM call scores an answer against a fixed five-dimension rubric, another generates a progression narrative across attempts, and a third — the meta-eval judge — scores the first LLM's assessment for accuracy and actionability. The value isn't in autonomous orchestration; it's in chaining multiple independent LLM judgments (scorer, narrator, judge) into a pipeline that checks its own output rather than trusting a single pass.
By the broader definition of agentic systems — an LLM operating inside a workflow with tools and state, doing real work at each step rather than a single one-shot call — STARtrack qualifies: state persists across attempts in SQLite, and each stage (gate, scorer, narrator, judge) does substantive reasoning rather than passing text through unchanged. Where it stops short of the stricter definition (an LLM that dynamically plans and selects which tool to call next) is orchestration: the built and tested path is a fixed Python pipeline — gate → assess → validate → save → progression → scoresheet — where the sequence is hardcoded in code rather than chosen by the model at runtime. An ADK-based autonomous agent (agent.py, using AGENTS.md and registered Skills as callable tools) was the original design and remains in the repo; the Gradio pipeline is what was actually developed and tested. Either way, the relevance to the track is the same multi-step LLM evaluation loop — rubric scoring, progression tracking, and LLM-as-judge — doing substantive work at every stage.
STARtrack gives structure to that process. It scores each answer against a fixed five-dimension rubric (S.T.A.R. answer structure, specificity, relevance, confidence, conciseness), and tracks every attempt so progress is measured, not just felt.
- Rubric-based scoring — each answer is scored 0–3 on five dimensions (max 15), with concrete strengths, gaps, and one specific improvement to focus on next.
- Progression tracking — up to 5 attempts per user against the same question, with a trend narrative and persistent-gap detection starting at attempt 2.
- Objective conciseness scoring — spoken length is computed from word count at a fixed speaking pace rather than estimated by the model, so pacing feedback doesn't drift with how "smooth" an answer sounds.
- Downloadable PDF scoresheet — radar chart of the five dimensions, plus a progression line chart and narrative once there's more than one attempt.
- Guardrails — a semantic gate blocks non-answers and prompt-injection attempts before scoring, and a validation step confirms the overall score always matches the sum of its parts.
- Built-in quality check — an LLM-as-judge meta-eval can score the assessment itself for accuracy and actionability, so the rubric grading isn't a black box.
Gradio UI — the interview practice screen: prompt, answer input, radar chart, and progression narrative.
Sample scoresheet PDF — progression across attempts and persistent gaps, generated after each submission.
STARtrack was originally designed as a single Google ADK agent: agent.py loads AGENTS.md as its static instruction context at startup and registers each Skill (semantic_gate, assess_answer, validate_session, save_session, analyze_progression, generate_scoresheet, run_meta_eval, reset_progress) as a tool the agent can call, letting an LLM decide the flow at runtime.
The version that was actually built out and tested is the Gradio UI (run_ui.py / skills/ui.py). It calls the same underlying Skill functions directly, in a fixed Python sequence — gate → assess → validate → save → progression → scoresheet — rather than through ADK's agent/tool-calling loop. Gemini is still invoked at several individual steps (scoring, the semantic gate, the progression narrative, the meta-eval judge), but nothing in the control flow itself is LLM-decided: it's a fixed pipeline that calls the LLM at discrete steps, not an autonomous agent that plans its own tool use. AGENTS.md is not read by this path at all.
See docs/architecture.md for the full context-engineering breakdown and data flow.
Requires Python 3.10+.
git clone <repo> && cd STARtrack
cp .env.example .env # add your GOOGLE_API_KEY
pip install -r requirements.txt
# Google ADK is effectively NOT used by STARtrack — see ui.py.
# Recommended: python run_ui.py to launch the Gradio custom UI entry point.
python run_ui.py # Customized Gradio UI on http://localhost:7860 (recommended)
python agent.py # CLI mode via ADK
adk web . # ADK browser UI on http://localhost:8000See AGENTS.md for the full folder layout, Skill inventory, rubric definitions,
and data contract.
question_1 — "Tell me about a time you had to influence someone without authority."
| user_id | Description |
|---|---|
user_a |
Steady improvement across all dimensions |
user_b |
Plateau attempts 1–3, breakthrough attempts 4–5 |
user_c |
Uneven — specificity up, confidence dips mid-series |
| Skill | File | Purpose |
|---|---|---|
assess_answer |
skills/assessment.py |
Score transcript against rubric |
save_session |
skills/progression.py |
Persist attempt to history |
analyze_progression |
skills/progression.py |
Narrative across attempts |
generate_scoresheet |
skills/scoresheet.py |
PDF scoresheet |
semantic_gate |
skills/guardrails.py |
Validate input before assessment |
validate_session |
skills/guardrails.py |
Confirm score integrity |
run_meta_eval |
skills/eval.py |
LLM-as-judge on assessment quality |
reset_progress |
skills/ui.py |
Clear user history |
Attempt history is stored in history/sessions.db (SQLite). The file is
created automatically on first run — no setup required.
Migrating from a previous version (.jsonl files): if you have existing
history/*.jsonl files, run the migration script once:
python scripts/migrate_to_db.py # import into DB (safe, idempotent)
python scripts/migrate_to_db.py --delete # import + remove .jsonl filespytest tests/integration_test.py -vMost tests are mocked and need no API key or network access. 7 tests make real Gemini calls and require a valid GOOGLE_API_KEY in .env: TestSemanticGate::test_valid_answer_passes, test_garbage_input_blocked, test_prompt_injection_blocked, TestAssessAnswer::test_returns_all_schema_fields, test_overall_score_equals_sum, test_scores_within_range, and TestAnalyzeProgression::test_returns_narrative_keys. Running the suite without a key will fail those 7 rather than skip them. The same suite can also be run from the UI itself via Dev Tools → Run Integration Tests.
Out of scope for the current version:
- Audio input and transcription (Gemini Audio or Whisper)
- Attempts beyond 5 per user
- Additional interview questions beyond
question_1 - Real user authentication (currently
user_a/user_b/user_cplaceholders) - Cloud Run deployment
- Python 3.10+
- Model (assessment + progression):
gemini-3.1-flash-lite - Model (semantic gate):
gemini-2.5-flash-lite - Model (meta-eval judge):
gemini-3.5-flash
This project is licensed under the MIT License — see LICENSE for details.