LOCATR

The Problem

Finding the right venue for a group, balancing vibe, budget, and local risk signals, means manually cross-referencing multiple sources and then still guessing. LOCATR collapses that research into a single query and streams back a ranked, explainable shortlist.

My Role

Full-stack and AI engineer, top GitHub contributor on a team of 4, owning the LangGraph graph design, asyncio fan-out, Snowflake integration, and WebSocket streaming layer.

The Approach

• Designed a 6-node LangGraph graph: Commander parses intent and pulls Auth0 preference weights; Scout discovers candidates via Google Places and deduplicates with Haversine distance, pulling historical risk events from Snowflake; Vibe Matcher, Cost Analyst, and Critic run as a parallel asyncio fan-out for multimodal, deterministic, and risk scoring respectively; Synthesiser produces a composite ranked shortlist with why/watch-out text.
• Streamed live agent state to the Next.js frontend over WebSockets so users see the pipeline reasoning in real time rather than waiting for a final answer.
• Integrated Auth0 CIBA (Client-Initiated Backchannel Authentication) as a human-approval gate before any Gmail booking dispatch, keeping real-world side effects under explicit user control.
• Used Snowflake as the structured data store for historical venue risk events, giving the Critic agent a queryable signal rather than relying solely on LLM inference.

Key Decisions

• Running the three analyst agents (Vibe Matcher, Cost Analyst, Critic) concurrently with asyncio instead of sequentially was the single biggest latency lever. Each agent is independent given the Scout output, so there was no correctness reason to serialize them, parallelizing dropped pipeline time from about 9 seconds to under 3 seconds. The lesson generalized: in any LangGraph pipeline, map your dependency graph before wiring edges, because sequential wiring of independent nodes is an invisible tax.
• Choosing a deterministic scoring layer (Haversine deduplication in Scout, price/value arithmetic in Cost Analyst) alongside LLM calls (Gemini multimodal in Vibe Matcher) kept the system inspectable and debuggable. When the shortlist ranked unexpectedly, I could isolate whether the fault was in the embedding score or the rule, which is much harder in an all-LLM pipeline.
• Auth0 CIBA for the booking action, rather than a simple confirmation modal, was a deliberate trust boundary: the agent can recommend freely, but dispatching a real email requires an explicit out-of-band approval push. That pattern, modular, observable agents with human approval for consequential actions, is what separates a demo from a deployable system.

Impact & Results

• Won DeerHacks V (1 of 9 prizes, 164 participants) as the top GitHub contributor on a team of 4.
• Asyncio fan-out across the three parallel analyst agents cut pipeline latency from approximately 9 seconds to under 3 seconds (roughly 70% reduction).
• Shipped 45,000+ lines across the full stack in a 36-hour hackathon window, covering the LangGraph backend, FastAPI service layer, Snowflake integration, WebSocket streaming, and Next.js/Mapbox frontend.

The Stack

What I Learned

• Agent orchestration discipline matters more than model choice. The biggest performance win was not a better prompt, it was drawing the dependency graph correctly and parallelizing independent nodes with asyncio. I would apply that analysis upfront on any future multi-agent system before writing a single edge.
• Streaming intermediate agent state over WebSockets changed how the product felt: users stopped perceiving the wait as a black box and started reading it as progress. Explainability is not just a safety feature; it is a UX feature, and building it in from the start is cheaper than retrofitting it.
• Mixing deterministic scoring with LLM inference, rather than delegating everything to the model, made the system far easier to debug and audit. Knowing which layer produced a surprising ranking is the difference between fixing a bug in minutes versus hours.