RoadPilot

An explainable AI co-driver that turns real travel constraints into a vehicle-aware road-trip plan you can actually drive.

Comment

Project story

Inspiration

Planning a real road trip is not the same as finding the shortest route. The vehicle, remaining battery or fuel, children, pets, weather, budget, and rest cadence all change what a good plan means. Today, travelers usually combine those decisions manually across maps, charging or fuel apps, weather, place search, and notes.

I built RoadPilot to make that fragmented decision explainable and actionable in one place.

What it does

RoadPilot turns a natural-language request and a selected My Car profile into a route-backed trip plan. It supports seven server-owned vehicle profiles across Electric, Hybrid, and Gas powertrains and Car, Pickup, Camper, and Motorcycle vehicle types.

The product provides:

  • a Quick Plan connected to real route, weather, place, and energy evidence;
  • charging or refueling stops based on the selected vehicle and remaining energy;
  • a Why view that links each recommendation back to the map;
  • a Trace view showing which tools ran and whether evidence succeeded;
  • an optional Detailed itinerary that stays collapsible on mobile;
  • Before/After What-if comparisons without restarting the conversation; and
  • a drive simulation that follows the actual plan polyline.

The demo begins with a Toyota RAV4 Hybrid at 70% fuel. A single What-if switches the same trip to a Ford F-150 Gas Pickup. RoadPilot keeps the verified 7h 30m route, rebuilds the refueling plan, and exposes the measured trade-off: fuel demand changes from 41.2L to 73.5L and cost increases by $34.50.

How I built it

RoadPilot separates qualitative AI decisions from numerical integrity.

GPT-5.6 understands and selects
        ↓
Route, weather, place, and energy tools provide evidence
        ↓
Deterministic code assembles the plan
        ↓
Validators enforce coordinates, energy, budget, and rest constraints
        ↓
RoadPilot explains the result

GPT-5.6 is used through Azure OpenAI for structured context extraction, candidate selection, supported free-form What-if interpretation, and the optional Deep Plan explanation pass. Route geometry, distance, travel time, charging or fuel quantities, core cost calculations, and Before/After arithmetic are owned by tools and deterministic code.

The frontend is Next.js and TypeScript on Vercel. The FastAPI backend runs on Azure Container Apps, with Cosmos DB for validated plan, artifact, What-if, and detail caches. Anonymous plans use scoped 256-bit access grants and seven-day retention.

How I used Codex

I used OpenAI Codex as a development and verification partner throughout the project, not only for code completion. Codex helped me:

  • translate architecture decisions into backend and frontend contracts;
  • diagnose production latency from live traces before changing the planner;
  • build deterministic assembly and validation paths around GPT-5.6;
  • add contract tests for seven vehicle profiles, What-if boundaries, access grants, and retention;
  • automate the mobile demo with Playwright and verify rendered states; and
  • run tests, inspect deployments, and keep the implementation and submission documentation aligned.

The offline gate currently runs 111 backend tests plus the frontend TypeScript check without external API keys.

Challenges I ran into

The hardest challenge was preventing a capable model from becoming the owner of trip physics. Early designs made it too easy for generated numbers and tool evidence to drift apart. I changed the contract so the model selects registered candidates and deterministic code assembles and validates the final plan.

Latency was another challenge. A full replan for every What-if was too slow and wasteful. RoadPilot now persists PlanArtifacts, reuses the verified route, and recomputes only affected fuel, stop, timing, or cost fields for common canonical changes.

Finally, a public anonymous demo still needs an access boundary. Plan IDs alone are not credentials, so RoadPilot stores only a hash of a per-tab access token and applies a seven-day Cosmos TTL.

Accomplishments that I am proud of

  • Shipping a live product on Vercel and Azure rather than a static prototype.
  • Making every important stop inspectable through Why, Trace, and the map.
  • Supporting seven distinct vehicle profiles with server-owned specifications.
  • Turning Hybrid to Gas Pickup into a deterministic, measurable What-if diff.
  • Keeping the mobile Detailed itinerary readable and collapsible.
  • Producing a repeatable two-minute demo with automated browser capture and verified voice-over.

What I learned

The most useful AI architecture is not the one that gives the model the most control. It is the one that makes responsibility visible. GPT-5.6 is strongest at understanding human constraints and choosing between trade-offs. Tools and code are stronger at coordinates, energy, arithmetic, and invariants. The product became both more trustworthy and easier to debug after those roles were separated.

What's next for RoadPilot

The next steps are saved and shareable trips, real account recovery across devices, live vehicle integrations, collaborative planning, and navigation handoff. The same constraint-aware planning layer could also support rental-car selection, mobility concierges, and fleet trip preparation.

Built With

Share this project:

Updates