Faro | Devpost

Faro's Specifications Sheet
Faro's System Architecture
Faro's ElevenLabs Intake
Faro's PDF Export Example

Inspiration

Commercial insurance for small businesses is broken. Getting coverage takes 5-7 days of back-and-forth with human brokers, pages of confusing jargon, and mountains of paperwork. A daycare owner, a restaurant operator, a contractor- they just want to know what they need, how much it costs, and where to get it. For people trying to build their own business, startup or not, this is a huge barrier that is often forgotten.

We built Faro to compress that entire workflow into under two minutes, powered by an autonomous AI agent that reasons like a broker.

We chose to build natively on iOS and iPadOS because we believe the future of AI applications is on-device. Today, Faro runs inference through cloud APIs, but native Swift architecture positions the app for a world where models run directly on the device with no data leaving the phone. For a product handling sensitive business financials, employee counts, and revenue data, that privacy guarantee matters.

What it does

A business owner opens Faro on their iPhone or iPad, describes their company in plain English, and within two minutes receives a complete insurance analysis. There are two intake modes:

Guided Questionnaire: A one-question-at-a-time onboarding flow that walks the user through business name, description, employee count, state, and revenue.
Conversational Voice Intake: The user simply talks to Faro. An ElevenLabs Conversational AI agent conducts a natural voice interview, and the transcript is automatically converted into structured intake data by Gemini.

Once intake is complete, Faro's four-step AI agent pipeline—powered by Google Gemini and orchestrated with LangGraph—runs autonomously:

Risk Profiler: Profiles risk exposure and regulatory requirements.
Coverage Mapper: Maps required, recommended, and projected insurance coverages with premium estimates.
Submission Builder: Generates a carrier-ready submission packet.
Explainer: Writes a plain-English explanation of everything.

The user watches this happen in real time via a live WebSocket-driven agent tracker.

The output includes a full coverage dashboard with interactive charts, a spoken voice summary generated by ElevenLabs TTS, a professional PDF submission document exportable via the native iOS share sheet, and a home screen widget showing live coverage status. All sessions are persisted in MongoDB Atlas, and user authentication is handled securely through Auth0. A marketing landing page directs users to download the native app.

(Check our website below! In addition, PLEASE review our README on GitHub for additional technical information)

How we built it

Native iOS & iPadOS App (SwiftUI)

The entire frontend is a native Swift application with adaptive layouts for both iPhone and iPad (sidebar-adaptable navigation on iPadOS 18+). We chose native development deliberately—beyond the immediate UX benefits, a native Swift codebase is architecturally ready for on-device model inference as Apple's ML frameworks mature, enabling a future where sensitive business data never leaves the device.

Google Gemini (Primary AI)

Gemini powers every reasoning step in the pipeline. We use gemini-3-flash-preview as the primary model with gemini-2.5-flash as a fallback. Gemini was chosen for its structured JSON output reliability, fast inference speed necessary for our sub-two-minute target, and its ability to handle complex multi-step reasoning across risk profiling, coverage mapping, submission generation, and plain-English explanation. Gemini also powers the post-processing of ElevenLabs voice transcripts into structured intake data.

ElevenLabs (Voice AI — Conversational + TTS)

ElevenLabs serves two distinct roles:

Conversational AI: Powers Faro's voice intake mode. A live WebSocket connection streams bidirectional audio between the iOS app and an ElevenLabs agent that conducts a natural insurance intake interview.
Text-to-Speech API: Converts the final plain-English coverage summary into spoken audio so users can listen to their results hands-free.

We used ElevenLabs because the voice quality is indistinguishable from a real broker, and the Conversational AI SDK enabled a true voice-first experience without building our own ASR + TTS stack.

MongoDB Atlas (Persistence)

MongoDB stores all session state, pipeline results, and audio data. We chose MongoDB because the schema-flexible document model naturally fits our use case—each session accumulates nested JSON from four different agent steps, and the structure can vary significantly between different business types. MongoDB Atlas gave us a managed, scalable database with zero operational overhead during a hackathon. We also built an in-memory fallback layer so the app degrades gracefully if the database is unreachable.

Auth0 (Authentication)

Auth0 handles user authentication end-to-end. The iOS app uses the Auth0 Swift SDK for native login, and the FastAPI backend verifies JWT tokens via Auth0's JWKS endpoint. Auth0 was essential because Faro handles sensitive business data (revenue, employee counts, contact information), and we needed production-grade security without building our own auth system. Every API endpoint and WebSocket connection is protected by Auth0 token verification.

LangGraph Agent Pipeline

Four sequential agent steps—Risk Profiler, Coverage Mapper, Submission Builder, Explainer—orchestrated as a state graph. Each step broadcasts progress over WebSocket so the iOS app can show the agent reasoning in real time.

Hybrid Premium Estimation

