An interview is a live system, not a sequence of prompts.
The platform had to listen, decide who should speak, follow an interview plan, react to code, remember earlier answers, and produce evidence-based feedback.
I built AI Interview in 2025 as a full-stack product. A React client handled the interview room, audio, video, and coding workspace. A Python and FastAPI backend ran the agents and streamed events over WebSockets.
There were three product modes: candidate practice, company-led screening, and invited candidate interviews. The same runtime had to support different jobs, interview plans, panelist personalities, and model providers.
This work predates the agent SDKs I use today. Agent lifecycle, routing, state, memory, and messages were explicit application code.
One coordinator, several focused agents.
The Master Agent owned the interview. It did not answer every question itself. It kept the shared state and sent the right context to the right specialist.
Configuration Agent
Before the call, it turned the job details and examples into an interview plan, coding activity, starter code, and panelist profiles.
Master Agent
During the call, it tracked the round, topic, subtopic, time, last speaker, waiting state, and audio playback state.
Panelist Agents
Each interviewer had a professional profile and personality. Only the selected panelist received a turn command.
Activity + Evaluation Agents
One watched the coding task while it happened. The other combined the transcript, criteria, code analysis, and panelist assessments after the interview.
Follow one event through the system.
Choose an event to see the path it takes. The browser and agents never communicate directly; the Master remains the control point.
For every conversational turn, the Master asks the model for two bounded decisions: is this topic complete? and who should speak next? Older context is summarized, the current exchange stays detailed, and advice for multiple panelists is generated in parallel.
The selected panelist receives one structured message. Its live path combines internal reasoning and the spoken answer in a single model call, then returns a typed response to the Master. That avoids extra model round trips while keeping the wider workflow explicit.
The SDK was queues, tasks, and typed messages.
Each panelist and the Activity Agent ran as its own asynchronous task. The Master wrote commands to their queues, and agents returned results through a shared receiving queue.
Code owns control
Locks, queues, timeouts, state transitions, database writes, and WebSocket events are regular code.
LLMs make narrow choices
The model chooses the next speaker, judges topic completion, writes advice, and produces a response.
Work happens in parallel
Panelists remain alive as background tasks, and per-panelist advice is generated together.
Models remain replaceable
A shared provider interface supports different OpenAI, Gemini, Groq, Grok, DeepSeek, and Perplexity paths.
Keep the current moment rich. Compress the past.
The interview plan doubles as a memory index. Dialogue is stored under its round, topic, and subtopic. As the conversation advances, the system creates subtopic and topic summaries.
Full conversation
Subtopic summaries
Compact summaries
This gave the Master and panelists enough evidence for a coherent follow-up without sending the entire interview transcript on every model call. The same memory graph is persisted so evaluation can reconstruct the evidence later.
Feedback is a second workflow, not an afterthought.
The Evaluation Agent reloads the interview plan and memory, then grades each topic and subtopic against its own criteria. Coding performance is included as evidence rather than scored in isolation.
For deeper technical discussion, the evaluator can generate focused subqueries and extract supporting details before scoring. Question-level results are then merged into criterion-level scores and an overall report.
Agent quality comes from the system around the model.
A modern agent framework can now provide parts of this runtime. The hard product decisions remain the same: what each agent owns, what information it sees, when a model should decide, and how evidence survives the run.