FalconX — AI Technical Interview Platform

Inspiration

Every one of us has either sat through a whiteboard coding interview or watched a friend get rejected from one — for problems that had nothing to do with the actual job. Meanwhile, the same companies rejecting us expect their engineers to use Claude Code, Cursor, and Copilot on day one.

That contradiction is where FalconX started. If AI is already how engineers work, why is it still banned in the one hour that decides whether they get hired? And if candidates are already using AI in interviews anyway — banned or not — companies aren't testing skill anymore. They're testing who's better at hiding it.

We wanted to build something that closes that gap honestly, instead of pretending AI doesn't exist.

What it does

FalconX reframes the technical interview from "prove you can solve puzzles alone" to "prove you can ship working software using the tools you'll actually use on the job."

Instead of a generic coding exercise, candidates get a real, sanitized snapshot of the hiring company's own codebase, a real bug or feature request, and full access to AI tools. What we evaluate isn't the final code — it's how well the candidate diagnoses the problem, directs an AI assistant, catches its mistakes, and explains their reasoning.

At the end, a human recruiter — never the AI — makes the final call.

How we designed it

Phase 1 was about validating the idea end to end before writing production code, so we focused on three things:

• Research — we mapped the existing landscape (CodeSignal, CoderPad, HackerRank, Karat, Mercor) to find the actual gap: nobody combines a real employer codebase, resumable human oversight, and native ATS integration in one platform.
• Agentic architecture — we designed a multi-agent system on LangGraph's StateGraph, where a Supervisor agent routes dynamically between an Interviewer agent and an Evaluation agent based on live state, instead of a fixed script. Three external tools — the GitHub API, the Greenhouse API, and a Judge0 + Kubernetes sandbox — are called dynamically inside that loop.
• Human-in-the-loop design — rather than a "flag for review" checkbox, we built the control point around LangGraph's interrupt() function, which pauses the entire workflow and persists full session state to a database checkpoint before a recruiter ever sees it. Nothing reaches the ATS until a human approves it.

Challenges we ran into

• Designing genuine ambiguity handling. It's easy to draw a chatbot that answers everything. It's much harder to design an agent that recognizes when it doesn't have enough information and asks a clarifying question instead of guessing — which mattered a lot for the "Conceptual Reasoning Design" criteria.
• Making human oversight meaningful, not decorative. A lot of "human-in-the-loop" designs are just a rubber-stamp approval button after the AI has already effectively decided. We had to rethink the flow so the AI's role is strictly limited to gathering and presenting evidence — never rendering a verdict.
• Scoping realistically for a hackathon. It was tempting to over-engineer the architecture. We kept coming back to: what's the minimum viable version of this loop that still proves the core idea — real codebase, dynamic tool use, resumable human control?

Accomplishments that we're proud of

• A genuinely dynamic agent loop — not a disguised linear script — with real error recovery (retry with exponential backoff, fallback routing) built in from the start.
• A human-in-the-loop design with actual technical teeth: full state persistence means a recruiter can review a session days later without losing any context.
• A clear, defensible answer to "would a business pay for this" — grounded in a real competitive gap, not just a feature list.

What we learned

We learned how much harder it is to design good agent architecture than to just wire an LLM to some tools. The interesting engineering problems weren't the API integrations — they were things like: when should control pass back to a human, and how do you make that pause point trustworthy instead of a formality?

What's next for FalconX

Phase 2 is building it for real: the LangGraph state machine and three core agents first, then the sandboxed execution engine (our highest-risk component), followed by the GitHub ingestion pipeline, and finally the recruiter dashboard with live Greenhouse webhook integration.

Built With

• astapi
• langchain
• langgraph
• postgresql
• python
• react