A deterministic rules-based pricing engine blends 70% actuarial-style formulas with 30% Gemini estimates across 12+ policy types (workers' comp, general liability, cyber, EPLI, and more), producing grounded premium ranges rather than pure LLM hallucination.

Marketing Website

A polished landing page built to present Faro's value proposition and direct users to the native app.

Challenges we ran into

ElevenLabs Conversational AI integration: This was our most demanding technical challenge. Getting bidirectional audio streaming over WebSocket from a native iOS client to the ElevenLabs platform required 10 iterative rounds of debugging—protocol handshake details, audio format negotiation, source_info enum values, and transcript extraction all needed careful attention. The commit history tells the story: "elevenlabs fixes 1" through "elevenlabs fixes 10" spanning 7+ hours of the build.
Auth0 coordination: The Auth0 Swift SDK generates redirect URLs based on the app's bundle identifier, and each URL must be allow-listed in the Auth0 dashboard. Coordinating tenant configuration, JWT audience/domain settings, and token verification between the native client and FastAPI backend took multiple hours and several team members working in parallel before the full login flow worked reliably.
Gemini JSON reliability: Getting Gemini to consistently produce clean, parseable structured JSON for risk profiles, coverage mappings, and submission packets—especially handling edge cases like empty responses, hallucinated loss histories, and inconsistent coverage category types—meant wrapping every LLM call in timeout, fallback, and validation logic.
Parallel development: Three contributors across iOS and Python simultaneously generated constant merge conflicts. We pushed 85+ commits in under 24 hours, and reconciling UI redesigns with backend API contract changes happening at the same time required careful coordination.

Accomplishments that we're proud of

Built a complete, production-quality native iOS and iPadOS application with a Python AI backend in under 16 hours with a three-person team.
Real-time WebSocket streaming that shows the AI agent reasoning through each pipeline step live—users watch it think, not stare at a spinner.
Two full intake modes: A guided questionnaire and a voice conversational agent powered by ElevenLabs, both feeding into the same analysis pipeline.
A hybrid premium estimation engine blending deterministic actuarial rules with Gemini reasoning to produce defensible, grounded numbers across 12+ insurance policy types.
Professional PDF generation and export via the native iOS share sheet—users can AirDrop a carrier-ready submission document directly from the app.
Spoken voice summaries via ElevenLabs TTS that explain coverage recommendations in plain English.
A WidgetKit home screen widget displaying live coverage status, polled from MongoDB-backed session data.
Adaptive iPad navigation using iOS 18's sidebar-adaptable tab view alongside iPhone's standard tab bar.
Auth0-secured authentication protecting every API endpoint and WebSocket connection.
A one-question-at-a-time onboarding flow with animated transitions, state autocomplete search, and pre-filled demo mode.
Persistent session storage in MongoDB Atlas with graceful in-memory fallback.
A polished marketing landing page directing users to the native application.
A complete coverage dashboard with Swift Charts showing premium estimates, confidence scores, and category breakdowns.
Coverage detail sheets with carrier suggestions, trigger events for projected policies, and low/mid/high premium ranges.

What we learned

Gemini's structured output is powerful but requires defensive engineering: Wrapping every call in timeout/fallback logic and JSON schema validation was essential for a demo that could not afford to fail. The dual-model fallback strategy proved critical.
ElevenLabs Conversational AI opens up an entirely new interaction paradigm: Voice-first intake is dramatically more natural than typing on a phone, but integrating bidirectional WebSocket audio streaming from a native iOS client is a non-trivial engineering challenge that required deep protocol-level debugging.
MongoDB's document model was the right choice: For AI agent pipelines where each session accumulates heterogeneous nested JSON from multiple steps, the flexibility to store varying structures without schema migrations saved significant development time.
Auth0 eliminates the build-vs-buy decision for authentication: However, coordinating the iOS SDK with backend JWT verification across different device configurations and bundle identifiers has a real learning curve.
Native development positions you for the future: Building in Swift with a clean separation between the AI reasoning layer and the presentation layer means Faro is architecturally ready for on-device inference. As models become efficient enough to run locally, the entire pipeline could execute without any data leaving the user's device.
Real-time WebSocket architecture creates a dramatically more compelling UX: Streaming AI pipeline progress is vastly superior to a loading spinner. Watching the agent work step by step is the demo moment that makes the product feel alive.

What's next for Faro

On-device inference: As Apple Silicon and on-device model frameworks mature, we plan to migrate the Gemini-powered reasoning pipeline to run entirely on the iPhone and iPad. Zero data leaves the device—true privacy for sensitive business financials.
Carrier API integrations: Connect to real insurance carrier quoting APIs so Faro returns bindable quotes, not just estimates.
Proactive risk monitoring: Leverage the WidgetKit foundation to continuously monitor a business's risk profile and alert owners when coverage gaps emerge (e.g., new hires, revenue changes, regulatory updates).
Document upload and OCR: Let users photograph existing policies so Faro can identify gaps in their current coverage rather than starting from scratch.
Multi-state and multi-location support: Extend the risk profiler to handle businesses operating across state lines with different regulatory requirements.
Broker marketplace: Once Faro identifies coverage needs, connect business owners directly with brokers who specialize in their industry and risk profile.