H herrington.ai
All Writings & Insights
Technical Article

One Million Cars, Zero Lead Spam: What I Learned Building a Nationwide Car Inventory MCP for Personal AI Agents

📅 Published 🔄 Updated 👤 Daniel Herrington 📄 index.md
One Million Cars, Zero Lead Spam: What I Learned Building a Nationwide Car Inventory MCP for Personal AI Agents Hero Cover

A few weeks ago, I shared how our telemetry team at The Zebra uncovered a tenfold surge of 1919×992 Linux headless browsers—personal AI agents spun up by real consumers—walking our insurance quote funnels and completing applications at more than twice the rate of traditional desktop shoppers. Just today, Nicholas Lamparelli at Insurance Nerds published a follow-up conversation where we unpacked the unit economics behind that shift: why a single unchecked AI agent firing off 40 bindable quotes at up to $20 per third-party MVR/underwriting pull could saddle carriers with $800 in data expenses for a single policy, and why clean, permissioned Model Context Protocol (MCP) front doors have to replace brittle screen scraping.

Watching thousands of personal agents shop for auto insurance got me obsessing over the step that happens right before someone binds an auto policy: buying the car itself.

Nobody wakes up excited to shop for car insurance in a vacuum. People shop for insurance because they are trying to buy—or keep—a vehicle within a real household monthly budget. So on nights and weekends over the past month, I started building a side project to test what customer-first agentic commerce looks like one step upstream on the dealership lot.

Today, DealerDirect National Car Inventory MCP (app.web.dealer-direct-mcp/dealer-direct-inventory on the Official MCP Registry) indexes 1,004,686 active vehicles across 3,450 franchise and specialty dealerships in all 50 US states—spanning brand-new daily drivers, used and CPO inventory, and more than 8,400 classic and collector cars alongside live Bring a Trailer and Hagerty auction lots.

Building it taught me a lot about why legacy consumer marketplaces break when an AI agent shows up on a buyer's behalf, how to design multi-round machine-to-machine negotiation without surrendering a shopper's phone number to BDC spam, and what happens to your Google Cloud bill the night autonomous MCP directory crawlers discover your endpoint.

Why Car Shopping Breaks Personal AI Agents

Try giving Claude, ChatGPT, Meta Muse, Instinct, or OpenClaw a prompt that sounds completely reasonable to a human:

"Find me a clean one-owner 2023+ three-row SUV within 50 miles of Austin where my true all-in monthly cost—loan principal, interest, dealer fees, and insurance—stays under $700/month. Verify it's physically on the lot with two keys and get me a binding Out-The-Door price, without giving out my cell number."

If your agent tries to execute that workflow on the open automotive web today, it hits four brick walls almost immediately:

  1. Anti-Bot Walls vs. Legitimate Buyer Agents: Major listing aggregators treat consumer-delegated headless browsers identically to commercial scrapers, tripping CAPTCHAs and WAF blocks mid-search.
  2. Teaser-Price Pollution: Sort almost any automotive site by Price: Low to High and the top results aren't real cash prices. They are $299/month lease payments accidentally mapped into the MSRP field, or "price after $2,995 cash/trade equity" disclaimers buried in footer fine print. Humans squint past those traps; naive tool-calling agents hallucinate that they just found you a $4,200 Ford Bronco.
  3. Syndicated Rooftop Clones: Large dealership groups routinely syndicate a single physical used car across 12 to 20 sister store websites. An AI agent comparing "the top five options in state" often ends up comparing five clones of the exact same VIN sitting on one asphalt lot.
  4. The Unshielded Lead-Form Spam Trap: Worst of all, you cannot get an honest answer to "Is this car actually on the lot today, and what is the real Out-The-Door price?" without filling out a lead form that demands your personal phone number and email address. Submit inquiries across four dealerships to compare numbers, and your phone will ring with automated Business Development Center (BDC) dialers and drip texts for the next three weeks—long after you've already bought a car.

Just like forcing an EV driver to wrestle with a clunky CCS-to-NACS adapter, forcing a personal AI agent to scrape aggregator HTML and type its user's real phone number into lead-gen forms is an architectural mismatch. Agents need a native, zero-auth discovery layer paired with a privacy-shielded negotiation rail.

Indexing 1,004,686 Live Vehicles in Sub-50ms

