BidBot

The AI that calls every contractor simultaneously, negotiates the best price, and books the winner — so homeowners never overpay again.

Comment

Inspiration

It started with a real moment. A friend's kitchen sink started leaking at 8pm on a Tuesday. She called three plumbers, got wildly different quotes, had no idea which was fair, and just picked one. She overpaid by $180.

That happens to millions of homeowners every year. 83% faced unexpected home repairs in 2024. 60% are putting off necessary repairs right now because of cost. And almost nobody negotiates, they just accept the first price they're given.

The reason is simple: negotiating with contractors takes time, confidence, and knowledge of market rates that most people don't have. Large property management companies have staff who do this full time. Regular homeowners have nothing.

That gap is what inspired BidBot. What if AI could negotiate for you — simultaneously, instantly, and smarter every time?

What it does

BidBot is an AI repair negotiation agent for homeowners. Here's the full flow:

  1. Describe the issue — type it out, use the microphone, or upload a photo of the problem
  2. AI diagnoses — Gemini Vision analyzes the photo alongside the text description to identify the repair type, urgency level, risk score out of 10, and expected cost range
  3. Groq answers follow-up questions — two clarifying questions with multiple choice answers to sharpen the diagnosis
  4. Find real contractors — Perplexity Sonar searches the live web for licensed contractors near the user's zip code
  5. Deploy the negotiation swarm — ElevenLabs Conversational AI agents call every contractor simultaneously via Twilio. Each agent is armed with the contractor's quote, their negotiation history from Google Sheets, and a smart negotiation script that references past rates and competitor pricing
  6. Results in real time — swarm cards resolve one by one as calls complete. The agreed prices update from the actual transcript
  7. Book the winner — one tap books the cheapest contractor

Every step is logged to Google Sheets across six tabs: submissions, diagnoses, contractors found, negotiations, call transcripts, and contractor profiles. Over time, BidBot builds a memory of every contractor it has ever negotiated with — their pickup rate, how cooperative they are, what they actually settled for last time.

How we built it

Frontend: Next.js 14 with a fully custom design system — no UI library. Light mode with a yellow-green accent palette, progressive section reveal as the user moves through the flow, animated risk gauge, animated savings counter, and a swarm view showing all contractors negotiating simultaneously.

AI layer:

  • Gemini Vision (Google) — multimodal diagnosis, analyzes photos of the repair issue
  • Groq / LLaMA 3.3 70B — clarifying questions, diagnosis reasoning, contractor price estimates, negotiation simulation, and post-call transcript summarization
  • Perplexity Sonar — live web search to find real local contractors by trade type and zip code

Voice layer:

  • ElevenLabs Conversational AI — a custom agent with a negotiation-focused system prompt, dynamic variables injected per call (contractor name, their quote, budget, history), deployed as outbound calls via the ElevenLabs API
  • Twilio — phone infrastructure for outbound calling

Memory layer:

  • Google Sheets — six-tab logging system. Contractor profiles accumulate over time: total calls, pickup rate, attitude score (cooperative / resistant / refused), times booked, average negotiated savings

Infrastructure:

  • Google Cloud Run — containerized Next.js deployment
  • ElevenLabs post-call webhook — after every call, the transcript is POSTed to our API, Groq summarizes it and extracts the agreed price, and the result is logged to Sheets

Challenges we ran into

Toll-free number blocking. When we first set up Twilio, we were assigned an 877 toll-free number. Outbound calls from toll-free numbers to mobile phones are automatically blocked by most US carriers as suspected spam. We debugged this for hours before realizing the number type itself was the problem. Switching to a local 510 area code number fixed it immediately.

ElevenLabs + Twilio authentication. The ElevenLabs outbound call API requires the phone number to be imported into their platform, not just referenced by number. The agent_phone_number_id is a separate identifier from the actual phone number string. Getting the two systems handshaking correctly took significant trial and error.

Dynamic variables in the agent prompt. Getting the agent to correctly receive and use per-call context (contractor name, their specific quote, negotiation history) required understanding how ElevenLabs passes conversation_initiation_client_data and configuring the agent's variable bindings in the dashboard to match the keys sent by the API.

TypeScript strictness on Cloud Run. The app ran fine locally but failed to build on Cloud Run because of TypeScript type mismatches we hadn't caught — specifically missing required fields on a logConversation call. Production builds are stricter than next dev.

Gemini quota limits. The free tier Gemini API hit quota limits during development. We solved this by using Groq as the primary reasoning engine (faster and more generous free tier) and keeping Gemini only for the vision/photo diagnosis step where multimodal capability is actually needed.

Accomplishments that we're proud of

  • Real phone calls. The ElevenLabs agent actually calls, actually speaks, actually negotiates. This isn't a simulation — it's a live AI voice on the phone arguing your corner.

  • Swarm architecture. All contractors are called simultaneously. They compete. The UI shows all of them negotiating in parallel, resolving one by one. Judges can watch it happen in real time.

  • Contractor memory. Google Sheets isn't just a log — it's a negotiation database. The agent references past rates mid-call: "Last time you handled similar work for us you came in at $195, why is it $290 now?" That's genuinely powerful.

  • Multimodal input. Users can type, speak, or photograph their repair issue. All three input modes work and feed into the same diagnosis pipeline.

  • Full-stack in 24 hours. Six AI integrations, real phone calls, persistent memory, deployed to Google Cloud Run, with a polished UI — all built solo at a hackathon.

What we learned

  • Toll-free numbers and outbound calls don't mix. Local area code numbers have dramatically higher answer rates and fewer carrier-level blocks. This matters a lot for any AI calling product.

  • ElevenLabs Conversational AI is genuinely impressive. The agent handles interruptions, adjusts tone based on the contractor's responses, and sounds completely natural. The gap between TTS (text-to-speech) and a real conversational agent is enormous.

  • System prompts are product decisions. The negotiation script isn't just a prompt — it's the entire product experience. The ending ("I need to confirm with the owner and will call you back") is what makes it feel like a real property manager, not a bot.

  • Google Sheets as a database is underrated for hackathons. It's free, visible in real time, no setup, and judges can literally watch rows populate during the demo. That's a better demo prop than any database dashboard.

  • TypeScript saves you in production. The type error that broke the Cloud Run build caught a real bug. Running tsc --noEmit locally before deploying would have saved 20 minutes.

What's next for BidBot

Short term:

  • Radius slider so users can choose how far out to search for contractors
  • Contractor rating marketplace — homeowners can leave reviews after jobs
  • Predictive pricing engine — BidBot learns what a fair price is for any repair in any zip code

Medium term:

  • Mobile app — the use case is inherently mobile (you're standing in front of a broken sink)
  • Omi voice wearable integration — describe the issue hands-free while looking at it
  • Insurance claim automation — BidBot files the claim alongside booking the repair

Long term:

  • Enterprise tier for property management companies
  • HOA management integration
  • Contractor SLA tracking — did they show up on time? Did they fix it right?

The core insight is that BidBot gets smarter with every call. Every negotiation adds to the contractor database. Over time it knows exactly how low each contractor will go, what time of day they answer, and whether they keep their word. That compounding intelligence is the real moat.

Built With

Share this project:

Updates