CarCoach — AI Car Deal Analyzer

AI agent that analyzes used car listings against live market comps, rates the deal, and hands you a word-for-word negotiation script with a specific counteroffer price.

Comment

Inspiration Americans overpay billions on used cars every year — not because they're uninformed, but because they lack access to real-time market data and don't know how to negotiate. Dealers have that data. Buyers don't. CarCoach closes that gap.

We wanted to build something that creates immediate, measurable value. Not a chatbot. Not a dashboard. An agent that ingests a listing, does the research, makes a judgment call, and gives you something actionable — the exact sentence to say to a dealer to save thousands of dollars.

What It Does CarCoach is a three-stage AI pipeline:

Parse — Paste a listing URL or raw text. An LLM extracts structured fields: year, make, model, trim, mileage, asking price, location. Research — Live market comps are fetched via Tavily web search, calibrated to your state. If Tavily is unavailable, a static table of 20 popular models with year-based depreciation serves as fallback. Analyze — Nemotron-3-Nano-30B on Crusoe Cloud evaluates the deal against comps and returns: Deal rating: Great Deal / Fair Deal / Overpriced / Major Overpriced Price delta: exact dollars above or below market mid Red flags and green flags Days-on-market signal Counteroffer price and a word-for-word negotiation script Every layer has a fallback. LLM fails → gpt-4o-mini on OpenAI Direct. Tavily fails → static comp table. Listing parse fails → regex heuristics. The agent never hard-crashes.

How We Built It Agent framework: LangGraph StateGraph with three nodes — scrape_node, research_node, analyze_node — connected by conditional edges that route to handle_error_node on any failure.

LLM routing: TrueFoundry AI Gateway routes to Nemotron-3-Nano-30B-A3B-FP8 on Crusoe Cloud as primary. Any exception triggers automatic fallback to gpt-4o-mini via OpenAI Direct. Both paths are fully independent — a TrueFoundry outage cannot affect the fallback route.

Market data: Tavily Search API pulls live comparable listings. The query is constructed dynamically: {year} {make} {model} used car price {state} 2025 2026. Dollar amounts are extracted with regex, filtered to plausible vehicle range ($5k–$150k), trimmed of extremes, and collapsed to low/mid/high.

Scraping: httpx with browser headers + BeautifulSoup4 for URL-based listings. LLM extraction for structured field parsing with regex fallback.

Data models: DealAnalysis as a Pydantic BaseModel for strict schema enforcement. CarAgentState as a TypedDict for the LangGraph state.

UI: Streamlit with a Chaos Mode toggle (invalidates TrueFoundry key at runtime), deal rating banner, metrics row, flag columns, negotiation script, and a provider waterfall showing every model attempt per stage.

API: FastAPI wrapper for programmatic access — POST /analyze, GET /health.

Challenges Real-world car sites block scrapers. AutoTrader, Carvana, CarMax all return 403 or bot challenges. Solved by making paste-text the primary demo path — more reliable and faster.

Tavily returned current market prices. The fallback comp table was calibrated to 2023 prices. When Tavily runs, the market data is live — which means "overpriced" thresholds shift. Adjusted the demo listing price to reflect a realistically overpriced scenario against current comps.

LLM JSON extraction is fragile. Nemotron and gpt-4o-mini both occasionally return markdown-fenced JSON or extra text. Solved with aggressive fence-stripping and a Pydantic schema that validates every field before the result surfaces to the UI.

TrueFoundry network access. The corporate network we developed on blocks the TrueFoundry gateway domain entirely (TLS handshake timeout). Proved resilience by recording the fallback path as the demo — which is also the more compelling story.

Accomplishments Three-layer fallback architecture: every component has an independent failure path Live market comps via Tavily with a calibrated static table as safety net Negotiation script generation grounded in specific dollar amounts from real data Chaos Mode that breaks the primary AI provider live — demonstrating resilience in real time Full LangGraph pipeline from raw text to structured DealAnalysis in under 20 seconds FastAPI + Streamlit running off the same agent core What We Learned Resilience isn't a feature you bolt on — it's a structural decision made at the graph level. LangGraph's conditional edges make it natural to route around failures without try/catch spaghetti. Every node either succeeds and advances state, or flags an error and hands off to a handler. That pattern scales to any agentic system.

We also learned that real-world data makes demos honest. Tavily returning live 2025 prices forced us to rethink the sample listing — and the result is a more credible product, not a rigged demo.

What's Next VIN lookup — decode vehicle history and flag salvage titles or odometer rollbacks automatically Multi-listing comparison — analyze 3–5 listings side by side and rank them Negotiation coach — interactive mode where CarCoach responds to counter-offers in real time Mobile — React Native wrapper over the FastAPI endpoint

Built With

  • beautifulsoup4
  • cloud
  • crusoe
  • fastapi
  • httpx
  • langgraph
  • nemotron-3-nano-30b
  • pydantic
  • python
  • streamlit
  • tavily
  • truefoundry
Share this project:

Updates