To make an MCP server genuinely useful to a personal agent, partial regional coverage doesn't cut it. If a user in Boise asks for a CPO Toyota Land Cruiser within 150 miles—or an enthusiast in Miami asks for a manual-transmission air-cooled 911 anywhere in the country—the index has to be nationwide and live.

Scaling DealerDirect from an initial prototype to 1,004,686 normalized active vehicles across 3,450 dealerships required solving three data-hygiene problems before a single tool call ever reached an LLM:

1. Automated Teaser-Price Quarantine

During ingestion, every vehicle passes through price-integrity heuristics before it is eligible for default agent search. Listings advertising monthly payment figures as purchase prices, sub-$2,500 modern vehicles, or deceptive down-payment-adjusted figures are automatically flagged with price_status = 'suspect' and quarantined out of standard search_inventory rankings. When an agent sorts by price, item #1 is an actual purchasable vehicle.

2. Multi-Rooftop Syndication Deduplication

When a mega-group syndicates one physical VIN across 14 sister rooftops, our ingestion pipeline identifies the canonical originating lot and collapses the duplicate shadow listings (is_syndicated_duplicate = true). That keeps an agent's context window clean instead of burning tokens on 14 copies of the same car.

3. Hybrid PostgreSQL + Typed-Array RAM SearchAccelerator

Personal agents chain multiple tool calls inside a single reasoning turn. If search_inventory takes 2.5 seconds per call, a three-step refinement feels sluggish.

Behind the scenes, DealerDirect pairs Cloud SQL PostgreSQL 15 (using covering INCLUDE partial indexes for canonical VIN lookups and cold fallback) with an in-memory Typed-Array SearchAccelerator. On container boot, the server streams all 1,004,686 active vehicles into compact numeric arrays and dictionary-encoded make/model/trim tables—hydrating the entire nationwide catalog in ~11.5 seconds inside a 4 GiB heap footprint and serving nationwide Haversine ZIP-radius queries in under 50 milliseconds.

Sticker Price Is Half the Equation: True Monthly Cost & Insurance Chaining

Anyone who has bought a car knows that sticker price is fiction. A $31,500 crossover in a state with uncapped dealer documentation fees, $399 electronic filing charges, and $1,495 in pre-installed nitrogen/tint add-ons costs thousands more out the door than a $32,200 vehicle at a transparent store—before you even factor in what that specific VIN costs to insure.

Because I spend my days thinking about insurance comparison infrastructure, designing the canonical vehicle schema around True Monthly Cost was non-negotiable. Every vehicle returned by search_inventory and get_vehicle includes two structured blocks alongside mechanical specs, Carfax links, and VDP provenance:

  1. Itemized fee_breakdown: Surfaces known dealership documentation fees (doc_fee_usd), state electronic filing fees (electronic_filing_fee_usd), and historical mandatory add-on behavior (mandatory_addons_usd). Better yet, this isn't static guesswork: every time a dealership submits a binding quote through our Deal Desk, a closed-loop Fee Intelligence pipeline compares their real quoted fees against our stored records—automatically awarding a verified_clean_otd_badge to transparent stores that quote zero hidden add-ons.
  2. Pre-Formatted insurance_quote_payload: Every vehicle exposes a clean, vendor-neutral JSON payload (year, make, model, submodel, vin, body_style, annual_mileage: 12000, ownership: "NOT_YET_PURCHASED") ready to pass straight into an insurance comparison tool or licensed advisor workflow. 
{
  "vin": "5TDKRKEC9PS148201",
  "price_usd": 36450,
  "fee_breakdown": {
    "doc_fee_usd": 225,
    "electronic_filing_fee_usd": 35,
    "mandatory_addons_usd": 0,
    "verified_clean_otd_badge": true
  },
  "insurance_quote_payload": {
    "year": 2023,
    "make": "Toyota",
    "model": "Sienna",
    "submodel": "XLE AWD",
    "vin": "5TDKRKEC9PS148201",
    "body_style": "Minivan",
    "annual_mileage": 12000,
    "ownership": "NOT_YET_PURCHASED"
  }
}

Instead of treating the car purchase and the insurance policy as two disconnected chores—where a shopper only discovers at the finance desk that insurance on trim B costs $95/month more than trim A—a personal AI agent can compute Principal + Interest + Dealer Fees + Insurance before the buyer ever steps foot on a lot.

