Negotiator AI

Negotiator AI is an autonomous agent that discovers local vendors, places live conversational phone calls, extracts itemized prices, and negotiates binding price discounts using AI leverage strategies

Comment

Negotiator AI

The problem

Getting a fair price should not require becoming a part-time procurement specialist. Yet hiring a contractor, buying a laptop, planning a wedding, or sourcing a business service often means chasing vendors, repeating the same brief, comparing vague totals, and hoping the lowest number does not hide the most expensive surprise.

Negotiator AI is a voice-first procurement agent that turns that messy process into one auditable workflow: discover relevant local businesses, call approved contacts, turn spoken answers into comparable quotes, and use verified pricing as negotiation leverage.

What we built

A user can describe a need by voice or upload an existing quote, invoice, PDF, or PNG. Negotiator AI then:

  1. Builds one locked brief - captures the requirements that every vendor should receive so the comparison stays fair.
  2. Discovers local options - searches Google Places for nearby businesses, including address, rating, maps link, and business phone data.
  3. Runs live outbound conversations - uses ElevenLabs Conversational AI and Twilio to contact approved, consented demo participants for a real phone-call experience.
  4. Tracks real call outcomes - distinguishes calling, processing a completed call, no answer, a documented decline, and a quote received.
  5. Creates evidence-backed quote records - extracts only amounts explicitly spoken in the transcript, flags missing terms, and keeps the transcript beside the resulting quote.
  6. Finds negotiation leverage - selects the lowest comparable verified quote and uses it to request a price match or measurable added value from the higher-priced vendor.
  7. Produces an executive comparison - presents line items, totals, terms, red flags, and savings in one decision-ready report.

For the live demo, calls are deliberately limited to three verified, consented participants. That keeps the experience safe and testable while showing the same orchestration pattern a production, user-approved vendor-calling workflow would use.

Why Codex and GPT-5.6 mattered

Codex was not a one-time autocomplete tool for this project. It was the engineering partner that let us turn a deceptively simple idea - “call multiple vendors and compare prices” - into a real, failure-aware system.

Using Codex with GPT-5.6, we designed and implemented:

  • the Next.js App Router API surface for discovery, call initiation, call status, webhooks, negotiation, and reporting;
  • the TypeScript domain model that preserves a locked job brief, call state, transcript, quote, leverage, and audit output;
  • the event-driven call lifecycle that reconciles Twilio telephony state with ElevenLabs post-call transcripts;
  • durable cross-instance call storage for serverless deployment, so a webhook can update the same call that initiated in a different function instance;
  • guardrails that prevent invented prices: quotes only use values stated in the source transcript, and incomplete calls remain declines rather than fabricated estimates;
  • the responsive six-vendor discovery and three-call experience, including explicit Not picked up and Processing quote states.

GPT-5.6 was especially valuable for reasoning across these connected constraints: asynchronous webhooks, serverless persistence, telephony failure states, and a UI that must remain honest when a vendor does not answer or a transcript is delayed. Codex accelerated implementation, but every workflow was reviewed, tested, and shaped around the real system behavior.

How we built it

  • Product and frontend: Next.js 16, React 19, TypeScript, Tailwind CSS
  • Voice and telephony: ElevenLabs Conversational AI and Twilio outbound calling
  • Discovery: Google Places API (New Text Search)
  • Quote intelligence: structured transcript normalization with evidence constraints
  • Reporting: GPT 5.6-generated executive report from the collected quote and negotiation data
  • Reliability: Redis-compatible durable state for webhooks and serverless status polling

The hard parts

Voice calls do not end when the UI thinks they do

A phone can ring forever, go unanswered, be cut short, or finish while its transcript is still being processed. We had to model those states separately. The interface now stops pretending every call is active: Twilio status reconciliation surfaces Not picked up and Processing quote, while the transcript webhook supplies the final evidence.

“A price” is not a comparable quote

A vendor saying one number is not enough. We needed scope, fees, validity, binding terms, and exclusions. The system treats absent details as absent details. It does not fill the gap with an AI guess.

Serverless webhooks need durable memory

An outbound call can begin in one Vercel function and finish in another. In-memory state loses that connection. We added durable call records keyed by the internal call ID and provider conversation identifiers so callbacks can recover the right quote workflow.

What we learned

The most exciting lesson was that useful agents are not just chat interfaces with a phone number. They need a trustworthy state machine, evidence boundaries, graceful failure handling, and a product experience that explains uncertainty instead of hiding it.

Negotiator AI is our answer to a practical question: what if everyone had a procurement officer that could do the calling, keep the receipts, and still let the human make the final decision?

Built With

Share this project:

Updates