InterMind: autonomous AI interviewer
An autonomous AI interviewer that turns a job description into an adaptive interview, evaluates candidate responses as the conversation unfolds, and produces an evidence-based report.
An interview that is written while it happens.
InterMind reads a job description, works out what the role is really asking for, and turns that into a plan of assessment areas. Then it runs the interview itself, one exchange at a time. What comes back at the end is not a transcript but a report where every assessment points to something the candidate said.
The interesting part is the middle. Each answer is evaluated as it arrives, evidence builds up across the exchange, and that state is what decides the next move: a targeted follow-up on something still unclear, or the next assessment area. The hiring decision stays with the recruiter. InterMind's job is to gather the evidence that decision gets made on.
Open the product itself.
InterMind is deployed and public. Below is the app, embedded: the same one a recruiter uses to set up a role, and the same one a candidate is sent into.
A fixed question list can't tell the difference.
A scripted screening interview asks every candidate the same things in the same order. It cannot push on an answer that talked around the question, and it cannot skip ground the candidate has already covered well. What it leaves behind is a transcript, or somebody's impression of one, for a reviewer to interpret later.
I wanted to close both gaps: let the questions depend on the answers, and make the output checkable, with every claim in the report anchored to something the candidate actually said.
The whole system, end to end.
InterMind is mine from the agent graph through to the deployed product:
Interview agent
Designed and built the LangGraph flow that plans, asks, evaluates, and decides what comes next.
Job-description analysis
Turned free-text job descriptions into structured role understanding and an interview plan.
Evaluation & reporting
Built the structured answer evaluation and the evidence-based report it produces.
Backend
Developed the FastAPI service and the PostgreSQL persistence behind interview sessions.
Frontend
Built the React and TypeScript app covering both the recruiter and candidate workflows.
Voice
Integrated Azure AI Speech so an interview can be spoken instead of typed.
Deployment
Shipped it to production: the React app on Vercel, the API on Azure App Service.
What it's built with.
Agent & LLM
Backend
Frontend
Voice & context
Deployment
Where the decisions are made.
The React client covers both workflows (a recruiter setting up a role, a candidate sitting the interview) and talks to a FastAPI service. Behind that service, a LangGraph graph holds the interview state and calls OpenAI for the language work: reading the role, phrasing the next question, evaluating each answer. PostgreSQL stores the session, so an interview is a durable record rather than a chat window.
Two inputs sit to the side of that path. Azure AI Speech is optional and turns the same exchange into a spoken one. O*NET is supplementary occupational context, used only when the role matches an occupation reliably. When it doesn't, the plan comes from the job description alone rather than from a bad match.
What it does.
- Job-description analysis that turns a free-text role into structured requirements.
- Structured interview planning, so the conversation has assessment areas rather than a fixed script.
- Adaptive interviewing: what the candidate says shapes what gets asked next, including a targeted follow-up when an answer leaves something important unresolved.
- Cumulative evidence carried across a follow-up exchange rather than judged turn by turn.
- Structured answer evaluation feeding an evidence-based report a recruiter can check.
- Recruiter and candidate workflows, two separate paths through the same product.
- Optional voice interaction through Azure AI Speech, for a spoken interview instead of a typed one.
- O*NET occupational context layered in as supplementary signal when a reliable match exists.
The hard parts.
Making the interview actually react
Making the interview genuinely react to each answer was the hardest part. I had to decide when an answer was enough, when to probe deeper, and when to move on, and that routing is what the LangGraph flow holds.
A report that shows its reasoning
I wanted the report to show the reasoning behind an assessment, not just a score. It ties the role requirements to the candidate's answers, the evidence behind them, and what is still missing.