Hard Wired Questions

• 

Every company—small startup or global enterprise—begins hiring with the same painful step: screening. It takes hours to sift through thousands of applicants, and most of that time is wasted on candidates who are not qualified, not aligned with the role, or outright cheating. No one wants to spend time on bad candidates, yet the industry keeps repeating this slow and inefficient process.

This gap is what inspired Hard Wire Questions. Instead of recruiters wasting hours on early-stage calls, the tool replaces the entire first screening layer. If 1,000 candidates apply, AGI Interviewer automatically identifies the strongest fits by filtering out anyone who cheats, types answers on the screen or uses tools like Cluely. It checks whether the candidate’s LinkedIn profile, CV, and live interview answers match—and it does this across any domain, from engineering and data science to marketing and product roles.

The goal is simple: remove the entire time sink of early screening and let teams speak only with the top candidates. AGI Interviewer exists to give companies real time back, while giving candidates a fair, efficient, unbiased process.

How we built it

We built Hard Wired Questions as a multi-agent system orchestrated through a central backend that coordinates seven specialized AGI agents. The architecture includes:

Frontend: Next.js with Tailwind CSS providing two main surfaces—a candidate UI (application → lobby → interview room → results) and an interviewer dashboard with live monitoring capabilities.

Backend: Node.js/Express API with PostgreSQL database, all session-scoped to ensure complete data isolation. An Agent Orchestrator serves as the conductor, calling AGI APIs for each specialized agent and validating all outputs.

Seven AGI Agents: Application Analyzer (normalizes resumes), Verification & Research (cross-checks LinkedIn/GitHub/portfolio against claims), Interview Planner (generates custom question sets with rubrics), Interview Conductor (runs the live interview with empathy and follow-ups), Transcript & Insight Tagger (extracts claims and STAR patterns), Scoring & Matching (produces evidence-based scorecards), and Results Narrator (generates candidate and interviewer summaries).

Real-time Interview: WebRTC for video/audio with streaming transcription via Deepgram/Whisper, live caption display, and a 15-minute structured interview flow.

Proctoring System: Client-side JavaScript tracks visibility API, window blur/focus, clipboard activity, and optional MediaPipe head-pose detection—all processed as signals, not verdicts, to fairly detect potential cheating without false positives.

Challenges we ran into

Latency management: Coordinating multiple LLM calls while keeping the candidate experience smooth required aggressive parallelization (running verification during the lobby phase) and small, focused prompts to minimize response times.

Proctoring without invasion: Building a fair cheating-detection system that doesn't create false positives or violate privacy was delicate. We settled on collecting behavioral signals (tab switches, copy/paste, head movement) rather than raw video, and capping penalties to keep the system forgiving.

Schema consistency: Getting seven different agents to output reliable, parseable JSON required extensive validation logic and fallback handling for when agents returned unexpected formats.

Evidence-based scoring: Moving beyond "vibes" to create transparent, reproducible evaluations meant designing detailed rubrics for each question and linking every score to specific transcript evidence—a challenge when working with natural conversation.

Time pressure: Building a production-quality system with full candidate and interviewer UIs, seven agents, live transcription, proctoring, and verification in 24 hours required ruthless prioritization and a convergent build plan.

Accomplishments that we're proud of

True vertical autonomy: Unlike tools that just schedule calls or parse resumes, Hard Wired Questions executes the entire screening workflow end-to-end—from application intake to final hiring recommendation—with no human intervention required.

Evidence-backed decisions: Every score is tied to transcript quotes, rubric criteria, and verification results. This creates transparency that both candidates and hiring teams can trust.

Fair proctoring: We built a system that detects cheating signals without penalizing candidates for legitimate behavior like adjusting their posture or briefly losing focus—keeping the penalty cap at 12% and using gentle schedules.

Cross-domain capability: The system works for any industry (engineering, marketing, product, data science) because the agents adapt their questions and evaluation criteria to the role requirements.

Privacy by design: Session isolation, consent flows, PII minimization, and on-device processing for head pose ensure we never leak data or create compliance risks.

Processing at scale: The architecture can handle 1,000 candidates in parallel and surface the top 10 matches, turning a weeks-long screening process into minutes.

What we learned

Context is everything: The quality of agent outputs improved dramatically when we gave each agent exactly the right inputs—CandidateProfile for planning, DiscrepancyReport for scoring, etc. Over-sharing context actually degraded performance.

Small penalties, big fairness: We initially considered harsh cheating penalties, but learned that browser signals are noisy. Keeping penalties under 12% and requiring confirmed evidence (not "cannot determine" flags) made the system far more defensible.

Empathy at speed: The Interview Conductor needed explicit prompts to stay warm and encouraging while also moving efficiently through questions. Balancing empathy with discipline was harder than we expected.

Streaming beats batching: Real-time transcription with live tagging created a much better interviewer experience than waiting until the end. It also enabled mid-interview proctor warnings.

Observability is non-negotiable: Storing input/output snapshots for each agent and maintaining an event log saved hours of debugging and will be critical for demo day when things inevitably go sideways.

What's next for Hard Wired Questions

Multi-round support: Extending beyond first-round screening to handle technical assessments, case studies, and final-round evaluations with memory of previous interactions.

Cohort analytics: Building percentile rankings and skill distribution views so companies can understand not just individual candidates, but how their entire applicant pool compares.

Collaborative scoring: Allowing multiple interviewers to review the same candidate with consensus mechanisms and bias detection.

Candidate self-service: Letting applicants practice with the system before their real interview, with feedback on how to improve their answers.

Integration ecosystem: Direct connections to ATS platforms (Greenhouse, Lever, Workday) and background check providers to create a seamless hiring pipeline.

Advanced verification: Expanding beyond LinkedIn/GitHub to check certifications, degrees, and professional references automatically.

Accessibility features: Adding support for text-only interviews, multiple languages, and accommodations for candidates with disabilities to ensure truly fair s

Built With

• deepgram/whisper-(speech-to-text)
• express.js
• languages:**-javascript/node.js-**frameworks:**-next.js
• mediapipe-(head-pose-detection)
• node.js
• parsing)
• pdf.js
• resume
• socket.io/server-sent](http://socket.io/server-sent)-events-**database:**-postgresql-(sqlite-for-rapid-prototyping)-**apis-&-services:**-agi-api-(multi-agent-orchestration)
• tailwind-css-**real-time-communication:**-webrtc-(livekit/twilio)
• web-based