Buyer Shield: Multi-Round Negotiation Without Giving Out Your Phone Number

Discovery is read-only. Negotiation is where things get adversarial—and where consumer privacy usually evaporates.

To let a personal AI agent verify physical lot status and negotiate a real Out-The-Door (OTD) price without exposing the buyer to weeks of spam, I built Buyer Shield: an asynchronous, consent-gated proxy relay between the shopper's AI agent and the dealership's sales desk.

Here is how the protocol works in practice:

Postscript: What Happens the Night You Hit the Official MCP Registry

I'll end with my favorite operational surprise from the first week in production—because if you are deploying public Streamable HTTP MCP servers on serverless infrastructure right now, it will save you real money.

On November 2, right after dealer-direct-inventory went live on registry.modelcontextprotocol.io, my Google Cloud Run billing chart suddenly went vertical—jumping from pennies a day to roughly $7.60/day (~$230/month run rate) overnight.

My first assumption was a spike in human car shoppers or runaway database queries. When I pulled the Cloud Run request logs, it was neither.

Within hours of appearing on the Official MCP Registry, an entire autonomous ecosystem of third-party MCP directory indexers, security scanners, and uptime monitors had discovered our /mcp endpoint and begun running initialize + tools/list health probes on a clockwork 5-minute cadence, 24 hours a day:

Each JSON-RPC probe completed in 4 milliseconds. So why was Cloud Run billing $7.60 a day?

Because during early ingestion benchmarking, the service had been deployed with --no-cpu-throttling (Instance-Based Billing) on a 4 vCPU / 8 GiB container. Cloud Run's default idle scale-down window is 15 minutes. A 4ms bot ping arriving every 5 minutes meant the container never scaled to zero—billing 4 full vCPUs for 86,363 active seconds out of 86,400 seconds every single day while sitting 99.9% idle!

Flipping a single architectural switch—enabling Request-Based Billing (--cpu-throttling) with --cpu-boost and right-sizing the typed-array heap to 2 vCPU / 4 GiB—inverted the economics overnight:

  1. Under Request-Based Billing, Google Cloud does not bill for idle memory residency between requests; you only pay for CPU/memory during the 4ms window a request is actively executing (well inside the monthly free tier).
  2. Meanwhile, because those polite MCP Registry monitors still ping /mcp every 5 minutes, they keep the Cloud Run container warm in RAM 24/7 for free—meaning real human car shoppers get instant <50ms queries across 1,004,686 warm in-memory vehicles without ever hitting an 11-second cold start.

What started as a serverless billing footgun turned into a zero-dollar global cache warmer, courtesy of the emerging agentic web.

Try It With Your Own Agent

You don't need an API key or a developer config file to test this. Just drop the prompt below into Claude, ChatGPT, Meta Muse, Instinct, OpenClaw, or any MCP-capable personal agent (swapping in your own ZIP code, vehicle, and monthly budget):

"Connect to the public DealerDirect MCP server at https://dealer-direct-mcp.web.app/mcp (no API key required). Search within 50 miles of ZIP 78701 for clean used or CPO 2023+ three-row SUVs under $38,000. Pull the itemized fee_breakdown and insurance_quote_payload for the top 3 matches, rank them by real Out-The-Door cost rather than sticker price, and flag any dealerships with high doc fees or mandatory add-ons. Do not share my personal contact info with any dealer."

Or, if your weekend tastes run closer to mine:

"Using the DealerDirect MCP server at https://dealer-direct-mcp.web.app/mcp, search nationwide across specialty classic dealers and live collector auctions for a manual-transmission 1980s–1990s Porsche, BMW, or Land Cruiser under $55,000, and summarize the top 5 candidates with direct listing links."

Explore the full tool specification and architecture on the DealerDirect MCP Project Showcase, inspect the live manifest on the Official MCP Registry, or read the companion piece on The 1919×992 Footprint and today's Insurance Nerds interview on how personal AI agents are reshaping regulated commerce.

Views expressed here are my own and not those of my employer or any affiliated organization. DealerDirect MCP is an independent personal software project built to explore agentic commerce protocols.

Model Context ProtocolAgentic CommerceAI AgentsInsurTechSystems Architecture

Interested in discussing this topic?

Connect with me to exchange ideas on AI product management, machine learning systems, or engineering leadership.

Connect on LinkedIn Explore All Writings